projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Make sure to not overflow
[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 RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define MACHINE_READABLE 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 0
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
152
153 #define NVIDIA_100PERCENTCPU_WORKAROUND 100
154
155 #define global_free(attr) \
156 { \
157 myfree ((void *) data.attr); \
158 \
159 data.attr = NULL; \
160 }
161
162 #define local_free(attr) \
163 { \
164 myfree ((void *) attr); \
165 \
166 attr = NULL; \
167 }
168
169 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
170 #define HC_API_CALL __stdcall
171 #else
172 #define HC_API_CALL
173 #endif
174
175 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
176 {
177 900,
178 0,
179 5100,
180 100,
181 1400,
182 10800,
183 1700,
184 5000,
185 10100,
186 6000,
187 6100,
188 6900,
189 11700,
190 11800,
191 400,
192 8900,
193 11900,
194 12000,
195 10900,
196 12100,
197 23,
198 2500,
199 5300,
200 5400,
201 5500,
202 5600,
203 7300,
204 7500,
205 13100,
206 8300,
207 11100,
208 11200,
209 11400,
210 121,
211 2611,
212 2711,
213 2811,
214 8400,
215 11,
216 2612,
217 7900,
218 21,
219 11000,
220 124,
221 10000,
222 3711,
223 7600,
224 12,
225 131,
226 132,
227 1731,
228 200,
229 300,
230 3100,
231 112,
232 12300,
233 8000,
234 141,
235 1441,
236 1600,
237 12600,
238 1421,
239 101,
240 111,
241 1711,
242 3000,
243 1000,
244 1100,
245 2100,
246 12800,
247 1500,
248 12400,
249 500,
250 3200,
251 7400,
252 1800,
253 122,
254 1722,
255 7100,
256 6300,
257 6700,
258 6400,
259 6500,
260 2400,
261 2410,
262 5700,
263 9200,
264 9300,
265 22,
266 501,
267 5800,
268 8100,
269 8500,
270 7200,
271 9900,
272 7700,
273 7800,
274 10300,
275 8600,
276 8700,
277 9100,
278 133,
279 13500,
280 11600,
281 13600,
282 12500,
283 13000,
284 13200,
285 13300,
286 6211,
287 6221,
288 6231,
289 6241,
290 13711,
291 13721,
292 13731,
293 13741,
294 13751,
295 13761,
296 8800,
297 12900,
298 12200,
299 9700,
300 9710,
301 9800,
302 9810,
303 9400,
304 9500,
305 9600,
306 10400,
307 10410,
308 10500,
309 10600,
310 10700,
311 9000,
312 5200,
313 6800,
314 6600,
315 8200,
316 11300,
317 12700,
318 13400,
319 125
320 };
321
322 /**
323 * types
324 */
325
326 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
327
328 /**
329 * globals
330 */
331
332 static unsigned int full01 = 0x01010101;
333 static unsigned int full80 = 0x80808080;
334
335 int SUPPRESS_OUTPUT = 0;
336
337 hc_thread_mutex_t mux_adl;
338 hc_thread_mutex_t mux_counter;
339 hc_thread_mutex_t mux_dispatcher;
340 hc_thread_mutex_t mux_display;
341
342 hc_global_data_t data;
343
344 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
345
346 const char *USAGE_MINI[] =
347 {
348 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
349 "",
350 "Try --help for more help.",
351 NULL
352 };
353
354 const char *USAGE_BIG[] =
355 {
356 "%s, advanced password recovery",
357 "",
358 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
359 "",
360 "- [ Options ] -",
361 "",
362 " Options Short / Long | Type | Description | Example",
363 "===============================|======|======================================================|=======================",
364 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
365 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
366 " -V, --version | | Print version |",
367 " -h, --help | | Print help |",
368 " --quiet | | Suppress output |",
369 " --hex-charset | | Assume charset is given in hex |",
370 " --hex-salt | | Assume salt is given in hex |",
371 " --hex-wordlist | | Assume words in wordlist is given in hex |",
372 " --force | | Ignore warnings |",
373 " --status | | Enable automatic update of the status-screen |",
374 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
375 " --machine-readable | | Display the status view in a machine readable format |",
376 " --loopback | | Add new plains to induct directory |",
377 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
378 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
379 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
380 " --markov-classic | | Enables classic markov-chains, no per-position |",
381 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
382 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
383 " --session | Str | Define specific session name | --session=mysession",
384 " --restore | | Restore session from --session |",
385 " --restore-disable | | Do not write restore file |",
386 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
387 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
388 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
389 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
390 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
391 " --show | | Show cracked passwords only |",
392 " --left | | Show un-cracked passwords only |",
393 " --username | | Enable ignoring of usernames in hashfile |",
394 " --remove | | Enable remove of hash once it is cracked |",
395 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
396 " --potfile-disable | | Do not write potfile |",
397 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
398 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
399 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
400 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
401 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
402 " --logfile-disable | | Disable the logfile |",
403 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
404 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
405 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
406 " -b, --benchmark | | Run benchmark |",
407 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
408 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
409 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
410 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
411 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
412 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
413 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
414 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
415 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
416 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
417 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
418 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
419 #ifdef HAVE_HWMON
420 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
421 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
422 " --powertune-enable | | Enable power tuning, restores settings when finished |",
423 #endif
424 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
425 " -s, --skip | Num | Skip X words from the start | -s 1000000",
426 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
427 " --keyspace | | Show keyspace base:mod values and quit |",
428 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
429 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
430 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
431 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
432 " --generate-rules-func-min | Num | Force min X funcs per rule |",
433 " --generate-rules-func-max | Num | Force max X funcs per rule |",
434 " --generate-rules-seed | Num | Force RNG seed set to X |",
435 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
436 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
437 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
438 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
439 " -i, --increment | | Enable mask increment mode |",
440 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
441 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
442 "",
443 "- [ Hash modes ] -",
444 "",
445 " # | Name | Category",
446 " ======+==================================================+======================================",
447 " 900 | MD4 | Raw Hash",
448 " 0 | MD5 | Raw Hash",
449 " 5100 | Half MD5 | Raw Hash",
450 " 100 | SHA1 | Raw Hash",
451 " 10800 | SHA-384 | Raw Hash",
452 " 1400 | SHA-256 | Raw Hash",
453 " 1700 | SHA-512 | Raw Hash",
454 " 5000 | SHA-3(Keccak) | Raw Hash",
455 " 10100 | SipHash | Raw Hash",
456 " 6000 | RipeMD160 | Raw Hash",
457 " 6100 | Whirlpool | Raw Hash",
458 " 6900 | GOST R 34.11-94 | Raw Hash",
459 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
460 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
461 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
462 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
463 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
464 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
465 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
466 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
467 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
468 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
469 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
470 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
471 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
472 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
473 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
474 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
475 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
476 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
477 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
478 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
479 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
480 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
481 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
482 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
483 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
484 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
485 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
486 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
487 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
488 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
489 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
490 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
491 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
492 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
493 " 400 | phpass | Generic KDF",
494 " 8900 | scrypt | Generic KDF",
495 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
496 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
497 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
498 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
499 " 23 | Skype | Network protocols",
500 " 2500 | WPA/WPA2 | Network protocols",
501 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
502 " 5300 | IKE-PSK MD5 | Network protocols",
503 " 5400 | IKE-PSK SHA1 | Network protocols",
504 " 5500 | NetNTLMv1 | Network protocols",
505 " 5500 | NetNTLMv1 + ESS | Network protocols",
506 " 5600 | NetNTLMv2 | Network protocols",
507 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
508 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
509 " 8300 | DNSSEC (NSEC3) | Network protocols",
510 " 10200 | Cram MD5 | Network protocols",
511 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
512 " 11200 | MySQL CRAM (SHA1) | Network protocols",
513 " 11400 | SIP digest authentication (MD5) | Network protocols",
514 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
515 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
516 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
517 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
518 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
519 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
520 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
521 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
522 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
523 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
524 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
525 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
526 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
527 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
528 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
529 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
530 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
531 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
532 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
533 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
534 " 12 | PostgreSQL | Database Server",
535 " 131 | MSSQL(2000) | Database Server",
536 " 132 | MSSQL(2005) | Database Server",
537 " 1731 | MSSQL(2012) | Database Server",
538 " 1731 | MSSQL(2014) | Database Server",
539 " 200 | MySQL323 | Database Server",
540 " 300 | MySQL4.1/MySQL5 | Database Server",
541 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
542 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
543 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
544 " 8000 | Sybase ASE | Database Server",
545 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
546 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
547 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
548 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
549 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
550 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
551 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
552 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
553 " 11500 | CRC32 | Checksums",
554 " 3000 | LM | Operating-Systems",
555 " 1000 | NTLM | Operating-Systems",
556 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
557 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
558 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
559 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
560 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
561 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
562 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
563 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
564 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
565 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
566 " 1722 | OSX v10.7 | Operating-Systems",
567 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
568 " 6300 | AIX {smd5} | Operating-Systems",
569 " 6700 | AIX {ssha1} | Operating-Systems",
570 " 6400 | AIX {ssha256} | Operating-Systems",
571 " 6500 | AIX {ssha512} | Operating-Systems",
572 " 2400 | Cisco-PIX | Operating-Systems",
573 " 2410 | Cisco-ASA | Operating-Systems",
574 " 500 | Cisco-IOS $1$ | Operating-Systems",
575 " 5700 | Cisco-IOS $4$ | Operating-Systems",
576 " 9200 | Cisco-IOS $8$ | Operating-Systems",
577 " 9300 | Cisco-IOS $9$ | Operating-Systems",
578 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
579 " 501 | Juniper IVE | Operating-Systems",
580 " 5800 | Android PIN | Operating-Systems",
581 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
582 " 8100 | Citrix Netscaler | Operating-Systems",
583 " 8500 | RACF | Operating-Systems",
584 " 7200 | GRUB 2 | Operating-Systems",
585 " 9900 | Radmin2 | Operating-Systems",
586 " 125 | ArubaOS | Operating-Systems",
587 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
588 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
589 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
590 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
591 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
592 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
593 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
594 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
595 " 11600 | 7-Zip | Archives",
596 " 12500 | RAR3-hp | Archives",
597 " 13000 | RAR5 | Archives",
598 " 13200 | AxCrypt | Archives",
599 " 13300 | AxCrypt in memory SHA1 | Archives",
600 " 13600 | WinZip | Archives",
601 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
602 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
603 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
604 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
605 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
606 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
607 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
608 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
609 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
610 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
611 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
612 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
613 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
614 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
615 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
616 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
617 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
618 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
619 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
620 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
621 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
622 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
623 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
624 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
625 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
626 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
627 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
628 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
629 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
630 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
631 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
632 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
633 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
634 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
635 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
636 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
637 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
638 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
639 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
640 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
641 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
642 " 9400 | MS Office 2007 | Documents",
643 " 9500 | MS Office 2010 | Documents",
644 " 9600 | MS Office 2013 | Documents",
645 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
646 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
647 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
648 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
649 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
650 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
651 " 9000 | Password Safe v2 | Password Managers",
652 " 5200 | Password Safe v3 | Password Managers",
653 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
654 " 6600 | 1Password, agilekeychain | Password Managers",
655 " 8200 | 1Password, cloudkeychain | Password Managers",
656 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
657 " 12700 | Blockchain, My Wallet | Password Managers",
658 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
659 "",
660 "- [ Outfile Formats ] -",
661 "",
662 " # | Format",
663 " ===+========",
664 " 1 | hash[:salt]",
665 " 2 | plain",
666 " 3 | hash[:salt]:plain",
667 " 4 | hex_plain",
668 " 5 | hash[:salt]:hex_plain",
669 " 6 | plain:hex_plain",
670 " 7 | hash[:salt]:plain:hex_plain",
671 " 8 | crackpos",
672 " 9 | hash[:salt]:crack_pos",
673 " 10 | plain:crack_pos",
674 " 11 | hash[:salt]:plain:crack_pos",
675 " 12 | hex_plain:crack_pos",
676 " 13 | hash[:salt]:hex_plain:crack_pos",
677 " 14 | plain:hex_plain:crack_pos",
678 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
679 "",
680 "- [ Rule Debugging Modes ] -",
681 "",
682 " # | Format",
683 " ===+========",
684 " 1 | Finding-Rule",
685 " 2 | Original-Word",
686 " 3 | Original-Word:Finding-Rule",
687 " 4 | Original-Word:Finding-Rule:Processed-Word",
688 "",
689 "- [ Attack Modes ] -",
690 "",
691 " # | Mode",
692 " ===+======",
693 " 0 | Straight",
694 " 1 | Combination",
695 " 3 | Brute-force",
696 " 6 | Hybrid Wordlist + Mask",
697 " 7 | Hybrid Mask + Wordlist",
698 "",
699 "- [ Built-in Charsets ] -",
700 "",
701 " ? | Charset",
702 " ===+=========",
703 " l | abcdefghijklmnopqrstuvwxyz",
704 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
705 " d | 0123456789",
706 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
707 " a | ?l?u?d?s",
708 " b | 0x00 - 0xff",
709 "",
710 "- [ OpenCL Device Types ] -",
711 "",
712 " # | Device Type",
713 " ===+=============",
714 " 1 | CPU",
715 " 2 | GPU",
716 " 3 | FPGA, DSP, Co-Processor",
717 "",
718 "- [ Workload Profiles ] -",
719 "",
720 " # | Performance | Runtime | Power Consumption | Desktop Impact",
721 " ===+=============+=========+===================+=================",
722 " 1 | Low | 2 ms | Low | Minimal",
723 " 2 | Default | 12 ms | Economic | Noticeable",
724 " 3 | High | 96 ms | High | Unresponsive",
725 " 4 | Nightmare | 480 ms | Insane | Headless",
726 "",
727 "If you have no idea what just happened then visit the following pages:",
728 "",
729 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
730 "* https://hashcat.net/wiki/#frequently_asked_questions",
731 "",
732 NULL
733 };
734
735 /**
736 * hashcat specific functions
737 */
738
739 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
740 {
741 int exec_pos = (int) device_param->exec_pos - last_num_entries;
742
743 if (exec_pos < 0) exec_pos += EXEC_CACHE;
744
745 double exec_ms_sum = 0;
746
747 int exec_ms_cnt = 0;
748
749 for (int i = 0; i < last_num_entries; i++)
750 {
751 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
752
753 if (exec_ms)
754 {
755 exec_ms_sum += exec_ms;
756
757 exec_ms_cnt++;
758 }
759 }
760
761 if (exec_ms_cnt == 0) return 0;
762
763 return exec_ms_sum / exec_ms_cnt;
764 }
765
766 void status_display_machine_readable ()
767 {
768 FILE *out = stdout;
769
770 fprintf (out, "STATUS\t%u\t", data.devices_status);
771
772 /**
773 * speed new
774 */
775
776 fprintf (out, "SPEED\t");
777
778 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
779 {
780 hc_device_param_t *device_param = &data.devices_param[device_id];
781
782 if (device_param->skipped) continue;
783
784 u64 speed_cnt = 0;
785 double speed_ms = 0;
786
787 for (int i = 0; i < SPEED_CACHE; i++)
788 {
789 speed_cnt += device_param->speed_cnt[i];
790 speed_ms += device_param->speed_ms[i];
791 }
792
793 speed_cnt /= SPEED_CACHE;
794 speed_ms /= SPEED_CACHE;
795
796 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
797 }
798
799 /**
800 * exec time
801 */
802
803 fprintf (out, "EXEC_RUNTIME\t");
804
805 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
806 {
807 hc_device_param_t *device_param = &data.devices_param[device_id];
808
809 if (device_param->skipped) continue;
810
811 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
812
813 fprintf (out, "%f\t", exec_ms_avg);
814 }
815
816 /**
817 * words_cur
818 */
819
820 u64 words_cur = get_lowest_words_done ();
821
822 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
823
824 /**
825 * counter
826 */
827
828 u64 progress_total = data.words_cnt * data.salts_cnt;
829
830 u64 all_done = 0;
831 u64 all_rejected = 0;
832 u64 all_restored = 0;
833
834 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
835 {
836 all_done += data.words_progress_done[salt_pos];
837 all_rejected += data.words_progress_rejected[salt_pos];
838 all_restored += data.words_progress_restored[salt_pos];
839 }
840
841 u64 progress_cur = all_restored + all_done + all_rejected;
842 u64 progress_end = progress_total;
843
844 u64 progress_skip = 0;
845
846 if (data.skip)
847 {
848 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
849
850 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
851 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
852 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
853 }
854
855 if (data.limit)
856 {
857 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
858
859 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
860 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
861 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
862 }
863
864 u64 progress_cur_relative_skip = progress_cur - progress_skip;
865 u64 progress_end_relative_skip = progress_end - progress_skip;
866
867 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
868
869 /**
870 * cracks
871 */
872
873 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
874 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
875
876 /**
877 * temperature
878 */
879
880 #ifdef HAVE_HWMON
881 if (data.gpu_temp_disable == 0)
882 {
883 fprintf (out, "TEMP\t");
884
885 hc_thread_mutex_lock (mux_adl);
886
887 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
888 {
889 hc_device_param_t *device_param = &data.devices_param[device_id];
890
891 if (device_param->skipped) continue;
892
893 int temp = hm_get_temperature_with_device_id (device_id);
894
895 fprintf (out, "%d\t", temp);
896 }
897
898 hc_thread_mutex_unlock (mux_adl);
899 }
900 #endif // HAVE_HWMON
901
902 /**
903 * flush
904 */
905
906 #ifdef _WIN
907 fputc ('\r', out);
908 fputc ('\n', out);
909 #endif
910
911 #ifdef _POSIX
912 fputc ('\n', out);
913 #endif
914
915 fflush (out);
916 }
917
918 void status_display ()
919 {
920 if (data.devices_status == STATUS_INIT) return;
921 if (data.devices_status == STATUS_STARTING) return;
922 if (data.devices_status == STATUS_BYPASS) return;
923
924 if (data.machine_readable == 1)
925 {
926 status_display_machine_readable ();
927
928 return;
929 }
930
931 char tmp_buf[1000] = { 0 };
932
933 uint tmp_len = 0;
934
935 log_info ("Session.Name...: %s", data.session);
936
937 char *status_type = strstatus (data.devices_status);
938
939 uint hash_mode = data.hash_mode;
940
941 char *hash_type = strhashtype (hash_mode); // not a bug
942
943 log_info ("Status.........: %s", status_type);
944
945 /**
946 * show rules
947 */
948
949 if (data.rp_files_cnt)
950 {
951 uint i;
952
953 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
954 {
955 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
956 }
957
958 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
959
960 log_info ("Rules.Type.....: %s", tmp_buf);
961
962 tmp_len = 0;
963 }
964
965 if (data.rp_gen)
966 {
967 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
968
969 if (data.rp_gen_seed)
970 {
971 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
972 }
973 }
974
975 /**
976 * show input
977 */
978
979 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
980 {
981 if (data.wordlist_mode == WL_MODE_FILE)
982 {
983 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
984 }
985 else if (data.wordlist_mode == WL_MODE_STDIN)
986 {
987 log_info ("Input.Mode.....: Pipe");
988 }
989 }
990 else if (data.attack_mode == ATTACK_MODE_COMBI)
991 {
992 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
993 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
994 }
995 else if (data.attack_mode == ATTACK_MODE_BF)
996 {
997 char *mask = data.mask;
998
999 if (mask != NULL)
1000 {
1001 uint mask_len = data.css_cnt;
1002
1003 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1004
1005 if (mask_len > 0)
1006 {
1007 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1008 {
1009 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1010 {
1011 mask_len -= data.salts_buf[0].salt_len;
1012 }
1013 }
1014
1015 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1016
1017 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1018 }
1019
1020 if (data.maskcnt > 1)
1021 {
1022 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1023
1024 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1025 }
1026
1027 log_info ("Input.Mode.....: %s", tmp_buf);
1028 }
1029
1030 tmp_len = 0;
1031 }
1032 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1033 {
1034 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1035 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1036 }
1037 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1038 {
1039 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1040 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1041 }
1042
1043 if (data.digests_cnt == 1)
1044 {
1045 if (data.hash_mode == 2500)
1046 {
1047 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1048
1049 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1050 (char *) data.salts_buf[0].salt_buf,
1051 wpa->orig_mac1[0],
1052 wpa->orig_mac1[1],
1053 wpa->orig_mac1[2],
1054 wpa->orig_mac1[3],
1055 wpa->orig_mac1[4],
1056 wpa->orig_mac1[5],
1057 wpa->orig_mac2[0],
1058 wpa->orig_mac2[1],
1059 wpa->orig_mac2[2],
1060 wpa->orig_mac2[3],
1061 wpa->orig_mac2[4],
1062 wpa->orig_mac2[5]);
1063 }
1064 else if (data.hash_mode == 5200)
1065 {
1066 log_info ("Hash.Target....: File (%s)", data.hashfile);
1067 }
1068 else if (data.hash_mode == 9000)
1069 {
1070 log_info ("Hash.Target....: File (%s)", data.hashfile);
1071 }
1072 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1073 {
1074 log_info ("Hash.Target....: File (%s)", data.hashfile);
1075 }
1076 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1077 {
1078 log_info ("Hash.Target....: File (%s)", data.hashfile);
1079 }
1080 else
1081 {
1082 char out_buf[HCBUFSIZ] = { 0 };
1083
1084 ascii_digest (out_buf, 0, 0);
1085
1086 // limit length
1087 if (strlen (out_buf) > 40)
1088 {
1089 out_buf[41] = '.';
1090 out_buf[42] = '.';
1091 out_buf[43] = '.';
1092 out_buf[44] = 0;
1093 }
1094
1095 log_info ("Hash.Target....: %s", out_buf);
1096 }
1097 }
1098 else
1099 {
1100 if (data.hash_mode == 3000)
1101 {
1102 char out_buf1[32] = { 0 };
1103 char out_buf2[32] = { 0 };
1104
1105 ascii_digest (out_buf1, 0, 0);
1106 ascii_digest (out_buf2, 0, 1);
1107
1108 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1109 }
1110 else
1111 {
1112 log_info ("Hash.Target....: File (%s)", data.hashfile);
1113 }
1114 }
1115
1116 log_info ("Hash.Type......: %s", hash_type);
1117
1118 /**
1119 * speed new
1120 */
1121
1122 u64 speed_cnt[DEVICES_MAX] = { 0 };
1123 double speed_ms[DEVICES_MAX] = { 0 };
1124
1125 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1126 {
1127 hc_device_param_t *device_param = &data.devices_param[device_id];
1128
1129 if (device_param->skipped) continue;
1130
1131 speed_cnt[device_id] = 0;
1132 speed_ms[device_id] = 0;
1133
1134 for (int i = 0; i < SPEED_CACHE; i++)
1135 {
1136 speed_cnt[device_id] += device_param->speed_cnt[i];
1137 speed_ms[device_id] += device_param->speed_ms[i];
1138 }
1139
1140 speed_cnt[device_id] /= SPEED_CACHE;
1141 speed_ms[device_id] /= SPEED_CACHE;
1142 }
1143
1144 double hashes_all_ms = 0;
1145
1146 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1147
1148 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1149 {
1150 hc_device_param_t *device_param = &data.devices_param[device_id];
1151
1152 if (device_param->skipped) continue;
1153
1154 hashes_dev_ms[device_id] = 0;
1155
1156 if (speed_ms[device_id])
1157 {
1158 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1159
1160 hashes_all_ms += hashes_dev_ms[device_id];
1161 }
1162 }
1163
1164 /**
1165 * exec time
1166 */
1167
1168 double exec_all_ms[DEVICES_MAX] = { 0 };
1169
1170 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1171 {
1172 hc_device_param_t *device_param = &data.devices_param[device_id];
1173
1174 if (device_param->skipped) continue;
1175
1176 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1177
1178 exec_all_ms[device_id] = exec_ms_avg;
1179 }
1180
1181 /**
1182 * timers
1183 */
1184
1185 double ms_running = 0;
1186
1187 hc_timer_get (data.timer_running, ms_running);
1188
1189 double ms_paused = data.ms_paused;
1190
1191 if (data.devices_status == STATUS_PAUSED)
1192 {
1193 double ms_paused_tmp = 0;
1194
1195 hc_timer_get (data.timer_paused, ms_paused_tmp);
1196
1197 ms_paused += ms_paused_tmp;
1198 }
1199
1200 #ifdef WIN
1201
1202 __time64_t sec_run = ms_running / 1000;
1203
1204 #else
1205
1206 time_t sec_run = ms_running / 1000;
1207
1208 #endif
1209
1210 if (sec_run)
1211 {
1212 char display_run[32] = { 0 };
1213
1214 struct tm tm_run;
1215
1216 struct tm *tmp = NULL;
1217
1218 #ifdef WIN
1219
1220 tmp = _gmtime64 (&sec_run);
1221
1222 #else
1223
1224 tmp = gmtime (&sec_run);
1225
1226 #endif
1227
1228 if (tmp != NULL)
1229 {
1230 memset (&tm_run, 0, sizeof (tm_run));
1231
1232 memcpy (&tm_run, tmp, sizeof (tm_run));
1233
1234 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1235
1236 char *start = ctime (&data.proc_start);
1237
1238 size_t start_len = strlen (start);
1239
1240 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1241 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1242
1243 log_info ("Time.Started...: %s (%s)", start, display_run);
1244 }
1245 }
1246 else
1247 {
1248 log_info ("Time.Started...: 0 secs");
1249 }
1250
1251 /**
1252 * counters
1253 */
1254
1255 u64 progress_total = data.words_cnt * data.salts_cnt;
1256
1257 u64 all_done = 0;
1258 u64 all_rejected = 0;
1259 u64 all_restored = 0;
1260
1261 u64 progress_noneed = 0;
1262
1263 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1264 {
1265 all_done += data.words_progress_done[salt_pos];
1266 all_rejected += data.words_progress_rejected[salt_pos];
1267 all_restored += data.words_progress_restored[salt_pos];
1268
1269 // Important for ETA only
1270
1271 if (data.salts_shown[salt_pos] == 1)
1272 {
1273 const u64 all = data.words_progress_done[salt_pos]
1274 + data.words_progress_rejected[salt_pos]
1275 + data.words_progress_restored[salt_pos];
1276
1277 const u64 left = data.words_cnt - all;
1278
1279 progress_noneed += left;
1280 }
1281 }
1282
1283 u64 progress_cur = all_restored + all_done + all_rejected;
1284 u64 progress_end = progress_total;
1285
1286 u64 progress_skip = 0;
1287
1288 if (data.skip)
1289 {
1290 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1291
1292 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1293 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1294 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1295 }
1296
1297 if (data.limit)
1298 {
1299 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1300
1301 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1302 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1303 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1304 }
1305
1306 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1307 u64 progress_end_relative_skip = progress_end - progress_skip;
1308
1309 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1310 {
1311 if (data.devices_status != STATUS_CRACKED)
1312 {
1313 #ifdef WIN
1314 __time64_t sec_etc = 0;
1315 #else
1316 time_t sec_etc = 0;
1317 #endif
1318
1319 if (hashes_all_ms)
1320 {
1321 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1322
1323 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1324
1325 sec_etc = ms_left / 1000;
1326 }
1327
1328 if (sec_etc == 0)
1329 {
1330 //log_info ("Time.Estimated.: 0 secs");
1331 }
1332 else if ((u64) sec_etc > ETC_MAX)
1333 {
1334 log_info ("Time.Estimated.: > 10 Years");
1335 }
1336 else
1337 {
1338 char display_etc[32] = { 0 };
1339
1340 struct tm tm_etc;
1341
1342 struct tm *tmp = NULL;
1343
1344 #ifdef WIN
1345
1346 tmp = _gmtime64 (&sec_etc);
1347
1348 #else
1349
1350 tmp = gmtime (&sec_etc);
1351
1352 #endif
1353
1354 if (tmp != NULL)
1355 {
1356 memset (&tm_etc, 0, sizeof (tm_etc));
1357
1358 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1359
1360 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1361
1362 time_t now;
1363
1364 time (&now);
1365
1366 now += sec_etc;
1367
1368 char *etc = ctime (&now);
1369
1370 size_t etc_len = strlen (etc);
1371
1372 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1373 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1374
1375 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1376 }
1377 }
1378 }
1379 }
1380
1381 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1382 {
1383 hc_device_param_t *device_param = &data.devices_param[device_id];
1384
1385 if (device_param->skipped) continue;
1386
1387 char display_dev_cur[16] = { 0 };
1388
1389 strncpy (display_dev_cur, "0.00", 4);
1390
1391 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1392
1393 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1394 }
1395
1396 char display_all_cur[16] = { 0 };
1397
1398 strncpy (display_all_cur, "0.00", 4);
1399
1400 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1401
1402 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1403
1404 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1405 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1406
1407 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);
1408
1409 // crack-per-time
1410
1411 if (data.digests_cnt > 100)
1412 {
1413 time_t now = time (NULL);
1414
1415 int cpt_cur_min = 0;
1416 int cpt_cur_hour = 0;
1417 int cpt_cur_day = 0;
1418
1419 for (int i = 0; i < CPT_BUF; i++)
1420 {
1421 const uint cracked = data.cpt_buf[i].cracked;
1422 const time_t timestamp = data.cpt_buf[i].timestamp;
1423
1424 if ((timestamp + 60) > now)
1425 {
1426 cpt_cur_min += cracked;
1427 }
1428
1429 if ((timestamp + 3600) > now)
1430 {
1431 cpt_cur_hour += cracked;
1432 }
1433
1434 if ((timestamp + 86400) > now)
1435 {
1436 cpt_cur_day += cracked;
1437 }
1438 }
1439
1440 double ms_real = ms_running - ms_paused;
1441
1442 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1443 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1444 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1445
1446 if ((data.cpt_start + 86400) < now)
1447 {
1448 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1449 cpt_cur_min,
1450 cpt_cur_hour,
1451 cpt_cur_day,
1452 cpt_avg_min,
1453 cpt_avg_hour,
1454 cpt_avg_day);
1455 }
1456 else if ((data.cpt_start + 3600) < now)
1457 {
1458 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1459 cpt_cur_min,
1460 cpt_cur_hour,
1461 cpt_avg_min,
1462 cpt_avg_hour,
1463 cpt_avg_day);
1464 }
1465 else if ((data.cpt_start + 60) < now)
1466 {
1467 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1468 cpt_cur_min,
1469 cpt_avg_min,
1470 cpt_avg_hour,
1471 cpt_avg_day);
1472 }
1473 else
1474 {
1475 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1476 cpt_avg_min,
1477 cpt_avg_hour,
1478 cpt_avg_day);
1479 }
1480 }
1481
1482 // Restore point
1483
1484 u64 restore_point = get_lowest_words_done ();
1485
1486 u64 restore_total = data.words_base;
1487
1488 float percent_restore = 0;
1489
1490 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1491
1492 if (progress_end_relative_skip)
1493 {
1494 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1495 {
1496 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1497 float percent_rejected = 0.0;
1498
1499 if (progress_cur)
1500 {
1501 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1502 }
1503
1504 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);
1505 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1506
1507 if (data.restore_disable == 0)
1508 {
1509 if (percent_finished != 1)
1510 {
1511 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1512 }
1513 }
1514 }
1515 }
1516 else
1517 {
1518 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1519 {
1520 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1521 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1522
1523 if (data.restore_disable == 0)
1524 {
1525 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1526 }
1527 }
1528 else
1529 {
1530 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1531 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1532
1533 // --restore not allowed if stdin is used -- really? why?
1534
1535 //if (data.restore_disable == 0)
1536 //{
1537 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1538 //}
1539 }
1540 }
1541
1542 #ifdef HAVE_HWMON
1543
1544 if (data.devices_status == STATUS_EXHAUSTED) return;
1545 if (data.devices_status == STATUS_CRACKED) return;
1546 if (data.devices_status == STATUS_ABORTED) return;
1547 if (data.devices_status == STATUS_QUIT) return;
1548
1549 if (data.gpu_temp_disable == 0)
1550 {
1551 hc_thread_mutex_lock (mux_adl);
1552
1553 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1554 {
1555 hc_device_param_t *device_param = &data.devices_param[device_id];
1556
1557 if (device_param->skipped) continue;
1558
1559 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1560 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1561 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1562 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1563 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1564 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1565 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1566
1567 char output_buf[256] = { 0 };
1568
1569 int output_len = 0;
1570
1571 if (num_temperature >= 0)
1572 {
1573 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1574
1575 output_len = strlen (output_buf);
1576 }
1577
1578 if (num_fanspeed >= 0)
1579 {
1580 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1581
1582 output_len = strlen (output_buf);
1583 }
1584
1585 if (num_utilization >= 0)
1586 {
1587 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1588
1589 output_len = strlen (output_buf);
1590 }
1591
1592 if (num_corespeed >= 0)
1593 {
1594 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1595
1596 output_len = strlen (output_buf);
1597 }
1598
1599 if (num_memoryspeed >= 0)
1600 {
1601 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1602
1603 output_len = strlen (output_buf);
1604 }
1605
1606 if (num_buslanes >= 0)
1607 {
1608 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1609
1610 output_len = strlen (output_buf);
1611 }
1612
1613 if (num_throttle == 1)
1614 {
1615 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1616
1617 output_len = strlen (output_buf);
1618 }
1619
1620 if (output_len == 0)
1621 {
1622 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1623
1624 output_len = strlen (output_buf);
1625 }
1626
1627 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1628 }
1629
1630 hc_thread_mutex_unlock (mux_adl);
1631 }
1632
1633 #endif // HAVE_HWMON
1634 }
1635
1636 static void status_benchmark_automate ()
1637 {
1638 u64 speed_cnt[DEVICES_MAX] = { 0 };
1639 double speed_ms[DEVICES_MAX] = { 0 };
1640
1641 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1642 {
1643 hc_device_param_t *device_param = &data.devices_param[device_id];
1644
1645 if (device_param->skipped) continue;
1646
1647 speed_cnt[device_id] = device_param->speed_cnt[0];
1648 speed_ms[device_id] = device_param->speed_ms[0];
1649 }
1650
1651 double hashes_dev_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 hashes_dev_ms[device_id] = 0;
1660
1661 if (speed_ms[device_id])
1662 {
1663 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1664 }
1665 }
1666
1667 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1668 {
1669 hc_device_param_t *device_param = &data.devices_param[device_id];
1670
1671 if (device_param->skipped) continue;
1672
1673 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1674 }
1675 }
1676
1677 static void status_benchmark ()
1678 {
1679 if (data.devices_status == STATUS_INIT) return;
1680 if (data.devices_status == STATUS_STARTING) return;
1681 if (data.devices_status == STATUS_BYPASS) return;
1682
1683 if (data.machine_readable == 1)
1684 {
1685 status_benchmark_automate ();
1686
1687 return;
1688 }
1689
1690 u64 speed_cnt[DEVICES_MAX] = { 0 };
1691 double speed_ms[DEVICES_MAX] = { 0 };
1692
1693 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1694 {
1695 hc_device_param_t *device_param = &data.devices_param[device_id];
1696
1697 if (device_param->skipped) continue;
1698
1699 speed_cnt[device_id] = device_param->speed_cnt[0];
1700 speed_ms[device_id] = device_param->speed_ms[0];
1701 }
1702
1703 double hashes_all_ms = 0;
1704
1705 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1706
1707 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1708 {
1709 hc_device_param_t *device_param = &data.devices_param[device_id];
1710
1711 if (device_param->skipped) continue;
1712
1713 hashes_dev_ms[device_id] = 0;
1714
1715 if (speed_ms[device_id])
1716 {
1717 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1718
1719 hashes_all_ms += hashes_dev_ms[device_id];
1720 }
1721 }
1722
1723 /**
1724 * exec time
1725 */
1726
1727 double exec_all_ms[DEVICES_MAX] = { 0 };
1728
1729 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1730 {
1731 hc_device_param_t *device_param = &data.devices_param[device_id];
1732
1733 if (device_param->skipped) continue;
1734
1735 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1736
1737 exec_all_ms[device_id] = exec_ms_avg;
1738 }
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 char display_dev_cur[16] = { 0 };
1747
1748 strncpy (display_dev_cur, "0.00", 4);
1749
1750 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1751
1752 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1753 }
1754
1755 char display_all_cur[16] = { 0 };
1756
1757 strncpy (display_all_cur, "0.00", 4);
1758
1759 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1760
1761 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1762 }
1763
1764 /**
1765 * hashcat -only- functions
1766 */
1767
1768 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1769 {
1770 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1771 {
1772 if (attack_kern == ATTACK_KERN_STRAIGHT)
1773 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1774 else if (attack_kern == ATTACK_KERN_COMBI)
1775 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1776 else if (attack_kern == ATTACK_KERN_BF)
1777 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1778 }
1779 else
1780 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1781 }
1782
1783 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)
1784 {
1785 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1786 {
1787 if (attack_kern == ATTACK_KERN_STRAIGHT)
1788 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1789 else if (attack_kern == ATTACK_KERN_COMBI)
1790 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1791 else if (attack_kern == ATTACK_KERN_BF)
1792 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1793 }
1794 else
1795 {
1796 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1797 }
1798 }
1799
1800 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1801 {
1802 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1803 {
1804 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1805 }
1806 else
1807 {
1808 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1809 }
1810 }
1811
1812 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)
1813 {
1814 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1815 {
1816 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1817 }
1818 else
1819 {
1820 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1821 }
1822 }
1823
1824 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1825 {
1826 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1827 }
1828
1829 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1830 {
1831 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1832 }
1833
1834 static uint convert_from_hex (char *line_buf, const uint line_len)
1835 {
1836 if (line_len & 1) return (line_len); // not in hex
1837
1838 if (data.hex_wordlist == 1)
1839 {
1840 uint i;
1841 uint j;
1842
1843 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1844 {
1845 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1846 }
1847
1848 memset (line_buf + i, 0, line_len - i);
1849
1850 return (i);
1851 }
1852 else if (line_len >= 6) // $HEX[] = 6
1853 {
1854 if (line_buf[0] != '$') return (line_len);
1855 if (line_buf[1] != 'H') return (line_len);
1856 if (line_buf[2] != 'E') return (line_len);
1857 if (line_buf[3] != 'X') return (line_len);
1858 if (line_buf[4] != '[') return (line_len);
1859 if (line_buf[line_len - 1] != ']') return (line_len);
1860
1861 uint i;
1862 uint j;
1863
1864 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1865 {
1866 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1867 }
1868
1869 memset (line_buf + i, 0, line_len - i);
1870
1871 return (i);
1872 }
1873
1874 return (line_len);
1875 }
1876
1877 static void clear_prompt ()
1878 {
1879 fputc ('\r', stdout);
1880
1881 for (size_t i = 0; i < strlen (PROMPT); i++)
1882 {
1883 fputc (' ', stdout);
1884 }
1885
1886 fputc ('\r', stdout);
1887
1888 fflush (stdout);
1889 }
1890
1891 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1892 {
1893 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);
1894 }
1895
1896 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1897 {
1898 char *outfile = data.outfile;
1899 uint quiet = data.quiet;
1900 FILE *pot_fp = data.pot_fp;
1901 uint loopback = data.loopback;
1902 uint debug_mode = data.debug_mode;
1903 char *debug_file = data.debug_file;
1904
1905 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1906 int debug_rule_len = 0; // -1 error
1907 uint debug_plain_len = 0;
1908
1909 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1910
1911 // hash
1912
1913 char out_buf[HCBUFSIZ] = { 0 };
1914
1915 const u32 salt_pos = plain->salt_pos;
1916 const u32 digest_pos = plain->digest_pos; // relative
1917 const u32 gidvid = plain->gidvid;
1918 const u32 il_pos = plain->il_pos;
1919
1920 ascii_digest (out_buf, salt_pos, digest_pos);
1921
1922 // plain
1923
1924 u64 crackpos = device_param->words_off;
1925
1926 uint plain_buf[16] = { 0 };
1927
1928 u8 *plain_ptr = (u8 *) plain_buf;
1929
1930 unsigned int plain_len = 0;
1931
1932 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1933 {
1934 pw_t pw;
1935
1936 gidd_to_pw_t (device_param, gidvid, &pw);
1937
1938 for (int i = 0; i < 16; i++)
1939 {
1940 plain_buf[i] = pw.i[i];
1941 }
1942
1943 plain_len = pw.pw_len;
1944
1945 const uint off = device_param->innerloop_pos + il_pos;
1946
1947 if (debug_mode > 0)
1948 {
1949 debug_rule_len = 0;
1950
1951 // save rule
1952 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1953 {
1954 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1955
1956 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1957 }
1958
1959 // save plain
1960 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1961 {
1962 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1963
1964 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1965
1966 debug_plain_len = plain_len;
1967 }
1968 }
1969
1970 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1971
1972 crackpos += gidvid;
1973 crackpos *= data.kernel_rules_cnt;
1974 crackpos += device_param->innerloop_pos + il_pos;
1975
1976 if (plain_len > data.pw_max) plain_len = data.pw_max;
1977 }
1978 else if (data.attack_mode == ATTACK_MODE_COMBI)
1979 {
1980 pw_t pw;
1981
1982 gidd_to_pw_t (device_param, gidvid, &pw);
1983
1984 for (int i = 0; i < 16; i++)
1985 {
1986 plain_buf[i] = pw.i[i];
1987 }
1988
1989 plain_len = pw.pw_len;
1990
1991 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1992 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1993
1994 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1995 {
1996 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1997 }
1998 else
1999 {
2000 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2001
2002 memcpy (plain_ptr, comb_buf, comb_len);
2003 }
2004
2005 plain_len += comb_len;
2006
2007 crackpos += gidvid;
2008 crackpos *= data.combs_cnt;
2009 crackpos += device_param->innerloop_pos + il_pos;
2010
2011 if (data.pw_max != PW_DICTMAX1)
2012 {
2013 if (plain_len > data.pw_max) plain_len = data.pw_max;
2014 }
2015 }
2016 else if (data.attack_mode == ATTACK_MODE_BF)
2017 {
2018 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2019 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2020
2021 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2022 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2023
2024 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2025 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2026
2027 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2028 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2029
2030 plain_len = data.css_cnt;
2031
2032 crackpos += gidvid;
2033 crackpos *= data.bfs_cnt;
2034 crackpos += device_param->innerloop_pos + il_pos;
2035 }
2036 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2037 {
2038 pw_t pw;
2039
2040 gidd_to_pw_t (device_param, gidvid, &pw);
2041
2042 for (int i = 0; i < 16; i++)
2043 {
2044 plain_buf[i] = pw.i[i];
2045 }
2046
2047 plain_len = pw.pw_len;
2048
2049 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2050
2051 uint start = 0;
2052 uint stop = device_param->kernel_params_mp_buf32[4];
2053
2054 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2055
2056 plain_len += start + stop;
2057
2058 crackpos += gidvid;
2059 crackpos *= data.combs_cnt;
2060 crackpos += device_param->innerloop_pos + il_pos;
2061
2062 if (data.pw_max != PW_DICTMAX1)
2063 {
2064 if (plain_len > data.pw_max) plain_len = data.pw_max;
2065 }
2066 }
2067 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2068 {
2069 pw_t pw;
2070
2071 gidd_to_pw_t (device_param, gidvid, &pw);
2072
2073 for (int i = 0; i < 16; i++)
2074 {
2075 plain_buf[i] = pw.i[i];
2076 }
2077
2078 plain_len = pw.pw_len;
2079
2080 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2081
2082 uint start = 0;
2083 uint stop = device_param->kernel_params_mp_buf32[4];
2084
2085 memmove (plain_ptr + stop, plain_ptr, plain_len);
2086
2087 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2088
2089 plain_len += start + stop;
2090
2091 crackpos += gidvid;
2092 crackpos *= data.combs_cnt;
2093 crackpos += device_param->innerloop_pos + il_pos;
2094
2095 if (data.pw_max != PW_DICTMAX1)
2096 {
2097 if (plain_len > data.pw_max) plain_len = data.pw_max;
2098 }
2099 }
2100
2101 if (data.attack_mode == ATTACK_MODE_BF)
2102 {
2103 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2104 {
2105 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2106 {
2107 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2108 {
2109 plain_len = plain_len - data.salts_buf[0].salt_len;
2110 }
2111 }
2112
2113 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2114 {
2115 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2116 {
2117 plain_ptr[j] = plain_ptr[i];
2118 }
2119
2120 plain_len = plain_len / 2;
2121 }
2122 }
2123 }
2124
2125 // if enabled, update also the potfile
2126
2127 if (pot_fp)
2128 {
2129 lock_file (pot_fp);
2130
2131 fprintf (pot_fp, "%s:", out_buf);
2132
2133 format_plain (pot_fp, plain_ptr, plain_len, 1);
2134
2135 fputc ('\n', pot_fp);
2136
2137 fflush (pot_fp);
2138
2139 unlock_file (pot_fp);
2140 }
2141
2142 // outfile
2143
2144 FILE *out_fp = NULL;
2145
2146 if (outfile != NULL)
2147 {
2148 if ((out_fp = fopen (outfile, "ab")) == NULL)
2149 {
2150 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2151
2152 out_fp = stdout;
2153 }
2154
2155 lock_file (out_fp);
2156 }
2157 else
2158 {
2159 out_fp = stdout;
2160
2161 if (quiet == 0) clear_prompt ();
2162 }
2163
2164 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2165
2166 if (outfile != NULL)
2167 {
2168 if (out_fp != stdout)
2169 {
2170 fclose (out_fp);
2171 }
2172 }
2173 else
2174 {
2175 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2176 {
2177 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2178 {
2179 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2180 if (quiet == 0) fflush (stdout);
2181 }
2182 }
2183 }
2184
2185 // loopback
2186
2187 if (loopback)
2188 {
2189 char *loopback_file = data.loopback_file;
2190
2191 FILE *fb_fp = NULL;
2192
2193 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2194 {
2195 lock_file (fb_fp);
2196
2197 format_plain (fb_fp, plain_ptr, plain_len, 1);
2198
2199 fputc ('\n', fb_fp);
2200
2201 fclose (fb_fp);
2202 }
2203 }
2204
2205 // (rule) debug mode
2206
2207 // the next check implies that:
2208 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2209 // - debug_mode > 0
2210
2211 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2212 {
2213 if (debug_rule_len < 0) debug_rule_len = 0;
2214
2215 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2216
2217 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2218
2219 if ((quiet == 0) && (debug_file == NULL))
2220 {
2221 fprintf (stdout, "%s", PROMPT);
2222
2223 fflush (stdout);
2224 }
2225 }
2226 }
2227
2228 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2229 {
2230 salt_t *salt_buf = &data.salts_buf[salt_pos];
2231
2232 u32 num_cracked;
2233
2234 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2235
2236 if (num_cracked)
2237 {
2238 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2239
2240 log_info_nn ("");
2241
2242 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2243
2244 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);
2245
2246 uint cpt_cracked = 0;
2247
2248 for (uint i = 0; i < num_cracked; i++)
2249 {
2250 const uint hash_pos = cracked[i].hash_pos;
2251
2252 if (data.digests_shown[hash_pos] == 1) continue;
2253
2254 hc_thread_mutex_lock (mux_display);
2255
2256 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2257 {
2258 data.digests_shown[hash_pos] = 1;
2259
2260 data.digests_done++;
2261
2262 cpt_cracked++;
2263
2264 salt_buf->digests_done++;
2265
2266 if (salt_buf->digests_done == salt_buf->digests_cnt)
2267 {
2268 data.salts_shown[salt_pos] = 1;
2269
2270 data.salts_done++;
2271 }
2272 }
2273
2274 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2275
2276 hc_thread_mutex_unlock (mux_display);
2277
2278 check_hash (device_param, &cracked[i]);
2279 }
2280
2281 myfree (cracked);
2282
2283 if (cpt_cracked > 0)
2284 {
2285 hc_thread_mutex_lock (mux_display);
2286
2287 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2288 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2289
2290 data.cpt_pos++;
2291
2292 data.cpt_total += cpt_cracked;
2293
2294 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2295
2296 hc_thread_mutex_unlock (mux_display);
2297 }
2298
2299 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2300 {
2301 // we need to reset cracked state on the device
2302 // otherwise host thinks again and again the hash was cracked
2303 // and returns invalid password each time
2304
2305 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2306
2307 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);
2308 }
2309
2310 num_cracked = 0;
2311
2312 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2313 }
2314 }
2315
2316 static void save_hash ()
2317 {
2318 char *hashfile = data.hashfile;
2319
2320 char new_hashfile[256] = { 0 };
2321 char old_hashfile[256] = { 0 };
2322
2323 snprintf (new_hashfile, 255, "%s.new", hashfile);
2324 snprintf (old_hashfile, 255, "%s.old", hashfile);
2325
2326 unlink (new_hashfile);
2327
2328 char separator = data.separator;
2329
2330 FILE *fp = fopen (new_hashfile, "wb");
2331
2332 if (fp == NULL)
2333 {
2334 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2335
2336 exit (-1);
2337 }
2338
2339 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2340 {
2341 if (data.salts_shown[salt_pos] == 1) continue;
2342
2343 salt_t *salt_buf = &data.salts_buf[salt_pos];
2344
2345 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2346 {
2347 uint idx = salt_buf->digests_offset + digest_pos;
2348
2349 if (data.digests_shown[idx] == 1) continue;
2350
2351 if (data.hash_mode != 2500)
2352 {
2353 char out_buf[HCBUFSIZ] = { 0 };
2354
2355 if (data.username == 1)
2356 {
2357 user_t *user = data.hash_info[idx]->user;
2358
2359 uint i;
2360
2361 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2362
2363 fputc (separator, fp);
2364 }
2365
2366 ascii_digest (out_buf, salt_pos, digest_pos);
2367
2368 fputs (out_buf, fp);
2369
2370 log_out (fp, "");
2371 }
2372 else
2373 {
2374 hccap_t hccap;
2375
2376 to_hccap_t (&hccap, salt_pos, digest_pos);
2377
2378 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2379 }
2380 }
2381 }
2382
2383 fflush (fp);
2384
2385 fclose (fp);
2386
2387 unlink (old_hashfile);
2388
2389 if (rename (hashfile, old_hashfile) != 0)
2390 {
2391 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2392
2393 exit (-1);
2394 }
2395
2396 unlink (hashfile);
2397
2398 if (rename (new_hashfile, hashfile) != 0)
2399 {
2400 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2401
2402 exit (-1);
2403 }
2404
2405 unlink (old_hashfile);
2406 }
2407
2408 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2409 {
2410 uint num_elements = num;
2411
2412 device_param->kernel_params_buf32[30] = data.combs_mode;
2413 device_param->kernel_params_buf32[31] = num;
2414
2415 uint kernel_threads = device_param->kernel_threads;
2416
2417 while (num_elements % kernel_threads) num_elements++;
2418
2419 cl_kernel kernel = NULL;
2420
2421 switch (kern_run)
2422 {
2423 case KERN_RUN_1: kernel = device_param->kernel1; break;
2424 case KERN_RUN_12: kernel = device_param->kernel12; break;
2425 case KERN_RUN_2: kernel = device_param->kernel2; break;
2426 case KERN_RUN_23: kernel = device_param->kernel23; break;
2427 case KERN_RUN_3: kernel = device_param->kernel3; break;
2428 }
2429
2430 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2431 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2432 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2433 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2434 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2435 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2436 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2437 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2438 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2439 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2440 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2441
2442 cl_event event;
2443
2444 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2445 {
2446 const size_t global_work_size[3] = { num_elements, 32, 1 };
2447 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2448
2449 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2450 }
2451 else
2452 {
2453 if (kern_run == KERN_RUN_2)
2454 {
2455 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2456 {
2457 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2458 }
2459 }
2460
2461 while (num_elements % kernel_threads) num_elements++;
2462
2463 const size_t global_work_size[3] = { num_elements, 1, 1 };
2464 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2465
2466 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2467 }
2468
2469 hc_clFlush (data.ocl, device_param->command_queue);
2470
2471 if (data.devices_status == STATUS_RUNNING)
2472 {
2473 if (iteration < EXPECTED_ITERATIONS)
2474 {
2475 switch (kern_run)
2476 {
2477 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration]); break;
2478 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration]); break;
2479 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration]); break;
2480 }
2481 }
2482 }
2483
2484 hc_clWaitForEvents (data.ocl, 1, &event);
2485
2486 cl_ulong time_start;
2487 cl_ulong time_end;
2488
2489 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2490 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2491
2492 const double exec_us = (double) (time_end - time_start) / 1000;
2493
2494 if (data.devices_status == STATUS_RUNNING)
2495 {
2496 if (iteration < EXPECTED_ITERATIONS)
2497 {
2498 switch (kern_run)
2499 {
2500 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2501 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2502 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2503 }
2504 }
2505 }
2506
2507 if (event_update)
2508 {
2509 uint exec_pos = device_param->exec_pos;
2510
2511 device_param->exec_ms[exec_pos] = exec_us / 1000;
2512
2513 exec_pos++;
2514
2515 if (exec_pos == EXEC_CACHE)
2516 {
2517 exec_pos = 0;
2518 }
2519
2520 device_param->exec_pos = exec_pos;
2521 }
2522
2523 hc_clReleaseEvent (data.ocl, event);
2524
2525 hc_clFinish (data.ocl, device_param->command_queue);
2526 }
2527
2528 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2529 {
2530 uint num_elements = num;
2531
2532 switch (kern_run)
2533 {
2534 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2535 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2536 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2537 }
2538
2539 // causes problems with special threads like in bcrypt
2540 // const uint kernel_threads = device_param->kernel_threads;
2541
2542 uint kernel_threads = device_param->kernel_threads;
2543
2544 while (num_elements % kernel_threads) num_elements++;
2545
2546 cl_kernel kernel = NULL;
2547
2548 switch (kern_run)
2549 {
2550 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2551 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2552 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2553 }
2554
2555 switch (kern_run)
2556 {
2557 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2558 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2559 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2560 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2561 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2562 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2563 break;
2564 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2565 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2566 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2567 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2568 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2569 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2570 break;
2571 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2572 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2573 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2574 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2575 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2576 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2577 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2578 break;
2579 }
2580
2581 const size_t global_work_size[3] = { num_elements, 1, 1 };
2582 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2583
2584 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2585
2586 hc_clFlush (data.ocl, device_param->command_queue);
2587
2588 hc_clFinish (data.ocl, device_param->command_queue);
2589 }
2590
2591 static void run_kernel_tm (hc_device_param_t *device_param)
2592 {
2593 const uint num_elements = 1024; // fixed
2594
2595 uint kernel_threads = 32;
2596
2597 cl_kernel kernel = device_param->kernel_tm;
2598
2599 const size_t global_work_size[3] = { num_elements, 1, 1 };
2600 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2601
2602 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2603
2604 hc_clFlush (data.ocl, device_param->command_queue);
2605
2606 hc_clFinish (data.ocl, device_param->command_queue);
2607 }
2608
2609 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2610 {
2611 uint num_elements = num;
2612
2613 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2614 device_param->kernel_params_amp_buf32[6] = num_elements;
2615
2616 // causes problems with special threads like in bcrypt
2617 // const uint kernel_threads = device_param->kernel_threads;
2618
2619 uint kernel_threads = device_param->kernel_threads;
2620
2621 while (num_elements % kernel_threads) num_elements++;
2622
2623 cl_kernel kernel = device_param->kernel_amp;
2624
2625 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2626 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2627
2628 const size_t global_work_size[3] = { num_elements, 1, 1 };
2629 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2630
2631 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2632
2633 hc_clFlush (data.ocl, device_param->command_queue);
2634
2635 hc_clFinish (data.ocl, device_param->command_queue);
2636 }
2637
2638 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2639 {
2640 const u32 num16d = num / 16;
2641 const u32 num16m = num % 16;
2642
2643 if (num16d)
2644 {
2645 device_param->kernel_params_memset_buf32[1] = value;
2646 device_param->kernel_params_memset_buf32[2] = num16d;
2647
2648 uint kernel_threads = device_param->kernel_threads;
2649
2650 uint num_elements = num16d;
2651
2652 while (num_elements % kernel_threads) num_elements++;
2653
2654 cl_kernel kernel = device_param->kernel_memset;
2655
2656 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2657 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2658 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2659
2660 const size_t global_work_size[3] = { num_elements, 1, 1 };
2661 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2662
2663 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2664
2665 hc_clFlush (data.ocl, device_param->command_queue);
2666
2667 hc_clFinish (data.ocl, device_param->command_queue);
2668 }
2669
2670 if (num16m)
2671 {
2672 u32 tmp[4];
2673
2674 tmp[0] = value;
2675 tmp[1] = value;
2676 tmp[2] = value;
2677 tmp[3] = value;
2678
2679 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2680 }
2681 }
2682
2683 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2684 {
2685 run_kernel_memset (device_param, buf, 0, size);
2686
2687 /*
2688 int rc = -1;
2689
2690 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2691 {
2692 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2693
2694 const cl_uchar zero = 0;
2695
2696 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2697 }
2698
2699 if (rc != 0)
2700 {
2701 // NOTE: clEnqueueFillBuffer () always fails with -59
2702 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2703 // How's that possible, OpenCL 1.2 support is advertised??
2704 // We need to workaround...
2705
2706 #define FILLSZ 0x100000
2707
2708 char *tmp = (char *) mymalloc (FILLSZ);
2709
2710 for (size_t i = 0; i < size; i += FILLSZ)
2711 {
2712 const size_t left = size - i;
2713
2714 const size_t fillsz = MIN (FILLSZ, left);
2715
2716 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2717 }
2718
2719 myfree (tmp);
2720 }
2721 */
2722 }
2723
2724 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)
2725 {
2726 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2727 {
2728 if (attack_mode == ATTACK_MODE_BF)
2729 {
2730 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2731 {
2732 const uint size_tm = 32 * sizeof (bs_word_t);
2733
2734 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2735
2736 run_kernel_tm (device_param);
2737
2738 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);
2739 }
2740 }
2741
2742 if (highest_pw_len < 16)
2743 {
2744 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
2745 }
2746 else if (highest_pw_len < 32)
2747 {
2748 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
2749 }
2750 else
2751 {
2752 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
2753 }
2754 }
2755 else
2756 {
2757 run_kernel_amp (device_param, pws_cnt);
2758
2759 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
2760
2761 if (opts_type & OPTS_TYPE_HOOK12)
2762 {
2763 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
2764 }
2765
2766 uint iter = salt_buf->salt_iter;
2767
2768 uint loop_step = device_param->kernel_loops;
2769
2770 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
2771 {
2772 uint loop_left = iter - loop_pos;
2773
2774 loop_left = MIN (loop_left, loop_step);
2775
2776 device_param->kernel_params_buf32[25] = loop_pos;
2777 device_param->kernel_params_buf32[26] = loop_left;
2778
2779 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
2780
2781 if (data.devices_status == STATUS_CRACKED) break;
2782 if (data.devices_status == STATUS_ABORTED) break;
2783 if (data.devices_status == STATUS_QUIT) break;
2784
2785 /**
2786 * speed
2787 */
2788
2789 const float iter_part = (float) (loop_pos + loop_left) / iter;
2790
2791 const u64 perf_sum_all = pws_cnt * iter_part;
2792
2793 double speed_ms;
2794
2795 hc_timer_get (device_param->timer_speed, speed_ms);
2796
2797 const u32 speed_pos = device_param->speed_pos;
2798
2799 device_param->speed_cnt[speed_pos] = perf_sum_all;
2800
2801 device_param->speed_ms[speed_pos] = speed_ms;
2802
2803 if (data.benchmark == 1)
2804 {
2805 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2806 }
2807 }
2808
2809 if (opts_type & OPTS_TYPE_HOOK23)
2810 {
2811 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
2812
2813 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);
2814
2815 // do something with data
2816
2817 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);
2818 }
2819
2820 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
2821 }
2822 }
2823
2824 static int run_rule_engine (const int rule_len, const char *rule_buf)
2825 {
2826 if (rule_len == 0)
2827 {
2828 return 0;
2829 }
2830 else if (rule_len == 1)
2831 {
2832 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2833 }
2834
2835 return 1;
2836 }
2837
2838 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2839 {
2840 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2841 {
2842 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);
2843 }
2844 else if (data.attack_kern == ATTACK_KERN_COMBI)
2845 {
2846 if (data.attack_mode == ATTACK_MODE_COMBI)
2847 {
2848 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2849 {
2850 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2851 {
2852 for (u32 i = 0; i < pws_cnt; i++)
2853 {
2854 const u32 pw_len = device_param->pws_buf[i].pw_len;
2855
2856 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2857
2858 ptr[pw_len] = 0x01;
2859 }
2860 }
2861 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2862 {
2863 for (u32 i = 0; i < pws_cnt; i++)
2864 {
2865 const u32 pw_len = device_param->pws_buf[i].pw_len;
2866
2867 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2868
2869 ptr[pw_len] = 0x80;
2870 }
2871 }
2872 }
2873 }
2874 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2875 {
2876 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2877 {
2878 for (u32 i = 0; i < pws_cnt; i++)
2879 {
2880 const u32 pw_len = device_param->pws_buf[i].pw_len;
2881
2882 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2883
2884 ptr[pw_len] = 0x01;
2885 }
2886 }
2887 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2888 {
2889 for (u32 i = 0; i < pws_cnt; i++)
2890 {
2891 const u32 pw_len = device_param->pws_buf[i].pw_len;
2892
2893 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2894
2895 ptr[pw_len] = 0x80;
2896 }
2897 }
2898 }
2899
2900 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);
2901 }
2902 else if (data.attack_kern == ATTACK_KERN_BF)
2903 {
2904 const u64 off = device_param->words_off;
2905
2906 device_param->kernel_params_mp_l_buf64[3] = off;
2907
2908 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2909 }
2910 }
2911
2912 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2913 {
2914 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2915
2916 device_param->kernel_params_buf32[25] = 0;
2917 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2918 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2919
2920 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2921 {
2922 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
2923 }
2924 else
2925 {
2926 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
2927 }
2928
2929 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2930
2931 return exec_ms_prev;
2932 }
2933
2934 static void autotune (hc_device_param_t *device_param)
2935 {
2936 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2937
2938 const u32 kernel_accel_min = device_param->kernel_accel_min;
2939 const u32 kernel_accel_max = device_param->kernel_accel_max;
2940
2941 const u32 kernel_loops_min = device_param->kernel_loops_min;
2942 const u32 kernel_loops_max = device_param->kernel_loops_max;
2943
2944 u32 kernel_accel = kernel_accel_min;
2945 u32 kernel_loops = kernel_loops_min;
2946
2947 // in this case the user specified a fixed -u and -n on the commandline
2948 // no way to tune anything
2949 // but we need to run a few caching rounds
2950
2951 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2952 {
2953 try_run (device_param, kernel_accel, kernel_loops);
2954 try_run (device_param, kernel_accel, kernel_loops);
2955 try_run (device_param, kernel_accel, kernel_loops);
2956 try_run (device_param, kernel_accel, kernel_loops);
2957
2958 device_param->kernel_accel = kernel_accel;
2959 device_param->kernel_loops = kernel_loops;
2960
2961 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2962
2963 device_param->kernel_power = kernel_power;
2964
2965 return;
2966 }
2967
2968 // from here it's clear we are allowed to autotune
2969 // so let's init some fake words
2970
2971 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2972
2973 if (data.attack_kern == ATTACK_KERN_BF)
2974 {
2975 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2976 }
2977 else
2978 {
2979 for (u32 i = 0; i < kernel_power_max; i++)
2980 {
2981 device_param->pws_buf[i].i[0] = i;
2982 device_param->pws_buf[i].i[1] = 0x01234567;
2983 device_param->pws_buf[i].pw_len = 7 + (i & 7);
2984 }
2985
2986 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);
2987 }
2988
2989 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2990 {
2991 if (data.kernel_rules_cnt > 1)
2992 {
2993 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);
2994 }
2995 }
2996 else
2997 {
2998 run_kernel_amp (device_param, kernel_power_max);
2999 }
3000
3001 #define VERIFIER_CNT 1
3002
3003 // first find out highest kernel-loops that stays below target_ms
3004
3005 if (kernel_loops_min < kernel_loops_max)
3006 {
3007 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3008 {
3009 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3010
3011 for (int i = 0; i < VERIFIER_CNT; i++)
3012 {
3013 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3014
3015 exec_ms = MIN (exec_ms, exec_ms_v);
3016 }
3017
3018 if (exec_ms < target_ms) break;
3019 }
3020 }
3021
3022 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3023
3024 #define STEPS_CNT 10
3025
3026 if (kernel_accel_min < kernel_accel_max)
3027 {
3028 for (int i = 0; i < STEPS_CNT; i++)
3029 {
3030 const u32 kernel_accel_try = 1 << i;
3031
3032 if (kernel_accel_try < kernel_accel_min) continue;
3033 if (kernel_accel_try > kernel_accel_max) break;
3034
3035 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3036
3037 for (int i = 0; i < VERIFIER_CNT; i++)
3038 {
3039 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3040
3041 exec_ms = MIN (exec_ms, exec_ms_v);
3042 }
3043
3044 if (exec_ms > target_ms) break;
3045
3046 kernel_accel = kernel_accel_try;
3047 }
3048 }
3049
3050 // at this point we want to know the actual runtime for the following reason:
3051 // we need a reference for the balancing loop following up, and this
3052 // the balancing loop can have an effect that the creates a new opportunity, for example:
3053 // if the target is 95 ms and the current runtime is 48ms the above loop
3054 // stopped the execution because the previous exec_ms was > 95ms
3055 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3056 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3057
3058 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3059
3060 for (int i = 0; i < VERIFIER_CNT; i++)
3061 {
3062 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3063
3064 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3065 }
3066
3067 u32 diff = kernel_loops - kernel_accel;
3068
3069 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3070 {
3071 u32 kernel_accel_orig = kernel_accel;
3072 u32 kernel_loops_orig = kernel_loops;
3073
3074 for (u32 f = 1; f < 1024; f++)
3075 {
3076 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3077 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3078
3079 if (kernel_accel_try > kernel_accel_max) break;
3080 if (kernel_loops_try < kernel_loops_min) break;
3081
3082 u32 diff_new = kernel_loops_try - kernel_accel_try;
3083
3084 if (diff_new > diff) break;
3085
3086 diff_new = diff;
3087
3088 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3089
3090 for (int i = 0; i < VERIFIER_CNT; i++)
3091 {
3092 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3093
3094 exec_ms = MIN (exec_ms, exec_ms_v);
3095 }
3096
3097 if (exec_ms < exec_ms_pre_final)
3098 {
3099 exec_ms_pre_final = exec_ms;
3100
3101 kernel_accel = kernel_accel_try;
3102 kernel_loops = kernel_loops_try;
3103 }
3104 }
3105 }
3106
3107 const double exec_left = target_ms / exec_ms_pre_final;
3108
3109 const double accel_left = kernel_accel_max / kernel_accel;
3110
3111 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3112
3113 if (exec_accel_min >= 1.0)
3114 {
3115 // this is safe to not overflow kernel_accel_max because of accel_left
3116
3117 kernel_accel = (double) kernel_accel * exec_accel_min;
3118 }
3119
3120 // reset them fake words
3121
3122 /*
3123 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3124
3125 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);
3126 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);
3127 */
3128
3129 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3130
3131 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3132 {
3133 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3134 }
3135
3136 // reset timer
3137
3138 device_param->exec_pos = 0;
3139
3140 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3141
3142 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3143 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3144 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3145
3146 // store
3147
3148 device_param->kernel_accel = kernel_accel;
3149 device_param->kernel_loops = kernel_loops;
3150
3151 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3152
3153 device_param->kernel_power = kernel_power;
3154
3155 #ifdef DEBUG
3156
3157 if (data.quiet == 0)
3158 {
3159 clear_prompt ();
3160
3161 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3162 "Device #%u: autotuned kernel-loops to %u\n",
3163 device_param->device_id + 1, kernel_accel,
3164 device_param->device_id + 1, kernel_loops);
3165
3166 fprintf (stdout, "%s", PROMPT);
3167
3168 fflush (stdout);
3169 }
3170
3171 #endif
3172 }
3173
3174 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3175 {
3176 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3177
3178 // init speed timer
3179
3180 uint speed_pos = device_param->speed_pos;
3181
3182 #ifdef _POSIX
3183 if (device_param->timer_speed.tv_sec == 0)
3184 {
3185 hc_timer_set (&device_param->timer_speed);
3186 }
3187 #endif
3188
3189 #ifdef _WIN
3190 if (device_param->timer_speed.QuadPart == 0)
3191 {
3192 hc_timer_set (&device_param->timer_speed);
3193 }
3194 #endif
3195
3196 // find higest password length, this is for optimization stuff
3197
3198 uint highest_pw_len = 0;
3199
3200 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3201 {
3202 }
3203 else if (data.attack_kern == ATTACK_KERN_COMBI)
3204 {
3205 }
3206 else if (data.attack_kern == ATTACK_KERN_BF)
3207 {
3208 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3209 + device_param->kernel_params_mp_l_buf32[5];
3210 }
3211
3212 // iteration type
3213
3214 uint innerloop_step = 0;
3215 uint innerloop_cnt = 0;
3216
3217 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3218 else innerloop_step = 1;
3219
3220 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3221 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3222 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3223
3224 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3225
3226 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3227 {
3228 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3229
3230 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3231
3232 if (data.devices_status == STATUS_CRACKED) break;
3233 if (data.devices_status == STATUS_ABORTED) break;
3234 if (data.devices_status == STATUS_QUIT) break;
3235 if (data.devices_status == STATUS_BYPASS) break;
3236
3237 salt_t *salt_buf = &data.salts_buf[salt_pos];
3238
3239 device_param->kernel_params_buf32[24] = salt_pos;
3240 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3241 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3242
3243 FILE *combs_fp = device_param->combs_fp;
3244
3245 if (data.attack_mode == ATTACK_MODE_COMBI)
3246 {
3247 rewind (combs_fp);
3248 }
3249
3250 // innerloops
3251
3252 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3253 {
3254 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3255
3256 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3257
3258 if (data.devices_status == STATUS_CRACKED) break;
3259 if (data.devices_status == STATUS_ABORTED) break;
3260 if (data.devices_status == STATUS_QUIT) break;
3261 if (data.devices_status == STATUS_BYPASS) break;
3262
3263 uint fast_iteration = 0;
3264
3265 uint innerloop_left = innerloop_cnt - innerloop_pos;
3266
3267 if (innerloop_left > innerloop_step)
3268 {
3269 innerloop_left = innerloop_step;
3270
3271 fast_iteration = 1;
3272 }
3273
3274 device_param->innerloop_pos = innerloop_pos;
3275 device_param->innerloop_left = innerloop_left;
3276
3277 device_param->kernel_params_buf32[27] = innerloop_left;
3278
3279 // i think we can get rid of this
3280 if (innerloop_left == 0)
3281 {
3282 puts ("bug, how should this happen????\n");
3283
3284 continue;
3285 }
3286
3287 if (data.salts_shown[salt_pos] == 1)
3288 {
3289 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3290
3291 continue;
3292 }
3293
3294 // initialize amplifiers
3295
3296 if (data.attack_mode == ATTACK_MODE_COMBI)
3297 {
3298 uint i = 0;
3299
3300 while (i < innerloop_left)
3301 {
3302 if (feof (combs_fp)) break;
3303
3304 int line_len = fgetl (combs_fp, line_buf);
3305
3306 if (line_len >= PW_MAX1) continue;
3307
3308 line_len = convert_from_hex (line_buf, line_len);
3309
3310 char *line_buf_new = line_buf;
3311
3312 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3313 {
3314 char rule_buf_out[BLOCK_SIZE] = { 0 };
3315
3316 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3317
3318 if (rule_len_out < 0)
3319 {
3320 data.words_progress_rejected[salt_pos] += pws_cnt;
3321
3322 continue;
3323 }
3324
3325 line_len = rule_len_out;
3326
3327 line_buf_new = rule_buf_out;
3328 }
3329
3330 line_len = MIN (line_len, PW_DICTMAX);
3331
3332 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3333
3334 memcpy (ptr, line_buf_new, line_len);
3335
3336 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3337
3338 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3339 {
3340 uppercase (ptr, line_len);
3341 }
3342
3343 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3344 {
3345 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3346 {
3347 ptr[line_len] = 0x80;
3348 }
3349
3350 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3351 {
3352 ptr[line_len] = 0x01;
3353 }
3354 }
3355
3356 device_param->combs_buf[i].pw_len = line_len;
3357
3358 i++;
3359 }
3360
3361 for (uint j = i; j < innerloop_left; j++)
3362 {
3363 device_param->combs_buf[j].i[0] = 0;
3364 device_param->combs_buf[j].i[1] = 0;
3365 device_param->combs_buf[j].i[2] = 0;
3366 device_param->combs_buf[j].i[3] = 0;
3367 device_param->combs_buf[j].i[4] = 0;
3368 device_param->combs_buf[j].i[5] = 0;
3369 device_param->combs_buf[j].i[6] = 0;
3370 device_param->combs_buf[j].i[7] = 0;
3371
3372 device_param->combs_buf[j].pw_len = 0;
3373 }
3374
3375 innerloop_left = i;
3376 }
3377 else if (data.attack_mode == ATTACK_MODE_BF)
3378 {
3379 u64 off = innerloop_pos;
3380
3381 device_param->kernel_params_mp_r_buf64[3] = off;
3382
3383 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3384 }
3385 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3386 {
3387 u64 off = innerloop_pos;
3388
3389 device_param->kernel_params_mp_buf64[3] = off;
3390
3391 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3392 }
3393 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3394 {
3395 u64 off = innerloop_pos;
3396
3397 device_param->kernel_params_mp_buf64[3] = off;
3398
3399 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3400 }
3401
3402 // copy amplifiers
3403
3404 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3405 {
3406 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);
3407 }
3408 else if (data.attack_mode == ATTACK_MODE_COMBI)
3409 {
3410 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);
3411 }
3412 else if (data.attack_mode == ATTACK_MODE_BF)
3413 {
3414 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);
3415 }
3416 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3417 {
3418 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);
3419 }
3420 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3421 {
3422 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);
3423 }
3424
3425 if (data.benchmark == 1)
3426 {
3427 hc_timer_set (&device_param->timer_speed);
3428 }
3429
3430 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3431
3432 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3433
3434 if (data.devices_status == STATUS_CRACKED) break;
3435 if (data.devices_status == STATUS_ABORTED) break;
3436 if (data.devices_status == STATUS_QUIT) break;
3437
3438 /**
3439 * result
3440 */
3441
3442 if (data.benchmark == 0)
3443 {
3444 check_cracked (device_param, salt_pos);
3445 }
3446
3447 /**
3448 * progress
3449 */
3450
3451 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3452
3453 hc_thread_mutex_lock (mux_counter);
3454
3455 data.words_progress_done[salt_pos] += perf_sum_all;
3456
3457 hc_thread_mutex_unlock (mux_counter);
3458
3459 /**
3460 * speed
3461 */
3462
3463 double speed_ms;
3464
3465 hc_timer_get (device_param->timer_speed, speed_ms);
3466
3467 hc_timer_set (&device_param->timer_speed);
3468
3469 // current speed
3470
3471 //hc_thread_mutex_lock (mux_display);
3472
3473 device_param->speed_cnt[speed_pos] = perf_sum_all;
3474
3475 device_param->speed_ms[speed_pos] = speed_ms;
3476
3477 //hc_thread_mutex_unlock (mux_display);
3478
3479 speed_pos++;
3480
3481 if (speed_pos == SPEED_CACHE)
3482 {
3483 speed_pos = 0;
3484 }
3485
3486 /**
3487 * benchmark
3488 */
3489
3490 if (data.benchmark == 1) break;
3491 }
3492 }
3493
3494 device_param->speed_pos = speed_pos;
3495
3496 myfree (line_buf);
3497 }
3498
3499 static void load_segment (wl_data_t *wl_data, FILE *fd)
3500 {
3501 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3502
3503 wl_data->pos = 0;
3504
3505 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3506
3507 wl_data->buf[wl_data->cnt] = 0;
3508
3509 if (wl_data->cnt == 0) return;
3510
3511 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3512
3513 while (!feof (fd))
3514 {
3515 if (wl_data->cnt == wl_data->avail)
3516 {
3517 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3518
3519 wl_data->avail += wl_data->incr;
3520 }
3521
3522 const int c = fgetc (fd);
3523
3524 if (c == EOF) break;
3525
3526 wl_data->buf[wl_data->cnt] = (char) c;
3527
3528 wl_data->cnt++;
3529
3530 if (c == '\n') break;
3531 }
3532
3533 // ensure stream ends with a newline
3534
3535 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3536 {
3537 wl_data->cnt++;
3538
3539 wl_data->buf[wl_data->cnt - 1] = '\n';
3540 }
3541
3542 return;
3543 }
3544
3545 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3546 {
3547 char *ptr = buf;
3548
3549 for (u32 i = 0; i < sz; i++, ptr++)
3550 {
3551 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3552
3553 if (i == 7)
3554 {
3555 *off = i;
3556 *len = i;
3557
3558 return;
3559 }
3560
3561 if (*ptr != '\n') continue;
3562
3563 *off = i + 1;
3564
3565 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3566
3567 *len = i;
3568
3569 return;
3570 }
3571
3572 *off = sz;
3573 *len = sz;
3574 }
3575
3576 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3577 {
3578 char *ptr = buf;
3579
3580 for (u32 i = 0; i < sz; i++, ptr++)
3581 {
3582 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3583
3584 if (*ptr != '\n') continue;
3585
3586 *off = i + 1;
3587
3588 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3589
3590 *len = i;
3591
3592 return;
3593 }
3594
3595 *off = sz;
3596 *len = sz;
3597 }
3598
3599 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3600 {
3601 char *ptr = buf;
3602
3603 for (u32 i = 0; i < sz; i++, ptr++)
3604 {
3605 if (*ptr != '\n') continue;
3606
3607 *off = i + 1;
3608
3609 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3610
3611 *len = i;
3612
3613 return;
3614 }
3615
3616 *off = sz;
3617 *len = sz;
3618 }
3619
3620 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3621 {
3622 while (wl_data->pos < wl_data->cnt)
3623 {
3624 uint off;
3625 uint len;
3626
3627 char *ptr = wl_data->buf + wl_data->pos;
3628
3629 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3630
3631 wl_data->pos += off;
3632
3633 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3634 {
3635 char rule_buf_out[BLOCK_SIZE] = { 0 };
3636
3637 int rule_len_out = -1;
3638
3639 if (len < BLOCK_SIZE)
3640 {
3641 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3642 }
3643
3644 if (rule_len_out < 0)
3645 {
3646 continue;
3647 }
3648
3649 if (rule_len_out > PW_MAX)
3650 {
3651 continue;
3652 }
3653 }
3654 else
3655 {
3656 if (len > PW_MAX)
3657 {
3658 continue;
3659 }
3660 }
3661
3662 *out_buf = ptr;
3663 *out_len = len;
3664
3665 return;
3666 }
3667
3668 if (feof (fd))
3669 {
3670 fprintf (stderr, "BUG feof()!!\n");
3671
3672 return;
3673 }
3674
3675 load_segment (wl_data, fd);
3676
3677 get_next_word (wl_data, fd, out_buf, out_len);
3678 }
3679
3680 #ifdef _POSIX
3681 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3682 #endif
3683
3684 #ifdef _WIN
3685 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3686 #endif
3687 {
3688 hc_signal (NULL);
3689
3690 dictstat_t d;
3691
3692 d.cnt = 0;
3693
3694 #ifdef _POSIX
3695 fstat (fileno (fd), &d.stat);
3696 #endif
3697
3698 #ifdef _WIN
3699 _fstat64 (fileno (fd), &d.stat);
3700 #endif
3701
3702 d.stat.st_mode = 0;
3703 d.stat.st_nlink = 0;
3704 d.stat.st_uid = 0;
3705 d.stat.st_gid = 0;
3706 d.stat.st_rdev = 0;
3707 d.stat.st_atime = 0;
3708
3709 #ifdef _POSIX
3710 d.stat.st_blksize = 0;
3711 d.stat.st_blocks = 0;
3712 #endif
3713
3714 if (d.stat.st_size == 0) return 0;
3715
3716 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3717
3718 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3719 {
3720 if (d_cache)
3721 {
3722 u64 cnt = d_cache->cnt;
3723
3724 u64 keyspace = cnt;
3725
3726 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3727 {
3728 keyspace *= data.kernel_rules_cnt;
3729 }
3730 else if (data.attack_kern == ATTACK_KERN_COMBI)
3731 {
3732 keyspace *= data.combs_cnt;
3733 }
3734
3735 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);
3736 if (data.quiet == 0) log_info ("");
3737
3738 hc_signal (sigHandler_default);
3739
3740 return (keyspace);
3741 }
3742 }
3743
3744 time_t now = 0;
3745 time_t prev = 0;
3746
3747 u64 comp = 0;
3748 u64 cnt = 0;
3749 u64 cnt2 = 0;
3750
3751 while (!feof (fd))
3752 {
3753 load_segment (wl_data, fd);
3754
3755 comp += wl_data->cnt;
3756
3757 u32 i = 0;
3758
3759 while (i < wl_data->cnt)
3760 {
3761 u32 len;
3762 u32 off;
3763
3764 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3765
3766 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3767 {
3768 char rule_buf_out[BLOCK_SIZE] = { 0 };
3769
3770 int rule_len_out = -1;
3771
3772 if (len < BLOCK_SIZE)
3773 {
3774 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3775 }
3776
3777 if (rule_len_out < 0)
3778 {
3779 len = PW_MAX1;
3780 }
3781 else
3782 {
3783 len = rule_len_out;
3784 }
3785 }
3786
3787 if (len < PW_MAX1)
3788 {
3789 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3790 {
3791 cnt += data.kernel_rules_cnt;
3792 }
3793 else if (data.attack_kern == ATTACK_KERN_COMBI)
3794 {
3795 cnt += data.combs_cnt;
3796 }
3797
3798 d.cnt++;
3799 }
3800
3801 i += off;
3802
3803 cnt2++;
3804 }
3805
3806 time (&now);
3807
3808 if ((now - prev) == 0) continue;
3809
3810 float percent = (float) comp / (float) d.stat.st_size;
3811
3812 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);
3813
3814 time (&prev);
3815 }
3816
3817 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);
3818 if (data.quiet == 0) log_info ("");
3819
3820 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3821
3822 hc_signal (sigHandler_default);
3823
3824 return (cnt);
3825 }
3826
3827 static void *thread_monitor (void *p)
3828 {
3829 uint runtime_check = 0;
3830 uint remove_check = 0;
3831 uint status_check = 0;
3832 uint restore_check = 0;
3833
3834 uint restore_left = data.restore_timer;
3835 uint remove_left = data.remove_timer;
3836 uint status_left = data.status_timer;
3837
3838 #ifdef HAVE_HWMON
3839 uint hwmon_check = 0;
3840
3841 int slowdown_warnings = 0;
3842
3843 // these variables are mainly used for fan control
3844
3845 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3846
3847 // temperature controller "loopback" values
3848
3849 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3850 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3851
3852 int temp_threshold = 1; // degrees celcius
3853
3854 int fan_speed_min = 15; // in percentage
3855 int fan_speed_max = 100;
3856
3857 time_t last_temp_check_time;
3858 #endif // HAVE_HWMON
3859
3860 uint sleep_time = 1;
3861
3862 if (data.runtime)
3863 {
3864 runtime_check = 1;
3865 }
3866
3867 if (data.restore_timer)
3868 {
3869 restore_check = 1;
3870 }
3871
3872 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3873 {
3874 remove_check = 1;
3875 }
3876
3877 if (data.status == 1)
3878 {
3879 status_check = 1;
3880 }
3881
3882 #ifdef HAVE_HWMON
3883 if (data.gpu_temp_disable == 0)
3884 {
3885 time (&last_temp_check_time);
3886
3887 hwmon_check = 1;
3888 }
3889 #endif
3890
3891 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3892 {
3893 #ifdef HAVE_HWMON
3894 if (hwmon_check == 0)
3895 #endif
3896 return (p);
3897 }
3898
3899 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3900 {
3901 hc_sleep (sleep_time);
3902
3903 if (data.devices_status != STATUS_RUNNING) continue;
3904
3905 #ifdef HAVE_HWMON
3906
3907 if (hwmon_check == 1)
3908 {
3909 hc_thread_mutex_lock (mux_adl);
3910
3911 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3912 {
3913 hc_device_param_t *device_param = &data.devices_param[device_id];
3914
3915 if (device_param->skipped) continue;
3916
3917 if (device_param->device_vendor_id == VENDOR_ID_NV)
3918 {
3919 if (data.hm_nvapi)
3920 {
3921 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
3922 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
3923
3924 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
3925 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
3926
3927 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
3928
3929 perfPolicies_status.info_value = perfPolicies_info.info_value;
3930
3931 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
3932
3933 if (perfPolicies_status.throttle & 2)
3934 {
3935 if (slowdown_warnings < 3)
3936 {
3937 if (data.quiet == 0) clear_prompt ();
3938
3939 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
3940
3941 if (slowdown_warnings == 2)
3942 {
3943 log_info ("");
3944 }
3945
3946 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
3947 if (data.quiet == 0) fflush (stdout);
3948
3949 slowdown_warnings++;
3950 }
3951 }
3952 else
3953 {
3954 slowdown_warnings = 0;
3955 }
3956 }
3957 }
3958 }
3959
3960 hc_thread_mutex_unlock (mux_adl);
3961 }
3962
3963 if (hwmon_check == 1)
3964 {
3965 hc_thread_mutex_lock (mux_adl);
3966
3967 time_t temp_check_time;
3968
3969 time (&temp_check_time);
3970
3971 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3972
3973 if (Ta == 0) Ta = 1;
3974
3975 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3976 {
3977 hc_device_param_t *device_param = &data.devices_param[device_id];
3978
3979 if (device_param->skipped) continue;
3980
3981 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3982
3983 const int temperature = hm_get_temperature_with_device_id (device_id);
3984
3985 if (temperature > (int) data.gpu_temp_abort)
3986 {
3987 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3988
3989 if (data.devices_status != STATUS_QUIT) myabort ();
3990
3991 break;
3992 }
3993
3994 const int gpu_temp_retain = data.gpu_temp_retain;
3995
3996 if (gpu_temp_retain)
3997 {
3998 if (data.hm_device[device_id].fan_set_supported == 1)
3999 {
4000 int temp_cur = temperature;
4001
4002 int temp_diff_new = gpu_temp_retain - temp_cur;
4003
4004 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4005
4006 // calculate Ta value (time difference in seconds between the last check and this check)
4007
4008 last_temp_check_time = temp_check_time;
4009
4010 float Kp = 1.8;
4011 float Ki = 0.005;
4012 float Kd = 6;
4013
4014 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4015
4016 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);
4017
4018 if (abs (fan_diff_required) >= temp_threshold)
4019 {
4020 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4021
4022 int fan_speed_level = fan_speed_cur;
4023
4024 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4025
4026 int fan_speed_new = fan_speed_level - fan_diff_required;
4027
4028 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4029 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4030
4031 if (fan_speed_new != fan_speed_cur)
4032 {
4033 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4034 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4035
4036 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4037 {
4038 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4039 {
4040 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4041 }
4042 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4043 {
4044
4045 }
4046
4047 fan_speed_chgd[device_id] = 1;
4048 }
4049
4050 temp_diff_old[device_id] = temp_diff_new;
4051 }
4052 }
4053 }
4054 }
4055 }
4056
4057 hc_thread_mutex_unlock (mux_adl);
4058 }
4059 #endif // HAVE_HWMON
4060
4061 if (restore_check == 1)
4062 {
4063 restore_left--;
4064
4065 if (restore_left == 0)
4066 {
4067 if (data.restore_disable == 0) cycle_restore ();
4068
4069 restore_left = data.restore_timer;
4070 }
4071 }
4072
4073 if ((runtime_check == 1) && (data.runtime_start > 0))
4074 {
4075 time_t runtime_cur;
4076
4077 time (&runtime_cur);
4078
4079 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4080
4081 if (runtime_left <= 0)
4082 {
4083 if (data.benchmark == 0)
4084 {
4085 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4086 }
4087
4088 if (data.devices_status != STATUS_QUIT) myabort ();
4089 }
4090 }
4091
4092 if (remove_check == 1)
4093 {
4094 remove_left--;
4095
4096 if (remove_left == 0)
4097 {
4098 if (data.digests_saved != data.digests_done)
4099 {
4100 data.digests_saved = data.digests_done;
4101
4102 save_hash ();
4103 }
4104
4105 remove_left = data.remove_timer;
4106 }
4107 }
4108
4109 if (status_check == 1)
4110 {
4111 status_left--;
4112
4113 if (status_left == 0)
4114 {
4115 //hc_thread_mutex_lock (mux_display);
4116
4117 if (data.quiet == 0) clear_prompt ();
4118
4119 if (data.quiet == 0) log_info ("");
4120
4121 status_display ();
4122
4123 if (data.quiet == 0) log_info ("");
4124
4125 //hc_thread_mutex_unlock (mux_display);
4126
4127 status_left = data.status_timer;
4128 }
4129 }
4130 }
4131
4132 #ifdef HAVE_HWMON
4133 myfree (fan_speed_chgd);
4134
4135 myfree (temp_diff_old);
4136 myfree (temp_diff_sum);
4137 #endif
4138
4139 p = NULL;
4140
4141 return (p);
4142 }
4143
4144 static void *thread_outfile_remove (void *p)
4145 {
4146 // some hash-dependent constants
4147 char *outfile_dir = data.outfile_check_directory;
4148 uint dgst_size = data.dgst_size;
4149 uint isSalted = data.isSalted;
4150 uint esalt_size = data.esalt_size;
4151 uint hash_mode = data.hash_mode;
4152
4153 uint outfile_check_timer = data.outfile_check_timer;
4154
4155 char separator = data.separator;
4156
4157 // some hash-dependent functions
4158 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4159 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4160
4161 // buffers
4162 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4163
4164 hash_buf.digest = mymalloc (dgst_size);
4165
4166 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4167
4168 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4169
4170 uint digest_buf[64] = { 0 };
4171
4172 outfile_data_t *out_info = NULL;
4173
4174 char **out_files = NULL;
4175
4176 time_t folder_mtime = 0;
4177
4178 int out_cnt = 0;
4179
4180 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4181
4182 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4183 {
4184 hc_sleep (1);
4185
4186 if (data.devices_status != STATUS_RUNNING) continue;
4187
4188 check_left--;
4189
4190 if (check_left == 0)
4191 {
4192 struct stat outfile_check_stat;
4193
4194 if (stat (outfile_dir, &outfile_check_stat) == 0)
4195 {
4196 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4197
4198 if (is_dir == 1)
4199 {
4200 if (outfile_check_stat.st_mtime > folder_mtime)
4201 {
4202 char **out_files_new = scan_directory (outfile_dir);
4203
4204 int out_cnt_new = count_dictionaries (out_files_new);
4205
4206 outfile_data_t *out_info_new = NULL;
4207
4208 if (out_cnt_new > 0)
4209 {
4210 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4211
4212 for (int i = 0; i < out_cnt_new; i++)
4213 {
4214 out_info_new[i].file_name = out_files_new[i];
4215
4216 // check if there are files that we have seen/checked before (and not changed)
4217
4218 for (int j = 0; j < out_cnt; j++)
4219 {
4220 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4221 {
4222 struct stat outfile_stat;
4223
4224 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4225 {
4226 if (outfile_stat.st_ctime == out_info[j].ctime)
4227 {
4228 out_info_new[i].ctime = out_info[j].ctime;
4229 out_info_new[i].seek = out_info[j].seek;
4230 }
4231 }
4232 }
4233 }
4234 }
4235 }
4236
4237 local_free (out_info);
4238 local_free (out_files);
4239
4240 out_files = out_files_new;
4241 out_cnt = out_cnt_new;
4242 out_info = out_info_new;
4243
4244 folder_mtime = outfile_check_stat.st_mtime;
4245 }
4246
4247 for (int j = 0; j < out_cnt; j++)
4248 {
4249 FILE *fp = fopen (out_info[j].file_name, "rb");
4250
4251 if (fp != NULL)
4252 {
4253 //hc_thread_mutex_lock (mux_display);
4254
4255 #ifdef _POSIX
4256 struct stat outfile_stat;
4257
4258 fstat (fileno (fp), &outfile_stat);
4259 #endif
4260
4261 #ifdef _WIN
4262 struct stat64 outfile_stat;
4263
4264 _fstat64 (fileno (fp), &outfile_stat);
4265 #endif
4266
4267 if (outfile_stat.st_ctime > out_info[j].ctime)
4268 {
4269 out_info[j].ctime = outfile_stat.st_ctime;
4270 out_info[j].seek = 0;
4271 }
4272
4273 fseek (fp, out_info[j].seek, SEEK_SET);
4274
4275 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4276
4277 while (!feof (fp))
4278 {
4279 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4280
4281 if (ptr == NULL) break;
4282
4283 int line_len = strlen (line_buf);
4284
4285 if (line_len <= 0) continue;
4286
4287 int iter = MAX_CUT_TRIES;
4288
4289 for (uint i = line_len - 1; i && iter; i--, line_len--)
4290 {
4291 if (line_buf[i] != separator) continue;
4292
4293 int parser_status = PARSER_OK;
4294
4295 if ((hash_mode != 2500) && (hash_mode != 6800))
4296 {
4297 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4298 }
4299
4300 uint found = 0;
4301
4302 if (parser_status == PARSER_OK)
4303 {
4304 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4305 {
4306 if (data.salts_shown[salt_pos] == 1) continue;
4307
4308 salt_t *salt_buf = &data.salts_buf[salt_pos];
4309
4310 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4311 {
4312 uint idx = salt_buf->digests_offset + digest_pos;
4313
4314 if (data.digests_shown[idx] == 1) continue;
4315
4316 uint cracked = 0;
4317
4318 if (hash_mode == 6800)
4319 {
4320 if (i == salt_buf->salt_len)
4321 {
4322 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4323 }
4324 }
4325 else if (hash_mode == 2500)
4326 {
4327 // BSSID : MAC1 : MAC2 (:plain)
4328 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4329 {
4330 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4331
4332 if (!cracked) continue;
4333
4334 // now compare MAC1 and MAC2 too, since we have this additional info
4335 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4336 char *mac2_pos = mac1_pos + 12 + 1;
4337
4338 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4339 wpa_t *wpa = &wpas[salt_pos];
4340
4341 // compare hex string(s) vs binary MAC address(es)
4342
4343 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4344 {
4345 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4346 {
4347 cracked = 0;
4348
4349 break;
4350 }
4351 }
4352
4353 // early skip ;)
4354 if (!cracked) continue;
4355
4356 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4357 {
4358 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4359 {
4360 cracked = 0;
4361
4362 break;
4363 }
4364 }
4365 }
4366 }
4367 else
4368 {
4369 char *digests_buf_ptr = (char *) data.digests_buf;
4370
4371 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4372
4373 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4374 }
4375
4376 if (cracked == 1)
4377 {
4378 found = 1;
4379
4380 data.digests_shown[idx] = 1;
4381
4382 data.digests_done++;
4383
4384 salt_buf->digests_done++;
4385
4386 if (salt_buf->digests_done == salt_buf->digests_cnt)
4387 {
4388 data.salts_shown[salt_pos] = 1;
4389
4390 data.salts_done++;
4391
4392 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4393 }
4394 }
4395 }
4396
4397 if (data.devices_status == STATUS_CRACKED) break;
4398 }
4399 }
4400
4401 if (found) break;
4402
4403 if (data.devices_status == STATUS_CRACKED) break;
4404
4405 iter--;
4406 }
4407
4408 if (data.devices_status == STATUS_CRACKED) break;
4409 }
4410
4411 myfree (line_buf);
4412
4413 out_info[j].seek = ftell (fp);
4414
4415 //hc_thread_mutex_unlock (mux_display);
4416
4417 fclose (fp);
4418 }
4419 }
4420 }
4421 }
4422
4423 check_left = outfile_check_timer;
4424 }
4425 }
4426
4427 if (esalt_size) local_free (hash_buf.esalt);
4428
4429 if (isSalted) local_free (hash_buf.salt);
4430
4431 local_free (hash_buf.digest);
4432
4433 local_free (out_info);
4434
4435 local_free (out_files);
4436
4437 p = NULL;
4438
4439 return (p);
4440 }
4441
4442 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4443 {
4444 //if (device_param->pws_cnt < device_param->kernel_power)
4445 //{
4446 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4447
4448 u8 *ptr = (u8 *) pw->i;
4449
4450 memcpy (ptr, pw_buf, pw_len);
4451
4452 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4453
4454 pw->pw_len = pw_len;
4455
4456 device_param->pws_cnt++;
4457 //}
4458 //else
4459 //{
4460 // fprintf (stderr, "BUG pw_add()!!\n");
4461 //
4462 // return;
4463 //}
4464 }
4465
4466 static void set_kernel_power_final (const u64 kernel_power_final)
4467 {
4468 if (data.quiet == 0)
4469 {
4470 clear_prompt ();
4471
4472 //log_info ("");
4473
4474 log_info ("INFO: approaching final keyspace, workload adjusted");
4475 log_info ("");
4476
4477 fprintf (stdout, "%s", PROMPT);
4478
4479 fflush (stdout);
4480 }
4481
4482 data.kernel_power_final = kernel_power_final;
4483 }
4484
4485 static u32 get_power (hc_device_param_t *device_param)
4486 {
4487 const u64 kernel_power_final = data.kernel_power_final;
4488
4489 if (kernel_power_final)
4490 {
4491 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4492
4493 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4494
4495 // work should be at least the hardware power available without any accelerator
4496
4497 const u64 work = MAX (words_left_device, device_param->hardware_power);
4498
4499 return work;
4500 }
4501
4502 return device_param->kernel_power;
4503 }
4504
4505 static uint get_work (hc_device_param_t *device_param, const u64 max)
4506 {
4507 hc_thread_mutex_lock (mux_dispatcher);
4508
4509 const u64 words_cur = data.words_cur;
4510 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4511
4512 device_param->words_off = words_cur;
4513
4514 const u64 kernel_power_all = data.kernel_power_all;
4515
4516 const u64 words_left = words_base - words_cur;
4517
4518 if (words_left < kernel_power_all)
4519 {
4520 if (data.kernel_power_final == 0)
4521 {
4522 set_kernel_power_final (words_left);
4523 }
4524 }
4525
4526 const u32 kernel_power = get_power (device_param);
4527
4528 uint work = MIN (words_left, kernel_power);
4529
4530 work = MIN (work, max);
4531
4532 data.words_cur += work;
4533
4534 hc_thread_mutex_unlock (mux_dispatcher);
4535
4536 return work;
4537 }
4538
4539 static void *thread_autotune (void *p)
4540 {
4541 hc_device_param_t *device_param = (hc_device_param_t *) p;
4542
4543 if (device_param->skipped) return NULL;
4544
4545 autotune (device_param);
4546
4547 return NULL;
4548 }
4549
4550 static void *thread_calc_stdin (void *p)
4551 {
4552 hc_device_param_t *device_param = (hc_device_param_t *) p;
4553
4554 if (device_param->skipped) return NULL;
4555
4556 char *buf = (char *) mymalloc (HCBUFSIZ);
4557
4558 const uint attack_kern = data.attack_kern;
4559
4560 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4561 {
4562 hc_thread_mutex_lock (mux_dispatcher);
4563
4564 if (feof (stdin) != 0)
4565 {
4566 hc_thread_mutex_unlock (mux_dispatcher);
4567
4568 break;
4569 }
4570
4571 uint words_cur = 0;
4572
4573 while (words_cur < device_param->kernel_power)
4574 {
4575 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4576
4577 if (line_buf == NULL) break;
4578
4579 uint line_len = in_superchop (line_buf);
4580
4581 line_len = convert_from_hex (line_buf, line_len);
4582
4583 // post-process rule engine
4584
4585 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4586 {
4587 char rule_buf_out[BLOCK_SIZE] = { 0 };
4588
4589 int rule_len_out = -1;
4590
4591 if (line_len < BLOCK_SIZE)
4592 {
4593 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4594 }
4595
4596 if (rule_len_out < 0) continue;
4597
4598 line_buf = rule_buf_out;
4599 line_len = rule_len_out;
4600 }
4601
4602 if (line_len > PW_MAX)
4603 {
4604 continue;
4605 }
4606
4607 // hmm that's always the case, or?
4608
4609 if (attack_kern == ATTACK_KERN_STRAIGHT)
4610 {
4611 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4612 {
4613 hc_thread_mutex_lock (mux_counter);
4614
4615 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4616 {
4617 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4618 }
4619
4620 hc_thread_mutex_unlock (mux_counter);
4621
4622 continue;
4623 }
4624 }
4625
4626 pw_add (device_param, (u8 *) line_buf, line_len);
4627
4628 words_cur++;
4629
4630 if (data.devices_status == STATUS_CRACKED) break;
4631 if (data.devices_status == STATUS_ABORTED) break;
4632 if (data.devices_status == STATUS_QUIT) break;
4633 if (data.devices_status == STATUS_BYPASS) break;
4634 }
4635
4636 hc_thread_mutex_unlock (mux_dispatcher);
4637
4638 if (data.devices_status == STATUS_CRACKED) break;
4639 if (data.devices_status == STATUS_ABORTED) break;
4640 if (data.devices_status == STATUS_QUIT) break;
4641 if (data.devices_status == STATUS_BYPASS) break;
4642
4643 // flush
4644
4645 const uint pws_cnt = device_param->pws_cnt;
4646
4647 if (pws_cnt)
4648 {
4649 run_copy (device_param, pws_cnt);
4650
4651 run_cracker (device_param, pws_cnt);
4652
4653 device_param->pws_cnt = 0;
4654
4655 /*
4656 still required?
4657 if (attack_kern == ATTACK_KERN_STRAIGHT)
4658 {
4659 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4660 }
4661 else if (attack_kern == ATTACK_KERN_COMBI)
4662 {
4663 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4664 }
4665 */
4666 }
4667 }
4668
4669 device_param->kernel_accel = 0;
4670 device_param->kernel_loops = 0;
4671
4672 myfree (buf);
4673
4674 return NULL;
4675 }
4676
4677 static void *thread_calc (void *p)
4678 {
4679 hc_device_param_t *device_param = (hc_device_param_t *) p;
4680
4681 if (device_param->skipped) return NULL;
4682
4683 const uint attack_mode = data.attack_mode;
4684 const uint attack_kern = data.attack_kern;
4685
4686 if (attack_mode == ATTACK_MODE_BF)
4687 {
4688 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4689 {
4690 const uint work = get_work (device_param, -1);
4691
4692 if (work == 0) break;
4693
4694 const u64 words_off = device_param->words_off;
4695 const u64 words_fin = words_off + work;
4696
4697 const uint pws_cnt = work;
4698
4699 device_param->pws_cnt = pws_cnt;
4700
4701 if (pws_cnt)
4702 {
4703 run_copy (device_param, pws_cnt);
4704
4705 run_cracker (device_param, pws_cnt);
4706
4707 device_param->pws_cnt = 0;
4708
4709 /*
4710 still required?
4711 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4712 */
4713 }
4714
4715 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4716
4717 if (data.devices_status == STATUS_CRACKED) break;
4718 if (data.devices_status == STATUS_ABORTED) break;
4719 if (data.devices_status == STATUS_QUIT) break;
4720 if (data.devices_status == STATUS_BYPASS) break;
4721
4722 if (data.benchmark == 1) break;
4723
4724 device_param->words_done = words_fin;
4725 }
4726 }
4727 else
4728 {
4729 const uint segment_size = data.segment_size;
4730
4731 char *dictfile = data.dictfile;
4732
4733 if (attack_mode == ATTACK_MODE_COMBI)
4734 {
4735 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4736 {
4737 dictfile = data.dictfile2;
4738 }
4739 }
4740
4741 FILE *fd = fopen (dictfile, "rb");
4742
4743 if (fd == NULL)
4744 {
4745 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4746
4747 return NULL;
4748 }
4749
4750 if (attack_mode == ATTACK_MODE_COMBI)
4751 {
4752 const uint combs_mode = data.combs_mode;
4753
4754 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4755 {
4756 const char *dictfilec = data.dictfile2;
4757
4758 FILE *combs_fp = fopen (dictfilec, "rb");
4759
4760 if (combs_fp == NULL)
4761 {
4762 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4763
4764 fclose (fd);
4765
4766 return NULL;
4767 }
4768
4769 device_param->combs_fp = combs_fp;
4770 }
4771 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4772 {
4773 const char *dictfilec = data.dictfile;
4774
4775 FILE *combs_fp = fopen (dictfilec, "rb");
4776
4777 if (combs_fp == NULL)
4778 {
4779 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4780
4781 fclose (fd);
4782
4783 return NULL;
4784 }
4785
4786 device_param->combs_fp = combs_fp;
4787 }
4788 }
4789
4790 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4791
4792 wl_data->buf = (char *) mymalloc (segment_size);
4793 wl_data->avail = segment_size;
4794 wl_data->incr = segment_size;
4795 wl_data->cnt = 0;
4796 wl_data->pos = 0;
4797
4798 u64 words_cur = 0;
4799
4800 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4801 {
4802 u64 words_off = 0;
4803 u64 words_fin = 0;
4804
4805 u64 max = -1;
4806
4807 while (max)
4808 {
4809 const uint work = get_work (device_param, max);
4810
4811 if (work == 0) break;
4812
4813 max = 0;
4814
4815 words_off = device_param->words_off;
4816 words_fin = words_off + work;
4817
4818 char *line_buf;
4819 uint line_len;
4820
4821 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4822
4823 for ( ; words_cur < words_fin; words_cur++)
4824 {
4825 get_next_word (wl_data, fd, &line_buf, &line_len);
4826
4827 line_len = convert_from_hex (line_buf, line_len);
4828
4829 // post-process rule engine
4830
4831 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4832 {
4833 char rule_buf_out[BLOCK_SIZE] = { 0 };
4834
4835 int rule_len_out = -1;
4836
4837 if (line_len < BLOCK_SIZE)
4838 {
4839 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4840 }
4841
4842 if (rule_len_out < 0) continue;
4843
4844 line_buf = rule_buf_out;
4845 line_len = rule_len_out;
4846 }
4847
4848 if (attack_kern == ATTACK_KERN_STRAIGHT)
4849 {
4850 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4851 {
4852 max++;
4853
4854 hc_thread_mutex_lock (mux_counter);
4855
4856 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4857 {
4858 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4859 }
4860
4861 hc_thread_mutex_unlock (mux_counter);
4862
4863 continue;
4864 }
4865 }
4866 else if (attack_kern == ATTACK_KERN_COMBI)
4867 {
4868 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4869 // since we still need to combine the plains
4870
4871 if (line_len > data.pw_max)
4872 {
4873 max++;
4874
4875 hc_thread_mutex_lock (mux_counter);
4876
4877 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4878 {
4879 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4880 }
4881
4882 hc_thread_mutex_unlock (mux_counter);
4883
4884 continue;
4885 }
4886 }
4887
4888 pw_add (device_param, (u8 *) line_buf, line_len);
4889
4890 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4891
4892 if (data.devices_status == STATUS_CRACKED) break;
4893 if (data.devices_status == STATUS_ABORTED) break;
4894 if (data.devices_status == STATUS_QUIT) break;
4895 if (data.devices_status == STATUS_BYPASS) break;
4896 }
4897
4898 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4899
4900 if (data.devices_status == STATUS_CRACKED) break;
4901 if (data.devices_status == STATUS_ABORTED) break;
4902 if (data.devices_status == STATUS_QUIT) break;
4903 if (data.devices_status == STATUS_BYPASS) break;
4904 }
4905
4906 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4907
4908 if (data.devices_status == STATUS_CRACKED) break;
4909 if (data.devices_status == STATUS_ABORTED) break;
4910 if (data.devices_status == STATUS_QUIT) break;
4911 if (data.devices_status == STATUS_BYPASS) break;
4912
4913 //
4914 // flush
4915 //
4916
4917 const uint pws_cnt = device_param->pws_cnt;
4918
4919 if (pws_cnt)
4920 {
4921 run_copy (device_param, pws_cnt);
4922
4923 run_cracker (device_param, pws_cnt);
4924
4925 device_param->pws_cnt = 0;
4926
4927 /*
4928 still required?
4929 if (attack_kern == ATTACK_KERN_STRAIGHT)
4930 {
4931 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4932 }
4933 else if (attack_kern == ATTACK_KERN_COMBI)
4934 {
4935 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4936 }
4937 */
4938 }
4939
4940 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4941
4942 if (data.devices_status == STATUS_CRACKED) break;
4943 if (data.devices_status == STATUS_ABORTED) break;
4944 if (data.devices_status == STATUS_QUIT) break;
4945 if (data.devices_status == STATUS_BYPASS) break;
4946
4947 if (words_fin == 0) break;
4948
4949 device_param->words_done = words_fin;
4950 }
4951
4952 if (attack_mode == ATTACK_MODE_COMBI)
4953 {
4954 fclose (device_param->combs_fp);
4955 }
4956
4957 free (wl_data->buf);
4958 free (wl_data);
4959
4960 fclose (fd);
4961 }
4962
4963 device_param->kernel_accel = 0;
4964 device_param->kernel_loops = 0;
4965
4966 return NULL;
4967 }
4968
4969 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4970 {
4971 if (!device_param)
4972 {
4973 log_error ("ERROR: %s : Invalid argument", __func__);
4974
4975 exit (-1);
4976 }
4977
4978 salt_t *salt_buf = &data.salts_buf[salt_pos];
4979
4980 device_param->kernel_params_buf32[24] = salt_pos;
4981 device_param->kernel_params_buf32[27] = 1;
4982 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4983 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4984 device_param->kernel_params_buf32[30] = 0;
4985 device_param->kernel_params_buf32[31] = 1;
4986
4987 char *dictfile_old = data.dictfile;
4988
4989 const char *weak_hash_check = "weak-hash-check";
4990
4991 data.dictfile = (char *) weak_hash_check;
4992
4993 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4994
4995 data.kernel_rules_buf[0].cmds[0] = 0;
4996
4997 /**
4998 * run the kernel
4999 */
5000
5001 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5002 {
5003 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5004 }
5005 else
5006 {
5007 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5008
5009 uint loop_step = 16;
5010
5011 const uint iter = salt_buf->salt_iter;
5012
5013 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5014 {
5015 uint loop_left = iter - loop_pos;
5016
5017 loop_left = MIN (loop_left, loop_step);
5018
5019 device_param->kernel_params_buf32[25] = loop_pos;
5020 device_param->kernel_params_buf32[26] = loop_left;
5021
5022 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5023 }
5024
5025 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5026 }
5027
5028 /**
5029 * result
5030 */
5031
5032 check_cracked (device_param, salt_pos);
5033
5034 /**
5035 * cleanup
5036 */
5037
5038 device_param->kernel_params_buf32[24] = 0;
5039 device_param->kernel_params_buf32[25] = 0;
5040 device_param->kernel_params_buf32[26] = 0;
5041 device_param->kernel_params_buf32[27] = 0;
5042 device_param->kernel_params_buf32[28] = 0;
5043 device_param->kernel_params_buf32[29] = 0;
5044 device_param->kernel_params_buf32[30] = 0;
5045 device_param->kernel_params_buf32[31] = 0;
5046
5047 data.dictfile = dictfile_old;
5048
5049 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5050 }
5051
5052 // hlfmt hashcat
5053
5054 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5055 {
5056 if (data.username == 0)
5057 {
5058 *hashbuf_pos = line_buf;
5059 *hashbuf_len = line_len;
5060 }
5061 else
5062 {
5063 char *pos = line_buf;
5064 int len = line_len;
5065
5066 for (int i = 0; i < line_len; i++, pos++, len--)
5067 {
5068 if (line_buf[i] == data.separator)
5069 {
5070 pos++;
5071
5072 len--;
5073
5074 break;
5075 }
5076 }
5077
5078 *hashbuf_pos = pos;
5079 *hashbuf_len = len;
5080 }
5081 }
5082
5083 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5084 {
5085 char *pos = NULL;
5086 int len = 0;
5087
5088 int sep_cnt = 0;
5089
5090 for (int i = 0; i < line_len; i++)
5091 {
5092 if (line_buf[i] == data.separator)
5093 {
5094 sep_cnt++;
5095
5096 continue;
5097 }
5098
5099 if (sep_cnt == 0)
5100 {
5101 if (pos == NULL) pos = line_buf + i;
5102
5103 len++;
5104 }
5105 }
5106
5107 *userbuf_pos = pos;
5108 *userbuf_len = len;
5109 }
5110
5111 // hlfmt pwdump
5112
5113 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5114 {
5115 int sep_cnt = 0;
5116
5117 int sep2_len = 0;
5118 int sep3_len = 0;
5119
5120 for (int i = 0; i < line_len; i++)
5121 {
5122 if (line_buf[i] == ':')
5123 {
5124 sep_cnt++;
5125
5126 continue;
5127 }
5128
5129 if (sep_cnt == 2) sep2_len++;
5130 if (sep_cnt == 3) sep3_len++;
5131 }
5132
5133 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5134
5135 return 0;
5136 }
5137
5138 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5139 {
5140 char *pos = NULL;
5141 int len = 0;
5142
5143 int sep_cnt = 0;
5144
5145 for (int i = 0; i < line_len; i++)
5146 {
5147 if (line_buf[i] == ':')
5148 {
5149 sep_cnt++;
5150
5151 continue;
5152 }
5153
5154 if (data.hash_mode == 1000)
5155 {
5156 if (sep_cnt == 3)
5157 {
5158 if (pos == NULL) pos = line_buf + i;
5159
5160 len++;
5161 }
5162 }
5163 else if (data.hash_mode == 3000)
5164 {
5165 if (sep_cnt == 2)
5166 {
5167 if (pos == NULL) pos = line_buf + i;
5168
5169 len++;
5170 }
5171 }
5172 }
5173
5174 *hashbuf_pos = pos;
5175 *hashbuf_len = len;
5176 }
5177
5178 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5179 {
5180 char *pos = NULL;
5181 int len = 0;
5182
5183 int sep_cnt = 0;
5184
5185 for (int i = 0; i < line_len; i++)
5186 {
5187 if (line_buf[i] == ':')
5188 {
5189 sep_cnt++;
5190
5191 continue;
5192 }
5193
5194 if (sep_cnt == 0)
5195 {
5196 if (pos == NULL) pos = line_buf + i;
5197
5198 len++;
5199 }
5200 }
5201
5202 *userbuf_pos = pos;
5203 *userbuf_len = len;
5204 }
5205
5206 // hlfmt passwd
5207
5208 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5209 {
5210 int sep_cnt = 0;
5211
5212 char sep5_first = 0;
5213 char sep6_first = 0;
5214
5215 for (int i = 0; i < line_len; i++)
5216 {
5217 if (line_buf[i] == ':')
5218 {
5219 sep_cnt++;
5220
5221 continue;
5222 }
5223
5224 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5225 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5226 }
5227
5228 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5229
5230 return 0;
5231 }
5232
5233 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5234 {
5235 char *pos = NULL;
5236 int len = 0;
5237
5238 int sep_cnt = 0;
5239
5240 for (int i = 0; i < line_len; i++)
5241 {
5242 if (line_buf[i] == ':')
5243 {
5244 sep_cnt++;
5245
5246 continue;
5247 }
5248
5249 if (sep_cnt == 1)
5250 {
5251 if (pos == NULL) pos = line_buf + i;
5252
5253 len++;
5254 }
5255 }
5256
5257 *hashbuf_pos = pos;
5258 *hashbuf_len = len;
5259 }
5260
5261 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5262 {
5263 char *pos = NULL;
5264 int len = 0;
5265
5266 int sep_cnt = 0;
5267
5268 for (int i = 0; i < line_len; i++)
5269 {
5270 if (line_buf[i] == ':')
5271 {
5272 sep_cnt++;
5273
5274 continue;
5275 }
5276
5277 if (sep_cnt == 0)
5278 {
5279 if (pos == NULL) pos = line_buf + i;
5280
5281 len++;
5282 }
5283 }
5284
5285 *userbuf_pos = pos;
5286 *userbuf_len = len;
5287 }
5288
5289 // hlfmt shadow
5290
5291 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5292 {
5293 int sep_cnt = 0;
5294
5295 for (int i = 0; i < line_len; i++)
5296 {
5297 if (line_buf[i] == ':') sep_cnt++;
5298 }
5299
5300 if (sep_cnt == 8) return 1;
5301
5302 return 0;
5303 }
5304
5305 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5306 {
5307 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5308 }
5309
5310 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5311 {
5312 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5313 }
5314
5315 // hlfmt main
5316
5317 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5318 {
5319 switch (hashfile_format)
5320 {
5321 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5322 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5323 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5324 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5325 }
5326 }
5327
5328 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5329 {
5330 switch (hashfile_format)
5331 {
5332 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5333 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5334 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5335 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5336 }
5337 }
5338
5339 char *strhlfmt (const uint hashfile_format)
5340 {
5341 switch (hashfile_format)
5342 {
5343 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5344 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5345 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5346 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5347 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5348 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5349 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5350 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5351 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5352 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5353 }
5354
5355 return ((char *) "Unknown");
5356 }
5357
5358 static uint hlfmt_detect (FILE *fp, uint max_check)
5359 {
5360 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5361
5362 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5363 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5364
5365 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5366
5367 uint num_check = 0;
5368
5369 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5370
5371 while (!feof (fp))
5372 {
5373 int line_len = fgetl (fp, line_buf);
5374
5375 if (line_len == 0) continue;
5376
5377 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5378 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5379 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5380
5381 if (num_check == max_check) break;
5382
5383 num_check++;
5384 }
5385
5386 myfree (line_buf);
5387
5388 uint hashlist_format = HLFMT_HASHCAT;
5389
5390 for (int i = 1; i < HLFMTS_CNT; i++)
5391 {
5392 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5393
5394 hashlist_format = i;
5395 }
5396
5397 free (formats_cnt);
5398
5399 return hashlist_format;
5400 }
5401
5402 /**
5403 * some further helper function
5404 */
5405
5406 // wrapper around mymalloc for ADL
5407
5408 #if defined(HAVE_HWMON)
5409 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5410 {
5411 return mymalloc (iSize);
5412 }
5413 #endif
5414
5415 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)
5416 {
5417 u64 collisions = 0;
5418
5419 const uint dgst_pos0 = data.dgst_pos0;
5420 const uint dgst_pos1 = data.dgst_pos1;
5421 const uint dgst_pos2 = data.dgst_pos2;
5422 const uint dgst_pos3 = data.dgst_pos3;
5423
5424 memset (bitmap_a, 0, bitmap_size);
5425 memset (bitmap_b, 0, bitmap_size);
5426 memset (bitmap_c, 0, bitmap_size);
5427 memset (bitmap_d, 0, bitmap_size);
5428
5429 for (uint i = 0; i < digests_cnt; i++)
5430 {
5431 uint *digest_ptr = (uint *) digests_buf_ptr;
5432
5433 digests_buf_ptr += dgst_size;
5434
5435 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5436 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5437 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5438 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5439
5440 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5441 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5442 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5443 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5444
5445 if (bitmap_a[idx0] & val0) collisions++;
5446 if (bitmap_b[idx1] & val1) collisions++;
5447 if (bitmap_c[idx2] & val2) collisions++;
5448 if (bitmap_d[idx3] & val3) collisions++;
5449
5450 bitmap_a[idx0] |= val0;
5451 bitmap_b[idx1] |= val1;
5452 bitmap_c[idx2] |= val2;
5453 bitmap_d[idx3] |= val3;
5454
5455 if (collisions >= collisions_max) return 0x7fffffff;
5456 }
5457
5458 return collisions;
5459 }
5460
5461 /**
5462 * main
5463 */
5464
5465 #ifdef WIN
5466 void SetConsoleWindowSize (const int x)
5467 {
5468 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5469
5470 if (h == INVALID_HANDLE_VALUE) return;
5471
5472 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5473
5474 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5475
5476 SMALL_RECT *sr = &bufferInfo.srWindow;
5477
5478 sr->Right = MAX (sr->Right, x - 1);
5479
5480 COORD co;
5481
5482 co.X = sr->Right + 1;
5483 co.Y = 9999;
5484
5485 if (!SetConsoleScreenBufferSize (h, co)) return;
5486
5487 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5488 }
5489 #endif
5490
5491 int main (int argc, char **argv)
5492 {
5493 #ifdef WIN
5494 SetConsoleWindowSize (132);
5495 #endif
5496
5497 /**
5498 * To help users a bit
5499 */
5500
5501 char *compute = getenv ("COMPUTE");
5502
5503 if (compute)
5504 {
5505 static char display[100];
5506
5507 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5508
5509 putenv (display);
5510 }
5511 else
5512 {
5513 if (getenv ("DISPLAY") == NULL)
5514 putenv ((char *) "DISPLAY=:0");
5515 }
5516
5517 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5518 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5519
5520 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5521 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5522
5523 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5524 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5525
5526 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5527 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5528
5529 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5530 putenv ((char *) "POCL_KERNEL_CACHE=0");
5531
5532 umask (077);
5533
5534 /**
5535 * Real init
5536 */
5537
5538 memset (&data, 0, sizeof (hc_global_data_t));
5539
5540 time_t proc_start;
5541
5542 time (&proc_start);
5543
5544 data.proc_start = proc_start;
5545
5546 int myargc = argc;
5547 char **myargv = argv;
5548
5549 hc_thread_mutex_init (mux_dispatcher);
5550 hc_thread_mutex_init (mux_counter);
5551 hc_thread_mutex_init (mux_display);
5552 hc_thread_mutex_init (mux_adl);
5553
5554 /**
5555 * commandline parameters
5556 */
5557
5558 uint usage = USAGE;
5559 uint version = VERSION;
5560 uint quiet = QUIET;
5561 uint benchmark = BENCHMARK;
5562 uint show = SHOW;
5563 uint left = LEFT;
5564 uint username = USERNAME;
5565 uint remove = REMOVE;
5566 uint remove_timer = REMOVE_TIMER;
5567 u64 skip = SKIP;
5568 u64 limit = LIMIT;
5569 uint keyspace = KEYSPACE;
5570 uint potfile_disable = POTFILE_DISABLE;
5571 char *potfile_path = NULL;
5572 uint debug_mode = DEBUG_MODE;
5573 char *debug_file = NULL;
5574 char *induction_dir = NULL;
5575 char *outfile_check_dir = NULL;
5576 uint force = FORCE;
5577 uint runtime = RUNTIME;
5578 uint hash_mode = HASH_MODE;
5579 uint attack_mode = ATTACK_MODE;
5580 uint markov_disable = MARKOV_DISABLE;
5581 uint markov_classic = MARKOV_CLASSIC;
5582 uint markov_threshold = MARKOV_THRESHOLD;
5583 char *markov_hcstat = NULL;
5584 char *outfile = NULL;
5585 uint outfile_format = OUTFILE_FORMAT;
5586 uint outfile_autohex = OUTFILE_AUTOHEX;
5587 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5588 uint restore = RESTORE;
5589 uint restore_timer = RESTORE_TIMER;
5590 uint restore_disable = RESTORE_DISABLE;
5591 uint status = STATUS;
5592 uint status_timer = STATUS_TIMER;
5593 uint machine_readable = MACHINE_READABLE;
5594 uint loopback = LOOPBACK;
5595 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5596 char *session = NULL;
5597 uint hex_charset = HEX_CHARSET;
5598 uint hex_salt = HEX_SALT;
5599 uint hex_wordlist = HEX_WORDLIST;
5600 uint rp_gen = RP_GEN;
5601 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5602 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5603 uint rp_gen_seed = RP_GEN_SEED;
5604 char *rule_buf_l = (char *) RULE_BUF_L;
5605 char *rule_buf_r = (char *) RULE_BUF_R;
5606 uint increment = INCREMENT;
5607 uint increment_min = INCREMENT_MIN;
5608 uint increment_max = INCREMENT_MAX;
5609 char *cpu_affinity = NULL;
5610 OCL_PTR *ocl = NULL;
5611 char *opencl_devices = NULL;
5612 char *opencl_platforms = NULL;
5613 char *opencl_device_types = NULL;
5614 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5615 char *truecrypt_keyfiles = NULL;
5616 char *veracrypt_keyfiles = NULL;
5617 uint veracrypt_pim = 0;
5618 uint workload_profile = WORKLOAD_PROFILE;
5619 uint kernel_accel = KERNEL_ACCEL;
5620 uint kernel_loops = KERNEL_LOOPS;
5621 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5622 #ifdef HAVE_HWMON
5623 uint gpu_temp_abort = GPU_TEMP_ABORT;
5624 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5625 uint powertune_enable = POWERTUNE_ENABLE;
5626 #endif
5627 uint logfile_disable = LOGFILE_DISABLE;
5628 uint segment_size = SEGMENT_SIZE;
5629 uint scrypt_tmto = SCRYPT_TMTO;
5630 char separator = SEPARATOR;
5631 uint bitmap_min = BITMAP_MIN;
5632 uint bitmap_max = BITMAP_MAX;
5633 char *custom_charset_1 = NULL;
5634 char *custom_charset_2 = NULL;
5635 char *custom_charset_3 = NULL;
5636 char *custom_charset_4 = NULL;
5637
5638 #define IDX_HELP 'h'
5639 #define IDX_VERSION 'V'
5640 #define IDX_VERSION_LOWER 'v'
5641 #define IDX_QUIET 0xff02
5642 #define IDX_SHOW 0xff03
5643 #define IDX_LEFT 0xff04
5644 #define IDX_REMOVE 0xff05
5645 #define IDX_REMOVE_TIMER 0xff37
5646 #define IDX_SKIP 's'
5647 #define IDX_LIMIT 'l'
5648 #define IDX_KEYSPACE 0xff35
5649 #define IDX_POTFILE_DISABLE 0xff06
5650 #define IDX_POTFILE_PATH 0xffe0
5651 #define IDX_DEBUG_MODE 0xff43
5652 #define IDX_DEBUG_FILE 0xff44
5653 #define IDX_INDUCTION_DIR 0xff46
5654 #define IDX_OUTFILE_CHECK_DIR 0xff47
5655 #define IDX_USERNAME 0xff07
5656 #define IDX_FORCE 0xff08
5657 #define IDX_RUNTIME 0xff09
5658 #define IDX_BENCHMARK 'b'
5659 #define IDX_HASH_MODE 'm'
5660 #define IDX_ATTACK_MODE 'a'
5661 #define IDX_RP_FILE 'r'
5662 #define IDX_RP_GEN 'g'
5663 #define IDX_RP_GEN_FUNC_MIN 0xff10
5664 #define IDX_RP_GEN_FUNC_MAX 0xff11
5665 #define IDX_RP_GEN_SEED 0xff34
5666 #define IDX_RULE_BUF_L 'j'
5667 #define IDX_RULE_BUF_R 'k'
5668 #define IDX_INCREMENT 'i'
5669 #define IDX_INCREMENT_MIN 0xff12
5670 #define IDX_INCREMENT_MAX 0xff13
5671 #define IDX_OUTFILE 'o'
5672 #define IDX_OUTFILE_FORMAT 0xff14
5673 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5674 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5675 #define IDX_RESTORE 0xff15
5676 #define IDX_RESTORE_DISABLE 0xff27
5677 #define IDX_STATUS 0xff17
5678 #define IDX_STATUS_TIMER 0xff18
5679 #define IDX_MACHINE_READABLE 0xff50
5680 #define IDX_LOOPBACK 0xff38
5681 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5682 #define IDX_SESSION 0xff19
5683 #define IDX_HEX_CHARSET 0xff20
5684 #define IDX_HEX_SALT 0xff21
5685 #define IDX_HEX_WORDLIST 0xff40
5686 #define IDX_MARKOV_DISABLE 0xff22
5687 #define IDX_MARKOV_CLASSIC 0xff23
5688 #define IDX_MARKOV_THRESHOLD 't'
5689 #define IDX_MARKOV_HCSTAT 0xff24
5690 #define IDX_CPU_AFFINITY 0xff25
5691 #define IDX_OPENCL_DEVICES 'd'
5692 #define IDX_OPENCL_PLATFORMS 0xff72
5693 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5694 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5695 #define IDX_WORKLOAD_PROFILE 'w'
5696 #define IDX_KERNEL_ACCEL 'n'
5697 #define IDX_KERNEL_LOOPS 'u'
5698 #define IDX_GPU_TEMP_DISABLE 0xff29
5699 #define IDX_GPU_TEMP_ABORT 0xff30
5700 #define IDX_GPU_TEMP_RETAIN 0xff31
5701 #define IDX_POWERTUNE_ENABLE 0xff41
5702 #define IDX_LOGFILE_DISABLE 0xff51
5703 #define IDX_TRUECRYPT_KEYFILES 0xff52
5704 #define IDX_VERACRYPT_KEYFILES 0xff53
5705 #define IDX_VERACRYPT_PIM 0xff54
5706 #define IDX_SCRYPT_TMTO 0xff61
5707 #define IDX_SEGMENT_SIZE 'c'
5708 #define IDX_SEPARATOR 'p'
5709 #define IDX_BITMAP_MIN 0xff70
5710 #define IDX_BITMAP_MAX 0xff71
5711 #define IDX_CUSTOM_CHARSET_1 '1'
5712 #define IDX_CUSTOM_CHARSET_2 '2'
5713 #define IDX_CUSTOM_CHARSET_3 '3'
5714 #define IDX_CUSTOM_CHARSET_4 '4'
5715
5716 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5717
5718 struct option long_options[] =
5719 {
5720 {"help", no_argument, 0, IDX_HELP},
5721 {"version", no_argument, 0, IDX_VERSION},
5722 {"quiet", no_argument, 0, IDX_QUIET},
5723 {"show", no_argument, 0, IDX_SHOW},
5724 {"left", no_argument, 0, IDX_LEFT},
5725 {"username", no_argument, 0, IDX_USERNAME},
5726 {"remove", no_argument, 0, IDX_REMOVE},
5727 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5728 {"skip", required_argument, 0, IDX_SKIP},
5729 {"limit", required_argument, 0, IDX_LIMIT},
5730 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5731 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5732 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5733 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5734 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5735 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5736 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5737 {"force", no_argument, 0, IDX_FORCE},
5738 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5739 {"restore", no_argument, 0, IDX_RESTORE},
5740 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5741 {"status", no_argument, 0, IDX_STATUS},
5742 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5743 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5744 {"loopback", no_argument, 0, IDX_LOOPBACK},
5745 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5746 {"session", required_argument, 0, IDX_SESSION},
5747 {"runtime", required_argument, 0, IDX_RUNTIME},
5748 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5749 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5750 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5751 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5752 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5753 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5754 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5755 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5756 {"rules-file", required_argument, 0, IDX_RP_FILE},
5757 {"outfile", required_argument, 0, IDX_OUTFILE},
5758 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5759 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5760 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5761 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5762 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5763 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5764 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5765 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5766 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5767 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5768 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5769 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5770 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5771 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5772 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5773 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5774 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5775 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5776 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5777 #ifdef HAVE_HWMON
5778 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5779 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5780 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5781 #endif // HAVE_HWMON
5782 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5783 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5784 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5785 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5786 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5787 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5788 {"seperator", required_argument, 0, IDX_SEPARATOR},
5789 {"separator", required_argument, 0, IDX_SEPARATOR},
5790 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5791 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5792 {"increment", no_argument, 0, IDX_INCREMENT},
5793 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5794 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5795 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5796 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5797 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5798 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5799 {0, 0, 0, 0}
5800 };
5801
5802 uint rp_files_cnt = 0;
5803
5804 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5805
5806 int option_index = 0;
5807 int c = -1;
5808
5809 optind = 1;
5810 optopt = 0;
5811
5812 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5813 {
5814 switch (c)
5815 {
5816 case IDX_HELP: usage = 1; break;
5817 case IDX_VERSION:
5818 case IDX_VERSION_LOWER: version = 1; break;
5819 case IDX_RESTORE: restore = 1; break;
5820 case IDX_SESSION: session = optarg; break;
5821 case IDX_SHOW: show = 1; break;
5822 case IDX_LEFT: left = 1; break;
5823 case '?': return (-1);
5824 }
5825 }
5826
5827 if (optopt != 0)
5828 {
5829 log_error ("ERROR: Invalid argument specified");
5830
5831 return (-1);
5832 }
5833
5834 /**
5835 * exit functions
5836 */
5837
5838 if (version)
5839 {
5840 log_info ("%s", VERSION_TAG);
5841
5842 return (0);
5843 }
5844
5845 if (usage)
5846 {
5847 usage_big_print (PROGNAME);
5848
5849 return (0);
5850 }
5851
5852 /**
5853 * session needs to be set, always!
5854 */
5855
5856 if (session == NULL) session = (char *) PROGNAME;
5857
5858 /**
5859 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5860 */
5861
5862 char *exec_path = get_exec_path ();
5863
5864 #ifdef LINUX
5865
5866 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5867 char *resolved_exec_path = realpath (exec_path, NULL);
5868
5869 char *install_dir = get_install_dir (resolved_exec_path);
5870 char *profile_dir = NULL;
5871 char *session_dir = NULL;
5872 char *shared_dir = NULL;
5873
5874 if (strcmp (install_dir, resolved_install_folder) == 0)
5875 {
5876 struct passwd *pw = getpwuid (getuid ());
5877
5878 const char *homedir = pw->pw_dir;
5879
5880 profile_dir = get_profile_dir (homedir);
5881 session_dir = get_session_dir (profile_dir);
5882 shared_dir = strdup (SHARED_FOLDER);
5883
5884 mkdir (profile_dir, 0700);
5885 mkdir (session_dir, 0700);
5886 }
5887 else
5888 {
5889 profile_dir = install_dir;
5890 session_dir = install_dir;
5891 shared_dir = install_dir;
5892 }
5893
5894 myfree (resolved_install_folder);
5895 myfree (resolved_exec_path);
5896
5897 #else
5898
5899 char *install_dir = get_install_dir (exec_path);
5900 char *profile_dir = install_dir;
5901 char *session_dir = install_dir;
5902 char *shared_dir = install_dir;
5903
5904 #endif
5905
5906 data.install_dir = install_dir;
5907 data.profile_dir = profile_dir;
5908 data.session_dir = session_dir;
5909 data.shared_dir = shared_dir;
5910
5911 myfree (exec_path);
5912
5913 /**
5914 * kernel cache, we need to make sure folder exist
5915 */
5916
5917 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5918
5919 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5920
5921 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5922
5923 mkdir (kernels_folder, 0700);
5924
5925 myfree (kernels_folder);
5926
5927 /**
5928 * session
5929 */
5930
5931 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5932
5933 data.session = session;
5934
5935 char *eff_restore_file = (char *) mymalloc (session_size);
5936 char *new_restore_file = (char *) mymalloc (session_size);
5937
5938 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5939 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5940
5941 data.eff_restore_file = eff_restore_file;
5942 data.new_restore_file = new_restore_file;
5943
5944 if (((show == 1) || (left == 1)) && (restore == 1))
5945 {
5946 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5947 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5948
5949 return (-1);
5950 }
5951
5952 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5953 if ((show == 1) || (left == 1))
5954 {
5955 restore_disable = 1;
5956
5957 restore = 0;
5958 }
5959
5960 data.restore_disable = restore_disable;
5961
5962 restore_data_t *rd = init_restore (argc, argv);
5963
5964 data.rd = rd;
5965
5966 /**
5967 * restore file
5968 */
5969
5970 if (restore == 1)
5971 {
5972 read_restore (eff_restore_file, rd);
5973
5974 if (rd->version_bin < RESTORE_MIN)
5975 {
5976 log_error ("ERROR: Incompatible restore-file version");
5977
5978 return (-1);
5979 }
5980
5981 myargc = rd->argc;
5982 myargv = rd->argv;
5983
5984 #ifdef _POSIX
5985 rd->pid = getpid ();
5986 #elif _WIN
5987 rd->pid = GetCurrentProcessId ();
5988 #endif
5989 }
5990
5991 uint hash_mode_chgd = 0;
5992 uint runtime_chgd = 0;
5993 uint kernel_loops_chgd = 0;
5994 uint kernel_accel_chgd = 0;
5995 uint attack_mode_chgd = 0;
5996 uint outfile_format_chgd = 0;
5997 uint rp_gen_seed_chgd = 0;
5998 uint remove_timer_chgd = 0;
5999 uint increment_min_chgd = 0;
6000 uint increment_max_chgd = 0;
6001 uint workload_profile_chgd = 0;
6002 uint opencl_vector_width_chgd = 0;
6003
6004 optind = 1;
6005 optopt = 0;
6006 option_index = 0;
6007
6008 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6009 {
6010 switch (c)
6011 {
6012 //case IDX_HELP: usage = 1; break;
6013 //case IDX_VERSION: version = 1; break;
6014 //case IDX_RESTORE: restore = 1; break;
6015 case IDX_QUIET: quiet = 1; break;
6016 //case IDX_SHOW: show = 1; break;
6017 case IDX_SHOW: break;
6018 //case IDX_LEFT: left = 1; break;
6019 case IDX_LEFT: break;
6020 case IDX_USERNAME: username = 1; break;
6021 case IDX_REMOVE: remove = 1; break;
6022 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6023 remove_timer_chgd = 1; break;
6024 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6025 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6026 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6027 case IDX_DEBUG_FILE: debug_file = optarg; break;
6028 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6029 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6030 case IDX_FORCE: force = 1; break;
6031 case IDX_SKIP: skip = atoll (optarg); break;
6032 case IDX_LIMIT: limit = atoll (optarg); break;
6033 case IDX_KEYSPACE: keyspace = 1; break;
6034 case IDX_BENCHMARK: benchmark = 1; break;
6035 case IDX_RESTORE: break;
6036 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6037 case IDX_STATUS: status = 1; break;
6038 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6039 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6040 case IDX_LOOPBACK: loopback = 1; break;
6041 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6042 //case IDX_SESSION: session = optarg; break;
6043 case IDX_SESSION: break;
6044 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6045 hash_mode_chgd = 1; break;
6046 case IDX_RUNTIME: runtime = atoi (optarg);
6047 runtime_chgd = 1; break;
6048 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6049 attack_mode_chgd = 1; break;
6050 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6051 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6052 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6053 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6054 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6055 rp_gen_seed_chgd = 1; break;
6056 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6057 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6058 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6059 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6060 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6061 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6062 case IDX_OUTFILE: outfile = optarg; break;
6063 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6064 outfile_format_chgd = 1; break;
6065 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6066 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6067 case IDX_HEX_CHARSET: hex_charset = 1; break;
6068 case IDX_HEX_SALT: hex_salt = 1; break;
6069 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6070 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6071 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6072 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6073 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6074 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6075 opencl_vector_width_chgd = 1; break;
6076 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6077 workload_profile_chgd = 1; break;
6078 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6079 kernel_accel_chgd = 1; break;
6080 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6081 kernel_loops_chgd = 1; break;
6082 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6083 #ifdef HAVE_HWMON
6084 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6085 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6086 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6087 #endif // HAVE_HWMON
6088 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6089 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6090 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6091 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6092 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6093 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6094 case IDX_SEPARATOR: separator = optarg[0]; break;
6095 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6096 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6097 case IDX_INCREMENT: increment = 1; break;
6098 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6099 increment_min_chgd = 1; break;
6100 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6101 increment_max_chgd = 1; break;
6102 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6103 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6104 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6105 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6106
6107 default:
6108 log_error ("ERROR: Invalid argument specified");
6109 return (-1);
6110 }
6111 }
6112
6113 if (optopt != 0)
6114 {
6115 log_error ("ERROR: Invalid argument specified");
6116
6117 return (-1);
6118 }
6119
6120 /**
6121 * Inform user things getting started,
6122 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6123 * - we do not need to check algorithm_pos
6124 */
6125
6126 if (quiet == 0)
6127 {
6128 if (benchmark == 1)
6129 {
6130 if (machine_readable == 0)
6131 {
6132 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6133 log_info ("");
6134 log_info ("Note: Reported benchmark cracking speed = real cracking speed");
6135 log_info ("To verify, run hashcat like this: only_one_hash.txt -a 3 -w 3 ?b?b?b?b?b?b?b");
6136 log_info ("");
6137 }
6138 else
6139 {
6140 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6141 }
6142 }
6143 else if (restore == 1)
6144 {
6145 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6146 log_info ("");
6147 }
6148 else
6149 {
6150 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6151 log_info ("");
6152 }
6153 }
6154
6155 /**
6156 * sanity check
6157 */
6158
6159 if (attack_mode > 7)
6160 {
6161 log_error ("ERROR: Invalid attack-mode specified");
6162
6163 return (-1);
6164 }
6165
6166 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6167 {
6168 log_error ("ERROR: Invalid runtime specified");
6169
6170 return (-1);
6171 }
6172
6173 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6174 {
6175 log_error ("ERROR: Invalid hash-type specified");
6176
6177 return (-1);
6178 }
6179
6180 // renamed hash modes
6181
6182 if (hash_mode_chgd)
6183 {
6184 int n = -1;
6185
6186 switch (hash_mode)
6187 {
6188 case 123: n = 124;
6189 break;
6190 }
6191
6192 if (n >= 0)
6193 {
6194 log_error ("Old -m specified, use -m %d instead", n);
6195
6196 return (-1);
6197 }
6198 }
6199
6200 if (username == 1)
6201 {
6202 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6203 {
6204 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6205
6206 return (-1);
6207 }
6208 }
6209
6210 if (outfile_format > 16)
6211 {
6212 log_error ("ERROR: Invalid outfile-format specified");
6213
6214 return (-1);
6215 }
6216
6217 if (left == 1)
6218 {
6219 if (outfile_format_chgd == 1)
6220 {
6221 if (outfile_format > 1)
6222 {
6223 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6224
6225 return (-1);
6226 }
6227 }
6228 else
6229 {
6230 outfile_format = OUTFILE_FMT_HASH;
6231 }
6232 }
6233
6234 if (show == 1)
6235 {
6236 if (outfile_format_chgd == 1)
6237 {
6238 if ((outfile_format > 7) && (outfile_format < 16))
6239 {
6240 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6241
6242 return (-1);
6243 }
6244 }
6245 }
6246
6247 if (increment_min < INCREMENT_MIN)
6248 {
6249 log_error ("ERROR: Invalid increment-min specified");
6250
6251 return (-1);
6252 }
6253
6254 if (increment_max > INCREMENT_MAX)
6255 {
6256 log_error ("ERROR: Invalid increment-max specified");
6257
6258 return (-1);
6259 }
6260
6261 if (increment_min > increment_max)
6262 {
6263 log_error ("ERROR: Invalid increment-min specified");
6264
6265 return (-1);
6266 }
6267
6268 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6269 {
6270 log_error ("ERROR: increment is not allowed in attack-mode 0");
6271
6272 return (-1);
6273 }
6274
6275 if ((increment == 0) && (increment_min_chgd == 1))
6276 {
6277 log_error ("ERROR: increment-min is only supported together with increment switch");
6278
6279 return (-1);
6280 }
6281
6282 if ((increment == 0) && (increment_max_chgd == 1))
6283 {
6284 log_error ("ERROR: increment-max is only supported together with increment switch");
6285
6286 return (-1);
6287 }
6288
6289 if (rp_files_cnt && rp_gen)
6290 {
6291 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6292
6293 return (-1);
6294 }
6295
6296 if (rp_files_cnt || rp_gen)
6297 {
6298 if (attack_mode != ATTACK_MODE_STRAIGHT)
6299 {
6300 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6301
6302 return (-1);
6303 }
6304 }
6305
6306 if (rp_gen_func_min > rp_gen_func_max)
6307 {
6308 log_error ("ERROR: Invalid rp-gen-func-min specified");
6309
6310 return (-1);
6311 }
6312
6313 if (kernel_accel_chgd == 1)
6314 {
6315 if (force == 0)
6316 {
6317 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6318 log_info ("Please consider using the option -w instead");
6319 log_info ("You can use --force to override this but do not post error reports if you do so");
6320 log_info ("");
6321
6322 return (-1);
6323 }
6324
6325 if (kernel_accel < 1)
6326 {
6327 log_error ("ERROR: Invalid kernel-accel specified");
6328
6329 return (-1);
6330 }
6331
6332 if (kernel_accel > 1024)
6333 {
6334 log_error ("ERROR: Invalid kernel-accel specified");
6335
6336 return (-1);
6337 }
6338 }
6339
6340 if (kernel_loops_chgd == 1)
6341 {
6342 if (force == 0)
6343 {
6344 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6345 log_info ("Please consider using the option -w instead");
6346 log_info ("You can use --force to override this but do not post error reports if you do so");
6347 log_info ("");
6348
6349 return (-1);
6350 }
6351
6352 if (kernel_loops < 1)
6353 {
6354 log_error ("ERROR: Invalid kernel-loops specified");
6355
6356 return (-1);
6357 }
6358
6359 if (kernel_loops > 1024)
6360 {
6361 log_error ("ERROR: Invalid kernel-loops specified");
6362
6363 return (-1);
6364 }
6365 }
6366
6367 if ((workload_profile < 1) || (workload_profile > 4))
6368 {
6369 log_error ("ERROR: workload-profile %i not available", workload_profile);
6370
6371 return (-1);
6372 }
6373
6374 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6375 {
6376 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6377
6378 return (-1);
6379 }
6380
6381 if (show == 1 || left == 1)
6382 {
6383 attack_mode = ATTACK_MODE_NONE;
6384
6385 if (remove == 1)
6386 {
6387 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6388
6389 return (-1);
6390 }
6391
6392 if (potfile_disable == 1)
6393 {
6394 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6395
6396 return (-1);
6397 }
6398 }
6399
6400 uint attack_kern = ATTACK_KERN_NONE;
6401
6402 switch (attack_mode)
6403 {
6404 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6405 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6406 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6407 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6408 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6409 }
6410
6411 if (benchmark == 0)
6412 {
6413 if (keyspace == 1)
6414 {
6415 int num_additional_params = 1;
6416
6417 if (attack_kern == ATTACK_KERN_COMBI)
6418 {
6419 num_additional_params = 2;
6420 }
6421
6422 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6423
6424 if (keyspace_wordlist_specified == 0) optind--;
6425 }
6426
6427 if (attack_kern == ATTACK_KERN_NONE)
6428 {
6429 if ((optind + 1) != myargc)
6430 {
6431 usage_mini_print (myargv[0]);
6432
6433 return (-1);
6434 }
6435 }
6436 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6437 {
6438 if ((optind + 1) > myargc)
6439 {
6440 usage_mini_print (myargv[0]);
6441
6442 return (-1);
6443 }
6444 }
6445 else if (attack_kern == ATTACK_KERN_COMBI)
6446 {
6447 if ((optind + 3) != myargc)
6448 {
6449 usage_mini_print (myargv[0]);
6450
6451 return (-1);
6452 }
6453 }
6454 else if (attack_kern == ATTACK_KERN_BF)
6455 {
6456 if ((optind + 1) > myargc)
6457 {
6458 usage_mini_print (myargv[0]);
6459
6460 return (-1);
6461 }
6462 }
6463 else
6464 {
6465 usage_mini_print (myargv[0]);
6466
6467 return (-1);
6468 }
6469 }
6470 else
6471 {
6472 if (myargv[optind] != 0)
6473 {
6474 log_error ("ERROR: Invalid argument for benchmark mode specified");
6475
6476 return (-1);
6477 }
6478
6479 if (attack_mode_chgd == 1)
6480 {
6481 if (attack_mode != ATTACK_MODE_BF)
6482 {
6483 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6484
6485 return (-1);
6486 }
6487 }
6488 }
6489
6490 if (skip != 0 && limit != 0)
6491 {
6492 limit += skip;
6493 }
6494
6495 if (keyspace == 1)
6496 {
6497 if (show == 1)
6498 {
6499 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6500
6501 return (-1);
6502 }
6503 else if (left == 1)
6504 {
6505 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6506
6507 return (-1);
6508 }
6509
6510 potfile_disable = 1;
6511
6512 restore_disable = 1;
6513
6514 restore = 0;
6515
6516 weak_hash_threshold = 0;
6517
6518 quiet = 1;
6519 }
6520
6521 if (remove_timer_chgd == 1)
6522 {
6523 if (remove == 0)
6524 {
6525 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6526
6527 return (-1);
6528 }
6529
6530 if (remove_timer < 1)
6531 {
6532 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6533
6534 return (-1);
6535 }
6536 }
6537
6538 if (loopback == 1)
6539 {
6540 if (attack_mode == ATTACK_MODE_STRAIGHT)
6541 {
6542 if ((rp_files_cnt == 0) && (rp_gen == 0))
6543 {
6544 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6545
6546 return (-1);
6547 }
6548 }
6549 else
6550 {
6551 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6552
6553 return (-1);
6554 }
6555 }
6556
6557 if (debug_mode > 0)
6558 {
6559 if (attack_mode != ATTACK_MODE_STRAIGHT)
6560 {
6561 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6562
6563 return (-1);
6564 }
6565
6566 if ((rp_files_cnt == 0) && (rp_gen == 0))
6567 {
6568 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6569
6570 return (-1);
6571 }
6572 }
6573
6574 if (debug_mode > 4)
6575 {
6576 log_error ("ERROR: Invalid debug-mode specified");
6577
6578 return (-1);
6579 }
6580
6581 if (debug_file != NULL)
6582 {
6583 if (debug_mode < 1)
6584 {
6585 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6586
6587 return (-1);
6588 }
6589 }
6590
6591 if (induction_dir != NULL)
6592 {
6593 if (attack_mode == ATTACK_MODE_BF)
6594 {
6595 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6596
6597 return (-1);
6598 }
6599 }
6600
6601 if (attack_mode != ATTACK_MODE_STRAIGHT)
6602 {
6603 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6604 {
6605 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6606
6607 return (-1);
6608 }
6609
6610 weak_hash_threshold = 0;
6611 }
6612
6613 /**
6614 * induction directory
6615 */
6616
6617 char *induction_directory = NULL;
6618
6619 if (attack_mode != ATTACK_MODE_BF)
6620 {
6621 if (induction_dir == NULL)
6622 {
6623 induction_directory = (char *) mymalloc (session_size);
6624
6625 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6626
6627 // create induction folder if it does not already exist
6628
6629 if (keyspace == 0)
6630 {
6631 if (rmdir (induction_directory) == -1)
6632 {
6633 if (errno == ENOENT)
6634 {
6635 // good, we can ignore
6636 }
6637 else if (errno == ENOTEMPTY)
6638 {
6639 char *induction_directory_mv = (char *) mymalloc (session_size);
6640
6641 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6642
6643 if (rename (induction_directory, induction_directory_mv) != 0)
6644 {
6645 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6646
6647 return (-1);
6648 }
6649 }
6650 else
6651 {
6652 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6653
6654 return (-1);
6655 }
6656 }
6657
6658 if (mkdir (induction_directory, 0700) == -1)
6659 {
6660 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6661
6662 return (-1);
6663 }
6664 }
6665 }
6666 else
6667 {
6668 induction_directory = induction_dir;
6669 }
6670 }
6671
6672 data.induction_directory = induction_directory;
6673
6674 /**
6675 * loopback
6676 */
6677
6678 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6679
6680 char *loopback_file = (char *) mymalloc (loopback_size);
6681
6682 /**
6683 * tuning db
6684 */
6685
6686 char tuning_db_file[256] = { 0 };
6687
6688 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6689
6690 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6691
6692 /**
6693 * outfile-check directory
6694 */
6695
6696 char *outfile_check_directory = NULL;
6697
6698 if (outfile_check_dir == NULL)
6699 {
6700 outfile_check_directory = (char *) mymalloc (session_size);
6701
6702 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6703 }
6704 else
6705 {
6706 outfile_check_directory = outfile_check_dir;
6707 }
6708
6709 data.outfile_check_directory = outfile_check_directory;
6710
6711 if (keyspace == 0)
6712 {
6713 struct stat outfile_check_stat;
6714
6715 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6716 {
6717 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6718
6719 if (is_dir == 0)
6720 {
6721 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6722
6723 return (-1);
6724 }
6725 }
6726 else if (outfile_check_dir == NULL)
6727 {
6728 if (mkdir (outfile_check_directory, 0700) == -1)
6729 {
6730 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6731
6732 return (-1);
6733 }
6734 }
6735 }
6736
6737 /**
6738 * special other stuff
6739 */
6740
6741 if (hash_mode == 9710)
6742 {
6743 outfile_format = 5;
6744 outfile_format_chgd = 1;
6745 }
6746
6747 if (hash_mode == 9810)
6748 {
6749 outfile_format = 5;
6750 outfile_format_chgd = 1;
6751 }
6752
6753 if (hash_mode == 10410)
6754 {
6755 outfile_format = 5;
6756 outfile_format_chgd = 1;
6757 }
6758
6759 /**
6760 * store stuff
6761 */
6762
6763 data.hash_mode = hash_mode;
6764 data.restore = restore;
6765 data.restore_timer = restore_timer;
6766 data.restore_disable = restore_disable;
6767 data.status = status;
6768 data.status_timer = status_timer;
6769 data.machine_readable = machine_readable;
6770 data.loopback = loopback;
6771 data.runtime = runtime;
6772 data.remove = remove;
6773 data.remove_timer = remove_timer;
6774 data.debug_mode = debug_mode;
6775 data.debug_file = debug_file;
6776 data.username = username;
6777 data.quiet = quiet;
6778 data.outfile = outfile;
6779 data.outfile_format = outfile_format;
6780 data.outfile_autohex = outfile_autohex;
6781 data.hex_charset = hex_charset;
6782 data.hex_salt = hex_salt;
6783 data.hex_wordlist = hex_wordlist;
6784 data.separator = separator;
6785 data.rp_files = rp_files;
6786 data.rp_files_cnt = rp_files_cnt;
6787 data.rp_gen = rp_gen;
6788 data.rp_gen_seed = rp_gen_seed;
6789 data.force = force;
6790 data.benchmark = benchmark;
6791 data.skip = skip;
6792 data.limit = limit;
6793 #ifdef HAVE_HWMON
6794 data.powertune_enable = powertune_enable;
6795 #endif
6796 data.logfile_disable = logfile_disable;
6797 data.truecrypt_keyfiles = truecrypt_keyfiles;
6798 data.veracrypt_keyfiles = veracrypt_keyfiles;
6799 data.veracrypt_pim = veracrypt_pim;
6800 data.scrypt_tmto = scrypt_tmto;
6801 data.workload_profile = workload_profile;
6802
6803 /**
6804 * cpu affinity
6805 */
6806
6807 if (cpu_affinity)
6808 {
6809 set_cpu_affinity (cpu_affinity);
6810 }
6811
6812 if (rp_gen_seed_chgd == 0)
6813 {
6814 srand (proc_start);
6815 }
6816 else
6817 {
6818 srand (rp_gen_seed);
6819 }
6820
6821 /**
6822 * logfile init
6823 */
6824
6825 if (logfile_disable == 0)
6826 {
6827 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6828
6829 char *logfile = (char *) mymalloc (logfile_size);
6830
6831 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6832
6833 data.logfile = logfile;
6834
6835 char *topid = logfile_generate_topid ();
6836
6837 data.topid = topid;
6838 }
6839
6840 // logfile_append() checks for logfile_disable internally to make it easier from here
6841
6842 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6843 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6844 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6845 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6846 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6847 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6848 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6849 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6850 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6851 #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));
6852
6853 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6854 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6855 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6856 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6857 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6858 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6859 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6860 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6861
6862 logfile_top_msg ("START");
6863
6864 logfile_top_uint (attack_mode);
6865 logfile_top_uint (attack_kern);
6866 logfile_top_uint (benchmark);
6867 logfile_top_uint (bitmap_min);
6868 logfile_top_uint (bitmap_max);
6869 logfile_top_uint (debug_mode);
6870 logfile_top_uint (force);
6871 logfile_top_uint (kernel_accel);
6872 logfile_top_uint (kernel_loops);
6873 logfile_top_uint (gpu_temp_disable);
6874 #ifdef HAVE_HWMON
6875 logfile_top_uint (gpu_temp_abort);
6876 logfile_top_uint (gpu_temp_retain);
6877 #endif
6878 logfile_top_uint (hash_mode);
6879 logfile_top_uint (hex_charset);
6880 logfile_top_uint (hex_salt);
6881 logfile_top_uint (hex_wordlist);
6882 logfile_top_uint (increment);
6883 logfile_top_uint (increment_max);
6884 logfile_top_uint (increment_min);
6885 logfile_top_uint (keyspace);
6886 logfile_top_uint (left);
6887 logfile_top_uint (logfile_disable);
6888 logfile_top_uint (loopback);
6889 logfile_top_uint (markov_classic);
6890 logfile_top_uint (markov_disable);
6891 logfile_top_uint (markov_threshold);
6892 logfile_top_uint (outfile_autohex);
6893 logfile_top_uint (outfile_check_timer);
6894 logfile_top_uint (outfile_format);
6895 logfile_top_uint (potfile_disable);
6896 logfile_top_string (potfile_path);
6897 #if defined(HAVE_HWMON)
6898 logfile_top_uint (powertune_enable);
6899 #endif
6900 logfile_top_uint (scrypt_tmto);
6901 logfile_top_uint (quiet);
6902 logfile_top_uint (remove);
6903 logfile_top_uint (remove_timer);
6904 logfile_top_uint (restore);
6905 logfile_top_uint (restore_disable);
6906 logfile_top_uint (restore_timer);
6907 logfile_top_uint (rp_gen);
6908 logfile_top_uint (rp_gen_func_max);
6909 logfile_top_uint (rp_gen_func_min);
6910 logfile_top_uint (rp_gen_seed);
6911 logfile_top_uint (runtime);
6912 logfile_top_uint (segment_size);
6913 logfile_top_uint (show);
6914 logfile_top_uint (status);
6915 logfile_top_uint (machine_readable);
6916 logfile_top_uint (status_timer);
6917 logfile_top_uint (usage);
6918 logfile_top_uint (username);
6919 logfile_top_uint (version);
6920 logfile_top_uint (weak_hash_threshold);
6921 logfile_top_uint (workload_profile);
6922 logfile_top_uint64 (limit);
6923 logfile_top_uint64 (skip);
6924 logfile_top_char (separator);
6925 logfile_top_string (cpu_affinity);
6926 logfile_top_string (custom_charset_1);
6927 logfile_top_string (custom_charset_2);
6928 logfile_top_string (custom_charset_3);
6929 logfile_top_string (custom_charset_4);
6930 logfile_top_string (debug_file);
6931 logfile_top_string (opencl_devices);
6932 logfile_top_string (opencl_platforms);
6933 logfile_top_string (opencl_device_types);
6934 logfile_top_uint (opencl_vector_width);
6935 logfile_top_string (induction_dir);
6936 logfile_top_string (markov_hcstat);
6937 logfile_top_string (outfile);
6938 logfile_top_string (outfile_check_dir);
6939 logfile_top_string (rule_buf_l);
6940 logfile_top_string (rule_buf_r);
6941 logfile_top_string (session);
6942 logfile_top_string (truecrypt_keyfiles);
6943 logfile_top_string (veracrypt_keyfiles);
6944 logfile_top_uint (veracrypt_pim);
6945
6946 /**
6947 * Init OpenCL library loader
6948 */
6949
6950 if (keyspace == 0)
6951 {
6952 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6953
6954 ocl_init (ocl);
6955
6956 data.ocl = ocl;
6957 }
6958
6959 /**
6960 * OpenCL platform selection
6961 */
6962
6963 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6964
6965 /**
6966 * OpenCL device selection
6967 */
6968
6969 u32 devices_filter = setup_devices_filter (opencl_devices);
6970
6971 /**
6972 * OpenCL device type selection
6973 */
6974
6975 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6976
6977 /**
6978 * benchmark
6979 */
6980
6981 if (benchmark == 1)
6982 {
6983 /**
6984 * disable useless stuff for benchmark
6985 */
6986
6987 status_timer = 0;
6988 restore_timer = 0;
6989 restore_disable = 1;
6990 potfile_disable = 1;
6991 weak_hash_threshold = 0;
6992 gpu_temp_disable = 1;
6993
6994 #ifdef HAVE_HWMON
6995 if (powertune_enable == 1)
6996 {
6997 gpu_temp_disable = 0;
6998 }
6999 #endif
7000
7001 data.status_timer = status_timer;
7002 data.restore_timer = restore_timer;
7003 data.restore_disable = restore_disable;
7004
7005 /**
7006 * force attack mode to be bruteforce
7007 */
7008
7009 attack_mode = ATTACK_MODE_BF;
7010 attack_kern = ATTACK_KERN_BF;
7011
7012 if (workload_profile_chgd == 0)
7013 {
7014 workload_profile = 3;
7015
7016 data.workload_profile = workload_profile;
7017 }
7018 }
7019
7020 /**
7021 * config
7022 */
7023
7024 uint hash_type = 0;
7025 uint salt_type = 0;
7026 uint attack_exec = 0;
7027 uint opts_type = 0;
7028 uint kern_type = 0;
7029 uint dgst_size = 0;
7030 uint esalt_size = 0;
7031 uint opti_type = 0;
7032 uint dgst_pos0 = -1;
7033 uint dgst_pos1 = -1;
7034 uint dgst_pos2 = -1;
7035 uint dgst_pos3 = -1;
7036
7037 int (*parse_func) (char *, uint, hash_t *);
7038 int (*sort_by_digest) (const void *, const void *);
7039
7040 uint algorithm_pos = 0;
7041 uint algorithm_max = 1;
7042
7043 uint *algorithms = default_benchmark_algorithms;
7044
7045 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7046
7047 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7048 {
7049 /*
7050 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7051 * the following algos are skipped entirely
7052 */
7053
7054 if (algorithm_pos > 0)
7055 {
7056 local_free (rd);
7057
7058 rd = init_restore (argc, argv);
7059
7060 data.rd = rd;
7061 }
7062
7063 /**
7064 * update hash_mode in case of multihash benchmark
7065 */
7066
7067 if (benchmark == 1)
7068 {
7069 if (hash_mode_chgd == 0)
7070 {
7071 hash_mode = algorithms[algorithm_pos];
7072
7073 data.hash_mode = hash_mode;
7074 }
7075
7076 quiet = 1;
7077
7078 data.quiet = quiet;
7079 }
7080
7081 switch (hash_mode)
7082 {
7083 case 0: hash_type = HASH_TYPE_MD5;
7084 salt_type = SALT_TYPE_NONE;
7085 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7086 opts_type = OPTS_TYPE_PT_GENERATE_LE
7087 | OPTS_TYPE_PT_ADD80
7088 | OPTS_TYPE_PT_ADDBITS14;
7089 kern_type = KERN_TYPE_MD5;
7090 dgst_size = DGST_SIZE_4_4;
7091 parse_func = md5_parse_hash;
7092 sort_by_digest = sort_by_digest_4_4;
7093 opti_type = OPTI_TYPE_ZERO_BYTE
7094 | OPTI_TYPE_PRECOMPUTE_INIT
7095 | OPTI_TYPE_PRECOMPUTE_MERKLE
7096 | OPTI_TYPE_MEET_IN_MIDDLE
7097 | OPTI_TYPE_EARLY_SKIP
7098 | OPTI_TYPE_NOT_ITERATED
7099 | OPTI_TYPE_NOT_SALTED
7100 | OPTI_TYPE_RAW_HASH;
7101 dgst_pos0 = 0;
7102 dgst_pos1 = 3;
7103 dgst_pos2 = 2;
7104 dgst_pos3 = 1;
7105 break;
7106
7107 case 10: hash_type = HASH_TYPE_MD5;
7108 salt_type = SALT_TYPE_INTERN;
7109 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7110 opts_type = OPTS_TYPE_PT_GENERATE_LE
7111 | OPTS_TYPE_ST_ADD80
7112 | OPTS_TYPE_ST_ADDBITS14;
7113 kern_type = KERN_TYPE_MD5_PWSLT;
7114 dgst_size = DGST_SIZE_4_4;
7115 parse_func = md5s_parse_hash;
7116 sort_by_digest = sort_by_digest_4_4;
7117 opti_type = OPTI_TYPE_ZERO_BYTE
7118 | OPTI_TYPE_PRECOMPUTE_INIT
7119 | OPTI_TYPE_PRECOMPUTE_MERKLE
7120 | OPTI_TYPE_MEET_IN_MIDDLE
7121 | OPTI_TYPE_EARLY_SKIP
7122 | OPTI_TYPE_NOT_ITERATED
7123 | OPTI_TYPE_APPENDED_SALT
7124 | OPTI_TYPE_RAW_HASH;
7125 dgst_pos0 = 0;
7126 dgst_pos1 = 3;
7127 dgst_pos2 = 2;
7128 dgst_pos3 = 1;
7129 break;
7130
7131 case 11: hash_type = HASH_TYPE_MD5;
7132 salt_type = SALT_TYPE_INTERN;
7133 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7134 opts_type = OPTS_TYPE_PT_GENERATE_LE
7135 | OPTS_TYPE_ST_ADD80
7136 | OPTS_TYPE_ST_ADDBITS14;
7137 kern_type = KERN_TYPE_MD5_PWSLT;
7138 dgst_size = DGST_SIZE_4_4;
7139 parse_func = joomla_parse_hash;
7140 sort_by_digest = sort_by_digest_4_4;
7141 opti_type = OPTI_TYPE_ZERO_BYTE
7142 | OPTI_TYPE_PRECOMPUTE_INIT
7143 | OPTI_TYPE_PRECOMPUTE_MERKLE
7144 | OPTI_TYPE_MEET_IN_MIDDLE
7145 | OPTI_TYPE_EARLY_SKIP
7146 | OPTI_TYPE_NOT_ITERATED
7147 | OPTI_TYPE_APPENDED_SALT
7148 | OPTI_TYPE_RAW_HASH;
7149 dgst_pos0 = 0;
7150 dgst_pos1 = 3;
7151 dgst_pos2 = 2;
7152 dgst_pos3 = 1;
7153 break;
7154
7155 case 12: hash_type = HASH_TYPE_MD5;
7156 salt_type = SALT_TYPE_INTERN;
7157 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7158 opts_type = OPTS_TYPE_PT_GENERATE_LE
7159 | OPTS_TYPE_ST_ADD80
7160 | OPTS_TYPE_ST_ADDBITS14;
7161 kern_type = KERN_TYPE_MD5_PWSLT;
7162 dgst_size = DGST_SIZE_4_4;
7163 parse_func = postgresql_parse_hash;
7164 sort_by_digest = sort_by_digest_4_4;
7165 opti_type = OPTI_TYPE_ZERO_BYTE
7166 | OPTI_TYPE_PRECOMPUTE_INIT
7167 | OPTI_TYPE_PRECOMPUTE_MERKLE
7168 | OPTI_TYPE_MEET_IN_MIDDLE
7169 | OPTI_TYPE_EARLY_SKIP
7170 | OPTI_TYPE_NOT_ITERATED
7171 | OPTI_TYPE_APPENDED_SALT
7172 | OPTI_TYPE_RAW_HASH;
7173 dgst_pos0 = 0;
7174 dgst_pos1 = 3;
7175 dgst_pos2 = 2;
7176 dgst_pos3 = 1;
7177 break;
7178
7179 case 20: hash_type = HASH_TYPE_MD5;
7180 salt_type = SALT_TYPE_INTERN;
7181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7182 opts_type = OPTS_TYPE_PT_GENERATE_LE
7183 | OPTS_TYPE_PT_ADD80
7184 | OPTS_TYPE_PT_ADDBITS14;
7185 kern_type = KERN_TYPE_MD5_SLTPW;
7186 dgst_size = DGST_SIZE_4_4;
7187 parse_func = md5s_parse_hash;
7188 sort_by_digest = sort_by_digest_4_4;
7189 opti_type = OPTI_TYPE_ZERO_BYTE
7190 | OPTI_TYPE_PRECOMPUTE_INIT
7191 | OPTI_TYPE_PRECOMPUTE_MERKLE
7192 | OPTI_TYPE_EARLY_SKIP
7193 | OPTI_TYPE_NOT_ITERATED
7194 | OPTI_TYPE_PREPENDED_SALT
7195 | OPTI_TYPE_RAW_HASH;
7196 dgst_pos0 = 0;
7197 dgst_pos1 = 3;
7198 dgst_pos2 = 2;
7199 dgst_pos3 = 1;
7200 break;
7201
7202 case 21: hash_type = HASH_TYPE_MD5;
7203 salt_type = SALT_TYPE_INTERN;
7204 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7205 opts_type = OPTS_TYPE_PT_GENERATE_LE
7206 | OPTS_TYPE_PT_ADD80
7207 | OPTS_TYPE_PT_ADDBITS14;
7208 kern_type = KERN_TYPE_MD5_SLTPW;
7209 dgst_size = DGST_SIZE_4_4;
7210 parse_func = osc_parse_hash;
7211 sort_by_digest = sort_by_digest_4_4;
7212 opti_type = OPTI_TYPE_ZERO_BYTE
7213 | OPTI_TYPE_PRECOMPUTE_INIT
7214 | OPTI_TYPE_PRECOMPUTE_MERKLE
7215 | OPTI_TYPE_EARLY_SKIP
7216 | OPTI_TYPE_NOT_ITERATED
7217 | OPTI_TYPE_PREPENDED_SALT
7218 | OPTI_TYPE_RAW_HASH;
7219 dgst_pos0 = 0;
7220 dgst_pos1 = 3;
7221 dgst_pos2 = 2;
7222 dgst_pos3 = 1;
7223 break;
7224
7225 case 22: hash_type = HASH_TYPE_MD5;
7226 salt_type = SALT_TYPE_EMBEDDED;
7227 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7228 opts_type = OPTS_TYPE_PT_GENERATE_LE
7229 | OPTS_TYPE_PT_ADD80
7230 | OPTS_TYPE_PT_ADDBITS14;
7231 kern_type = KERN_TYPE_MD5_SLTPW;
7232 dgst_size = DGST_SIZE_4_4;
7233 parse_func = netscreen_parse_hash;
7234 sort_by_digest = sort_by_digest_4_4;
7235 opti_type = OPTI_TYPE_ZERO_BYTE
7236 | OPTI_TYPE_PRECOMPUTE_INIT
7237 | OPTI_TYPE_PRECOMPUTE_MERKLE
7238 | OPTI_TYPE_EARLY_SKIP
7239 | OPTI_TYPE_NOT_ITERATED
7240 | OPTI_TYPE_PREPENDED_SALT
7241 | OPTI_TYPE_RAW_HASH;
7242 dgst_pos0 = 0;
7243 dgst_pos1 = 3;
7244 dgst_pos2 = 2;
7245 dgst_pos3 = 1;
7246 break;
7247
7248 case 23: hash_type = HASH_TYPE_MD5;
7249 salt_type = SALT_TYPE_EMBEDDED;
7250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7251 opts_type = OPTS_TYPE_PT_GENERATE_LE
7252 | OPTS_TYPE_PT_ADD80
7253 | OPTS_TYPE_PT_ADDBITS14;
7254 kern_type = KERN_TYPE_MD5_SLTPW;
7255 dgst_size = DGST_SIZE_4_4;
7256 parse_func = skype_parse_hash;
7257 sort_by_digest = sort_by_digest_4_4;
7258 opti_type = OPTI_TYPE_ZERO_BYTE
7259 | OPTI_TYPE_PRECOMPUTE_INIT
7260 | OPTI_TYPE_PRECOMPUTE_MERKLE
7261 | OPTI_TYPE_EARLY_SKIP
7262 | OPTI_TYPE_NOT_ITERATED
7263 | OPTI_TYPE_PREPENDED_SALT
7264 | OPTI_TYPE_RAW_HASH;
7265 dgst_pos0 = 0;
7266 dgst_pos1 = 3;
7267 dgst_pos2 = 2;
7268 dgst_pos3 = 1;
7269 break;
7270
7271 case 30: hash_type = HASH_TYPE_MD5;
7272 salt_type = SALT_TYPE_INTERN;
7273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7274 opts_type = OPTS_TYPE_PT_GENERATE_LE
7275 | OPTS_TYPE_PT_UNICODE
7276 | OPTS_TYPE_ST_ADD80
7277 | OPTS_TYPE_ST_ADDBITS14;
7278 kern_type = KERN_TYPE_MD5_PWUSLT;
7279 dgst_size = DGST_SIZE_4_4;
7280 parse_func = md5s_parse_hash;
7281 sort_by_digest = sort_by_digest_4_4;
7282 opti_type = OPTI_TYPE_ZERO_BYTE
7283 | OPTI_TYPE_PRECOMPUTE_INIT
7284 | OPTI_TYPE_PRECOMPUTE_MERKLE
7285 | OPTI_TYPE_MEET_IN_MIDDLE
7286 | OPTI_TYPE_EARLY_SKIP
7287 | OPTI_TYPE_NOT_ITERATED
7288 | OPTI_TYPE_APPENDED_SALT
7289 | OPTI_TYPE_RAW_HASH;
7290 dgst_pos0 = 0;
7291 dgst_pos1 = 3;
7292 dgst_pos2 = 2;
7293 dgst_pos3 = 1;
7294 break;
7295
7296 case 40: hash_type = HASH_TYPE_MD5;
7297 salt_type = SALT_TYPE_INTERN;
7298 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7299 opts_type = OPTS_TYPE_PT_GENERATE_LE
7300 | OPTS_TYPE_PT_ADD80
7301 | OPTS_TYPE_PT_ADDBITS14
7302 | OPTS_TYPE_PT_UNICODE;
7303 kern_type = KERN_TYPE_MD5_SLTPWU;
7304 dgst_size = DGST_SIZE_4_4;
7305 parse_func = md5s_parse_hash;
7306 sort_by_digest = sort_by_digest_4_4;
7307 opti_type = OPTI_TYPE_ZERO_BYTE
7308 | OPTI_TYPE_PRECOMPUTE_INIT
7309 | OPTI_TYPE_PRECOMPUTE_MERKLE
7310 | OPTI_TYPE_EARLY_SKIP
7311 | OPTI_TYPE_NOT_ITERATED
7312 | OPTI_TYPE_PREPENDED_SALT
7313 | OPTI_TYPE_RAW_HASH;
7314 dgst_pos0 = 0;
7315 dgst_pos1 = 3;
7316 dgst_pos2 = 2;
7317 dgst_pos3 = 1;
7318 break;
7319
7320 case 50: hash_type = HASH_TYPE_MD5;
7321 salt_type = SALT_TYPE_INTERN;
7322 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7323 opts_type = OPTS_TYPE_PT_GENERATE_LE
7324 | OPTS_TYPE_ST_ADD80
7325 | OPTS_TYPE_ST_ADDBITS14;
7326 kern_type = KERN_TYPE_HMACMD5_PW;
7327 dgst_size = DGST_SIZE_4_4;
7328 parse_func = hmacmd5_parse_hash;
7329 sort_by_digest = sort_by_digest_4_4;
7330 opti_type = OPTI_TYPE_ZERO_BYTE
7331 | OPTI_TYPE_NOT_ITERATED;
7332 dgst_pos0 = 0;
7333 dgst_pos1 = 3;
7334 dgst_pos2 = 2;
7335 dgst_pos3 = 1;
7336 break;
7337
7338 case 60: hash_type = HASH_TYPE_MD5;
7339 salt_type = SALT_TYPE_INTERN;
7340 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7341 opts_type = OPTS_TYPE_PT_GENERATE_LE
7342 | OPTS_TYPE_PT_ADD80
7343 | OPTS_TYPE_PT_ADDBITS14;
7344 kern_type = KERN_TYPE_HMACMD5_SLT;
7345 dgst_size = DGST_SIZE_4_4;
7346 parse_func = hmacmd5_parse_hash;
7347 sort_by_digest = sort_by_digest_4_4;
7348 opti_type = OPTI_TYPE_ZERO_BYTE
7349 | OPTI_TYPE_NOT_ITERATED;
7350 dgst_pos0 = 0;
7351 dgst_pos1 = 3;
7352 dgst_pos2 = 2;
7353 dgst_pos3 = 1;
7354 break;
7355
7356 case 100: hash_type = HASH_TYPE_SHA1;
7357 salt_type = SALT_TYPE_NONE;
7358 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7359 opts_type = OPTS_TYPE_PT_GENERATE_BE
7360 | OPTS_TYPE_PT_ADD80
7361 | OPTS_TYPE_PT_ADDBITS15;
7362 kern_type = KERN_TYPE_SHA1;
7363 dgst_size = DGST_SIZE_4_5;
7364 parse_func = sha1_parse_hash;
7365 sort_by_digest = sort_by_digest_4_5;
7366 opti_type = OPTI_TYPE_ZERO_BYTE
7367 | OPTI_TYPE_PRECOMPUTE_INIT
7368 | OPTI_TYPE_PRECOMPUTE_MERKLE
7369 | OPTI_TYPE_EARLY_SKIP
7370 | OPTI_TYPE_NOT_ITERATED
7371 | OPTI_TYPE_NOT_SALTED
7372 | OPTI_TYPE_RAW_HASH;
7373 dgst_pos0 = 3;
7374 dgst_pos1 = 4;
7375 dgst_pos2 = 2;
7376 dgst_pos3 = 1;
7377 break;
7378
7379 case 101: hash_type = HASH_TYPE_SHA1;
7380 salt_type = SALT_TYPE_NONE;
7381 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7382 opts_type = OPTS_TYPE_PT_GENERATE_BE
7383 | OPTS_TYPE_PT_ADD80
7384 | OPTS_TYPE_PT_ADDBITS15;
7385 kern_type = KERN_TYPE_SHA1;
7386 dgst_size = DGST_SIZE_4_5;
7387 parse_func = sha1b64_parse_hash;
7388 sort_by_digest = sort_by_digest_4_5;
7389 opti_type = OPTI_TYPE_ZERO_BYTE
7390 | OPTI_TYPE_PRECOMPUTE_INIT
7391 | OPTI_TYPE_PRECOMPUTE_MERKLE
7392 | OPTI_TYPE_EARLY_SKIP
7393 | OPTI_TYPE_NOT_ITERATED
7394 | OPTI_TYPE_NOT_SALTED
7395 | OPTI_TYPE_RAW_HASH;
7396 dgst_pos0 = 3;
7397 dgst_pos1 = 4;
7398 dgst_pos2 = 2;
7399 dgst_pos3 = 1;
7400 break;
7401
7402 case 110: hash_type = HASH_TYPE_SHA1;
7403 salt_type = SALT_TYPE_INTERN;
7404 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7405 opts_type = OPTS_TYPE_PT_GENERATE_BE
7406 | OPTS_TYPE_ST_ADD80
7407 | OPTS_TYPE_ST_ADDBITS15;
7408 kern_type = KERN_TYPE_SHA1_PWSLT;
7409 dgst_size = DGST_SIZE_4_5;
7410 parse_func = sha1s_parse_hash;
7411 sort_by_digest = sort_by_digest_4_5;
7412 opti_type = OPTI_TYPE_ZERO_BYTE
7413 | OPTI_TYPE_PRECOMPUTE_INIT
7414 | OPTI_TYPE_PRECOMPUTE_MERKLE
7415 | OPTI_TYPE_EARLY_SKIP
7416 | OPTI_TYPE_NOT_ITERATED
7417 | OPTI_TYPE_APPENDED_SALT
7418 | OPTI_TYPE_RAW_HASH;
7419 dgst_pos0 = 3;
7420 dgst_pos1 = 4;
7421 dgst_pos2 = 2;
7422 dgst_pos3 = 1;
7423 break;
7424
7425 case 111: hash_type = HASH_TYPE_SHA1;
7426 salt_type = SALT_TYPE_EMBEDDED;
7427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7428 opts_type = OPTS_TYPE_PT_GENERATE_BE
7429 | OPTS_TYPE_ST_ADD80
7430 | OPTS_TYPE_ST_ADDBITS15;
7431 kern_type = KERN_TYPE_SHA1_PWSLT;
7432 dgst_size = DGST_SIZE_4_5;
7433 parse_func = sha1b64s_parse_hash;
7434 sort_by_digest = sort_by_digest_4_5;
7435 opti_type = OPTI_TYPE_ZERO_BYTE
7436 | OPTI_TYPE_PRECOMPUTE_INIT
7437 | OPTI_TYPE_PRECOMPUTE_MERKLE
7438 | OPTI_TYPE_EARLY_SKIP
7439 | OPTI_TYPE_NOT_ITERATED
7440 | OPTI_TYPE_APPENDED_SALT
7441 | OPTI_TYPE_RAW_HASH;
7442 dgst_pos0 = 3;
7443 dgst_pos1 = 4;
7444 dgst_pos2 = 2;
7445 dgst_pos3 = 1;
7446 break;
7447
7448 case 112: hash_type = HASH_TYPE_SHA1;
7449 salt_type = SALT_TYPE_INTERN;
7450 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7451 opts_type = OPTS_TYPE_PT_GENERATE_BE
7452 | OPTS_TYPE_ST_ADD80
7453 | OPTS_TYPE_ST_ADDBITS15
7454 | OPTS_TYPE_ST_HEX;
7455 kern_type = KERN_TYPE_SHA1_PWSLT;
7456 dgst_size = DGST_SIZE_4_5;
7457 parse_func = oracles_parse_hash;
7458 sort_by_digest = sort_by_digest_4_5;
7459 opti_type = OPTI_TYPE_ZERO_BYTE
7460 | OPTI_TYPE_PRECOMPUTE_INIT
7461 | OPTI_TYPE_PRECOMPUTE_MERKLE
7462 | OPTI_TYPE_EARLY_SKIP
7463 | OPTI_TYPE_NOT_ITERATED
7464 | OPTI_TYPE_APPENDED_SALT
7465 | OPTI_TYPE_RAW_HASH;
7466 dgst_pos0 = 3;
7467 dgst_pos1 = 4;
7468 dgst_pos2 = 2;
7469 dgst_pos3 = 1;
7470 break;
7471
7472 case 120: hash_type = HASH_TYPE_SHA1;
7473 salt_type = SALT_TYPE_INTERN;
7474 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7475 opts_type = OPTS_TYPE_PT_GENERATE_BE
7476 | OPTS_TYPE_PT_ADD80
7477 | OPTS_TYPE_PT_ADDBITS15;
7478 kern_type = KERN_TYPE_SHA1_SLTPW;
7479 dgst_size = DGST_SIZE_4_5;
7480 parse_func = sha1s_parse_hash;
7481 sort_by_digest = sort_by_digest_4_5;
7482 opti_type = OPTI_TYPE_ZERO_BYTE
7483 | OPTI_TYPE_PRECOMPUTE_INIT
7484 | OPTI_TYPE_PRECOMPUTE_MERKLE
7485 | OPTI_TYPE_EARLY_SKIP
7486 | OPTI_TYPE_NOT_ITERATED
7487 | OPTI_TYPE_PREPENDED_SALT
7488 | OPTI_TYPE_RAW_HASH;
7489 dgst_pos0 = 3;
7490 dgst_pos1 = 4;
7491 dgst_pos2 = 2;
7492 dgst_pos3 = 1;
7493 break;
7494
7495 case 121: hash_type = HASH_TYPE_SHA1;
7496 salt_type = SALT_TYPE_INTERN;
7497 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7498 opts_type = OPTS_TYPE_PT_GENERATE_BE
7499 | OPTS_TYPE_PT_ADD80
7500 | OPTS_TYPE_PT_ADDBITS15
7501 | OPTS_TYPE_ST_LOWER;
7502 kern_type = KERN_TYPE_SHA1_SLTPW;
7503 dgst_size = DGST_SIZE_4_5;
7504 parse_func = smf_parse_hash;
7505 sort_by_digest = sort_by_digest_4_5;
7506 opti_type = OPTI_TYPE_ZERO_BYTE
7507 | OPTI_TYPE_PRECOMPUTE_INIT
7508 | OPTI_TYPE_PRECOMPUTE_MERKLE
7509 | OPTI_TYPE_EARLY_SKIP
7510 | OPTI_TYPE_NOT_ITERATED
7511 | OPTI_TYPE_PREPENDED_SALT
7512 | OPTI_TYPE_RAW_HASH;
7513 dgst_pos0 = 3;
7514 dgst_pos1 = 4;
7515 dgst_pos2 = 2;
7516 dgst_pos3 = 1;
7517 break;
7518
7519 case 122: hash_type = HASH_TYPE_SHA1;
7520 salt_type = SALT_TYPE_EMBEDDED;
7521 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7522 opts_type = OPTS_TYPE_PT_GENERATE_BE
7523 | OPTS_TYPE_PT_ADD80
7524 | OPTS_TYPE_PT_ADDBITS15
7525 | OPTS_TYPE_ST_HEX;
7526 kern_type = KERN_TYPE_SHA1_SLTPW;
7527 dgst_size = DGST_SIZE_4_5;
7528 parse_func = osx1_parse_hash;
7529 sort_by_digest = sort_by_digest_4_5;
7530 opti_type = OPTI_TYPE_ZERO_BYTE
7531 | OPTI_TYPE_PRECOMPUTE_INIT
7532 | OPTI_TYPE_PRECOMPUTE_MERKLE
7533 | OPTI_TYPE_EARLY_SKIP
7534 | OPTI_TYPE_NOT_ITERATED
7535 | OPTI_TYPE_PREPENDED_SALT
7536 | OPTI_TYPE_RAW_HASH;
7537 dgst_pos0 = 3;
7538 dgst_pos1 = 4;
7539 dgst_pos2 = 2;
7540 dgst_pos3 = 1;
7541 break;
7542
7543 case 124: hash_type = HASH_TYPE_SHA1;
7544 salt_type = SALT_TYPE_EMBEDDED;
7545 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7546 opts_type = OPTS_TYPE_PT_GENERATE_BE
7547 | OPTS_TYPE_PT_ADD80
7548 | OPTS_TYPE_PT_ADDBITS15;
7549 kern_type = KERN_TYPE_SHA1_SLTPW;
7550 dgst_size = DGST_SIZE_4_5;
7551 parse_func = djangosha1_parse_hash;
7552 sort_by_digest = sort_by_digest_4_5;
7553 opti_type = OPTI_TYPE_ZERO_BYTE
7554 | OPTI_TYPE_PRECOMPUTE_INIT
7555 | OPTI_TYPE_PRECOMPUTE_MERKLE
7556 | OPTI_TYPE_EARLY_SKIP
7557 | OPTI_TYPE_NOT_ITERATED
7558 | OPTI_TYPE_PREPENDED_SALT
7559 | OPTI_TYPE_RAW_HASH;
7560 dgst_pos0 = 3;
7561 dgst_pos1 = 4;
7562 dgst_pos2 = 2;
7563 dgst_pos3 = 1;
7564 break;
7565
7566 case 125: hash_type = HASH_TYPE_SHA1;
7567 salt_type = SALT_TYPE_EMBEDDED;
7568 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7569 opts_type = OPTS_TYPE_PT_GENERATE_BE
7570 | OPTS_TYPE_PT_ADD80
7571 | OPTS_TYPE_PT_ADDBITS15
7572 | OPTS_TYPE_ST_HEX;
7573 kern_type = KERN_TYPE_SHA1_SLTPW;
7574 dgst_size = DGST_SIZE_4_5;
7575 parse_func = arubaos_parse_hash;
7576 sort_by_digest = sort_by_digest_4_5;
7577 opti_type = OPTI_TYPE_ZERO_BYTE
7578 | OPTI_TYPE_PRECOMPUTE_INIT
7579 | OPTI_TYPE_PRECOMPUTE_MERKLE
7580 | OPTI_TYPE_EARLY_SKIP
7581 | OPTI_TYPE_NOT_ITERATED
7582 | OPTI_TYPE_PREPENDED_SALT
7583 | OPTI_TYPE_RAW_HASH;
7584 dgst_pos0 = 3;
7585 dgst_pos1 = 4;
7586 dgst_pos2 = 2;
7587 dgst_pos3 = 1;
7588 break;
7589
7590 case 130: hash_type = HASH_TYPE_SHA1;
7591 salt_type = SALT_TYPE_INTERN;
7592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7593 opts_type = OPTS_TYPE_PT_GENERATE_BE
7594 | OPTS_TYPE_PT_UNICODE
7595 | OPTS_TYPE_ST_ADD80
7596 | OPTS_TYPE_ST_ADDBITS15;
7597 kern_type = KERN_TYPE_SHA1_PWUSLT;
7598 dgst_size = DGST_SIZE_4_5;
7599 parse_func = sha1s_parse_hash;
7600 sort_by_digest = sort_by_digest_4_5;
7601 opti_type = OPTI_TYPE_ZERO_BYTE
7602 | OPTI_TYPE_PRECOMPUTE_INIT
7603 | OPTI_TYPE_PRECOMPUTE_MERKLE
7604 | OPTI_TYPE_EARLY_SKIP
7605 | OPTI_TYPE_NOT_ITERATED
7606 | OPTI_TYPE_APPENDED_SALT
7607 | OPTI_TYPE_RAW_HASH;
7608 dgst_pos0 = 3;
7609 dgst_pos1 = 4;
7610 dgst_pos2 = 2;
7611 dgst_pos3 = 1;
7612 break;
7613
7614 case 131: hash_type = HASH_TYPE_SHA1;
7615 salt_type = SALT_TYPE_EMBEDDED;
7616 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7617 opts_type = OPTS_TYPE_PT_GENERATE_BE
7618 | OPTS_TYPE_PT_UNICODE
7619 | OPTS_TYPE_PT_UPPER
7620 | OPTS_TYPE_ST_ADD80
7621 | OPTS_TYPE_ST_ADDBITS15
7622 | OPTS_TYPE_ST_HEX;
7623 kern_type = KERN_TYPE_SHA1_PWUSLT;
7624 dgst_size = DGST_SIZE_4_5;
7625 parse_func = mssql2000_parse_hash;
7626 sort_by_digest = sort_by_digest_4_5;
7627 opti_type = OPTI_TYPE_ZERO_BYTE
7628 | OPTI_TYPE_PRECOMPUTE_INIT
7629 | OPTI_TYPE_PRECOMPUTE_MERKLE
7630 | OPTI_TYPE_EARLY_SKIP
7631 | OPTI_TYPE_NOT_ITERATED
7632 | OPTI_TYPE_APPENDED_SALT
7633 | OPTI_TYPE_RAW_HASH;
7634 dgst_pos0 = 3;
7635 dgst_pos1 = 4;
7636 dgst_pos2 = 2;
7637 dgst_pos3 = 1;
7638 break;
7639
7640 case 132: hash_type = HASH_TYPE_SHA1;
7641 salt_type = SALT_TYPE_EMBEDDED;
7642 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7643 opts_type = OPTS_TYPE_PT_GENERATE_BE
7644 | OPTS_TYPE_PT_UNICODE
7645 | OPTS_TYPE_ST_ADD80
7646 | OPTS_TYPE_ST_ADDBITS15
7647 | OPTS_TYPE_ST_HEX;
7648 kern_type = KERN_TYPE_SHA1_PWUSLT;
7649 dgst_size = DGST_SIZE_4_5;
7650 parse_func = mssql2005_parse_hash;
7651 sort_by_digest = sort_by_digest_4_5;
7652 opti_type = OPTI_TYPE_ZERO_BYTE
7653 | OPTI_TYPE_PRECOMPUTE_INIT
7654 | OPTI_TYPE_PRECOMPUTE_MERKLE
7655 | OPTI_TYPE_EARLY_SKIP
7656 | OPTI_TYPE_NOT_ITERATED
7657 | OPTI_TYPE_APPENDED_SALT
7658 | OPTI_TYPE_RAW_HASH;
7659 dgst_pos0 = 3;
7660 dgst_pos1 = 4;
7661 dgst_pos2 = 2;
7662 dgst_pos3 = 1;
7663 break;
7664
7665 case 133: hash_type = HASH_TYPE_SHA1;
7666 salt_type = SALT_TYPE_EMBEDDED;
7667 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7668 opts_type = OPTS_TYPE_PT_GENERATE_BE
7669 | OPTS_TYPE_PT_UNICODE
7670 | OPTS_TYPE_ST_ADD80
7671 | OPTS_TYPE_ST_ADDBITS15;
7672 kern_type = KERN_TYPE_SHA1_PWUSLT;
7673 dgst_size = DGST_SIZE_4_5;
7674 parse_func = peoplesoft_parse_hash;
7675 sort_by_digest = sort_by_digest_4_5;
7676 opti_type = OPTI_TYPE_ZERO_BYTE
7677 | OPTI_TYPE_PRECOMPUTE_INIT
7678 | OPTI_TYPE_PRECOMPUTE_MERKLE
7679 | OPTI_TYPE_EARLY_SKIP
7680 | OPTI_TYPE_NOT_ITERATED
7681 | OPTI_TYPE_APPENDED_SALT
7682 | OPTI_TYPE_RAW_HASH;
7683 dgst_pos0 = 3;
7684 dgst_pos1 = 4;
7685 dgst_pos2 = 2;
7686 dgst_pos3 = 1;
7687 break;
7688
7689 case 140: hash_type = HASH_TYPE_SHA1;
7690 salt_type = SALT_TYPE_INTERN;
7691 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7692 opts_type = OPTS_TYPE_PT_GENERATE_BE
7693 | OPTS_TYPE_PT_ADD80
7694 | OPTS_TYPE_PT_ADDBITS15
7695 | OPTS_TYPE_PT_UNICODE;
7696 kern_type = KERN_TYPE_SHA1_SLTPWU;
7697 dgst_size = DGST_SIZE_4_5;
7698 parse_func = sha1s_parse_hash;
7699 sort_by_digest = sort_by_digest_4_5;
7700 opti_type = OPTI_TYPE_ZERO_BYTE
7701 | OPTI_TYPE_PRECOMPUTE_INIT
7702 | OPTI_TYPE_PRECOMPUTE_MERKLE
7703 | OPTI_TYPE_EARLY_SKIP
7704 | OPTI_TYPE_NOT_ITERATED
7705 | OPTI_TYPE_PREPENDED_SALT
7706 | OPTI_TYPE_RAW_HASH;
7707 dgst_pos0 = 3;
7708 dgst_pos1 = 4;
7709 dgst_pos2 = 2;
7710 dgst_pos3 = 1;
7711 break;
7712
7713 case 141: hash_type = HASH_TYPE_SHA1;
7714 salt_type = SALT_TYPE_EMBEDDED;
7715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7716 opts_type = OPTS_TYPE_PT_GENERATE_BE
7717 | OPTS_TYPE_PT_ADD80
7718 | OPTS_TYPE_PT_ADDBITS15
7719 | OPTS_TYPE_PT_UNICODE
7720 | OPTS_TYPE_ST_BASE64;
7721 kern_type = KERN_TYPE_SHA1_SLTPWU;
7722 dgst_size = DGST_SIZE_4_5;
7723 parse_func = episerver_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_PREPENDED_SALT
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 150: hash_type = HASH_TYPE_SHA1;
7739 salt_type = SALT_TYPE_INTERN;
7740 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7741 opts_type = OPTS_TYPE_PT_GENERATE_BE
7742 | OPTS_TYPE_ST_ADD80
7743 | OPTS_TYPE_ST_ADDBITS15;
7744 kern_type = KERN_TYPE_HMACSHA1_PW;
7745 dgst_size = DGST_SIZE_4_5;
7746 parse_func = hmacsha1_parse_hash;
7747 sort_by_digest = sort_by_digest_4_5;
7748 opti_type = OPTI_TYPE_ZERO_BYTE
7749 | OPTI_TYPE_NOT_ITERATED;
7750 dgst_pos0 = 3;
7751 dgst_pos1 = 4;
7752 dgst_pos2 = 2;
7753 dgst_pos3 = 1;
7754 break;
7755
7756 case 160: hash_type = HASH_TYPE_SHA1;
7757 salt_type = SALT_TYPE_INTERN;
7758 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7759 opts_type = OPTS_TYPE_PT_GENERATE_BE
7760 | OPTS_TYPE_PT_ADD80
7761 | OPTS_TYPE_PT_ADDBITS15;
7762 kern_type = KERN_TYPE_HMACSHA1_SLT;
7763 dgst_size = DGST_SIZE_4_5;
7764 parse_func = hmacsha1_parse_hash;
7765 sort_by_digest = sort_by_digest_4_5;
7766 opti_type = OPTI_TYPE_ZERO_BYTE
7767 | OPTI_TYPE_NOT_ITERATED;
7768 dgst_pos0 = 3;
7769 dgst_pos1 = 4;
7770 dgst_pos2 = 2;
7771 dgst_pos3 = 1;
7772 break;
7773
7774 case 190: hash_type = HASH_TYPE_SHA1;
7775 salt_type = SALT_TYPE_NONE;
7776 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7777 opts_type = OPTS_TYPE_PT_GENERATE_BE
7778 | OPTS_TYPE_PT_ADD80
7779 | OPTS_TYPE_PT_ADDBITS15;
7780 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7781 dgst_size = DGST_SIZE_4_5;
7782 parse_func = sha1linkedin_parse_hash;
7783 sort_by_digest = sort_by_digest_4_5;
7784 opti_type = OPTI_TYPE_ZERO_BYTE
7785 | OPTI_TYPE_PRECOMPUTE_INIT
7786 | OPTI_TYPE_EARLY_SKIP
7787 | OPTI_TYPE_NOT_ITERATED
7788 | OPTI_TYPE_NOT_SALTED;
7789 dgst_pos0 = 0;
7790 dgst_pos1 = 4;
7791 dgst_pos2 = 3;
7792 dgst_pos3 = 2;
7793 break;
7794
7795 case 200: hash_type = HASH_TYPE_MYSQL;
7796 salt_type = SALT_TYPE_NONE;
7797 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7798 opts_type = 0;
7799 kern_type = KERN_TYPE_MYSQL;
7800 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7801 parse_func = mysql323_parse_hash;
7802 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7803 opti_type = OPTI_TYPE_ZERO_BYTE;
7804 dgst_pos0 = 0;
7805 dgst_pos1 = 1;
7806 dgst_pos2 = 2;
7807 dgst_pos3 = 3;
7808 break;
7809
7810 case 300: hash_type = HASH_TYPE_SHA1;
7811 salt_type = SALT_TYPE_NONE;
7812 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7813 opts_type = OPTS_TYPE_PT_GENERATE_BE
7814 | OPTS_TYPE_PT_ADD80
7815 | OPTS_TYPE_PT_ADDBITS15;
7816 kern_type = KERN_TYPE_MYSQL41;
7817 dgst_size = DGST_SIZE_4_5;
7818 parse_func = sha1_parse_hash;
7819 sort_by_digest = sort_by_digest_4_5;
7820 opti_type = OPTI_TYPE_ZERO_BYTE
7821 | OPTI_TYPE_PRECOMPUTE_INIT
7822 | OPTI_TYPE_PRECOMPUTE_MERKLE
7823 | OPTI_TYPE_EARLY_SKIP
7824 | OPTI_TYPE_NOT_ITERATED
7825 | OPTI_TYPE_NOT_SALTED;
7826 dgst_pos0 = 3;
7827 dgst_pos1 = 4;
7828 dgst_pos2 = 2;
7829 dgst_pos3 = 1;
7830 break;
7831
7832 case 400: hash_type = HASH_TYPE_MD5;
7833 salt_type = SALT_TYPE_EMBEDDED;
7834 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7835 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7836 kern_type = KERN_TYPE_PHPASS;
7837 dgst_size = DGST_SIZE_4_4;
7838 parse_func = phpass_parse_hash;
7839 sort_by_digest = sort_by_digest_4_4;
7840 opti_type = OPTI_TYPE_ZERO_BYTE
7841 | OPTI_TYPE_SLOW_HASH_SIMD;
7842 dgst_pos0 = 0;
7843 dgst_pos1 = 1;
7844 dgst_pos2 = 2;
7845 dgst_pos3 = 3;
7846 break;
7847
7848 case 500: hash_type = HASH_TYPE_MD5;
7849 salt_type = SALT_TYPE_EMBEDDED;
7850 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7851 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7852 kern_type = KERN_TYPE_MD5CRYPT;
7853 dgst_size = DGST_SIZE_4_4;
7854 parse_func = md5crypt_parse_hash;
7855 sort_by_digest = sort_by_digest_4_4;
7856 opti_type = OPTI_TYPE_ZERO_BYTE;
7857 dgst_pos0 = 0;
7858 dgst_pos1 = 1;
7859 dgst_pos2 = 2;
7860 dgst_pos3 = 3;
7861 break;
7862
7863 case 501: hash_type = HASH_TYPE_MD5;
7864 salt_type = SALT_TYPE_EMBEDDED;
7865 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7866 opts_type = OPTS_TYPE_PT_GENERATE_LE
7867 | OPTS_TYPE_HASH_COPY;
7868 kern_type = KERN_TYPE_MD5CRYPT;
7869 dgst_size = DGST_SIZE_4_4;
7870 parse_func = juniper_parse_hash;
7871 sort_by_digest = sort_by_digest_4_4;
7872 opti_type = OPTI_TYPE_ZERO_BYTE;
7873 dgst_pos0 = 0;
7874 dgst_pos1 = 1;
7875 dgst_pos2 = 2;
7876 dgst_pos3 = 3;
7877 break;
7878
7879 case 900: hash_type = HASH_TYPE_MD4;
7880 salt_type = SALT_TYPE_NONE;
7881 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7882 opts_type = OPTS_TYPE_PT_GENERATE_LE
7883 | OPTS_TYPE_PT_ADD80
7884 | OPTS_TYPE_PT_ADDBITS14;
7885 kern_type = KERN_TYPE_MD4;
7886 dgst_size = DGST_SIZE_4_4;
7887 parse_func = md4_parse_hash;
7888 sort_by_digest = sort_by_digest_4_4;
7889 opti_type = OPTI_TYPE_ZERO_BYTE
7890 | OPTI_TYPE_PRECOMPUTE_INIT
7891 | OPTI_TYPE_PRECOMPUTE_MERKLE
7892 | OPTI_TYPE_MEET_IN_MIDDLE
7893 | OPTI_TYPE_EARLY_SKIP
7894 | OPTI_TYPE_NOT_ITERATED
7895 | OPTI_TYPE_NOT_SALTED
7896 | OPTI_TYPE_RAW_HASH;
7897 dgst_pos0 = 0;
7898 dgst_pos1 = 3;
7899 dgst_pos2 = 2;
7900 dgst_pos3 = 1;
7901 break;
7902
7903 case 1000: hash_type = HASH_TYPE_MD4;
7904 salt_type = SALT_TYPE_NONE;
7905 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7906 opts_type = OPTS_TYPE_PT_GENERATE_LE
7907 | OPTS_TYPE_PT_ADD80
7908 | OPTS_TYPE_PT_ADDBITS14
7909 | OPTS_TYPE_PT_UNICODE;
7910 kern_type = KERN_TYPE_MD4_PWU;
7911 dgst_size = DGST_SIZE_4_4;
7912 parse_func = md4_parse_hash;
7913 sort_by_digest = sort_by_digest_4_4;
7914 opti_type = OPTI_TYPE_ZERO_BYTE
7915 | OPTI_TYPE_PRECOMPUTE_INIT
7916 | OPTI_TYPE_PRECOMPUTE_MERKLE
7917 | OPTI_TYPE_MEET_IN_MIDDLE
7918 | OPTI_TYPE_EARLY_SKIP
7919 | OPTI_TYPE_NOT_ITERATED
7920 | OPTI_TYPE_NOT_SALTED
7921 | OPTI_TYPE_RAW_HASH;
7922 dgst_pos0 = 0;
7923 dgst_pos1 = 3;
7924 dgst_pos2 = 2;
7925 dgst_pos3 = 1;
7926 break;
7927
7928 case 1100: hash_type = HASH_TYPE_MD4;
7929 salt_type = SALT_TYPE_INTERN;
7930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7931 opts_type = OPTS_TYPE_PT_GENERATE_LE
7932 | OPTS_TYPE_PT_ADD80
7933 | OPTS_TYPE_PT_ADDBITS14
7934 | OPTS_TYPE_PT_UNICODE
7935 | OPTS_TYPE_ST_ADD80
7936 | OPTS_TYPE_ST_UNICODE
7937 | OPTS_TYPE_ST_LOWER;
7938 kern_type = KERN_TYPE_MD44_PWUSLT;
7939 dgst_size = DGST_SIZE_4_4;
7940 parse_func = dcc_parse_hash;
7941 sort_by_digest = sort_by_digest_4_4;
7942 opti_type = OPTI_TYPE_ZERO_BYTE
7943 | OPTI_TYPE_PRECOMPUTE_INIT
7944 | OPTI_TYPE_PRECOMPUTE_MERKLE
7945 | OPTI_TYPE_EARLY_SKIP
7946 | OPTI_TYPE_NOT_ITERATED;
7947 dgst_pos0 = 0;
7948 dgst_pos1 = 3;
7949 dgst_pos2 = 2;
7950 dgst_pos3 = 1;
7951 break;
7952
7953 case 1400: hash_type = HASH_TYPE_SHA256;
7954 salt_type = SALT_TYPE_NONE;
7955 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7956 opts_type = OPTS_TYPE_PT_GENERATE_BE
7957 | OPTS_TYPE_PT_ADD80
7958 | OPTS_TYPE_PT_ADDBITS15;
7959 kern_type = KERN_TYPE_SHA256;
7960 dgst_size = DGST_SIZE_4_8;
7961 parse_func = sha256_parse_hash;
7962 sort_by_digest = sort_by_digest_4_8;
7963 opti_type = OPTI_TYPE_ZERO_BYTE
7964 | OPTI_TYPE_PRECOMPUTE_INIT
7965 | OPTI_TYPE_PRECOMPUTE_MERKLE
7966 | OPTI_TYPE_EARLY_SKIP
7967 | OPTI_TYPE_NOT_ITERATED
7968 | OPTI_TYPE_NOT_SALTED
7969 | OPTI_TYPE_RAW_HASH;
7970 dgst_pos0 = 3;
7971 dgst_pos1 = 7;
7972 dgst_pos2 = 2;
7973 dgst_pos3 = 6;
7974 break;
7975
7976 case 1410: hash_type = HASH_TYPE_SHA256;
7977 salt_type = SALT_TYPE_INTERN;
7978 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7979 opts_type = OPTS_TYPE_PT_GENERATE_BE
7980 | OPTS_TYPE_ST_ADD80
7981 | OPTS_TYPE_ST_ADDBITS15;
7982 kern_type = KERN_TYPE_SHA256_PWSLT;
7983 dgst_size = DGST_SIZE_4_8;
7984 parse_func = sha256s_parse_hash;
7985 sort_by_digest = sort_by_digest_4_8;
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 = 7;
7995 dgst_pos2 = 2;
7996 dgst_pos3 = 6;
7997 break;
7998
7999 case 1420: hash_type = HASH_TYPE_SHA256;
8000 salt_type = SALT_TYPE_INTERN;
8001 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8002 opts_type = OPTS_TYPE_PT_GENERATE_BE
8003 | OPTS_TYPE_PT_ADD80
8004 | OPTS_TYPE_PT_ADDBITS15;
8005 kern_type = KERN_TYPE_SHA256_SLTPW;
8006 dgst_size = DGST_SIZE_4_8;
8007 parse_func = sha256s_parse_hash;
8008 sort_by_digest = sort_by_digest_4_8;
8009 opti_type = OPTI_TYPE_ZERO_BYTE
8010 | OPTI_TYPE_PRECOMPUTE_INIT
8011 | OPTI_TYPE_PRECOMPUTE_MERKLE
8012 | OPTI_TYPE_EARLY_SKIP
8013 | OPTI_TYPE_NOT_ITERATED
8014 | OPTI_TYPE_PREPENDED_SALT
8015 | OPTI_TYPE_RAW_HASH;
8016 dgst_pos0 = 3;
8017 dgst_pos1 = 7;
8018 dgst_pos2 = 2;
8019 dgst_pos3 = 6;
8020 break;
8021
8022 case 1421: hash_type = HASH_TYPE_SHA256;
8023 salt_type = SALT_TYPE_EMBEDDED;
8024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8025 opts_type = OPTS_TYPE_PT_GENERATE_BE
8026 | OPTS_TYPE_PT_ADD80
8027 | OPTS_TYPE_PT_ADDBITS15;
8028 kern_type = KERN_TYPE_SHA256_SLTPW;
8029 dgst_size = DGST_SIZE_4_8;
8030 parse_func = hmailserver_parse_hash;
8031 sort_by_digest = sort_by_digest_4_8;
8032 opti_type = OPTI_TYPE_ZERO_BYTE
8033 | OPTI_TYPE_PRECOMPUTE_INIT
8034 | OPTI_TYPE_PRECOMPUTE_MERKLE
8035 | OPTI_TYPE_EARLY_SKIP
8036 | OPTI_TYPE_NOT_ITERATED
8037 | OPTI_TYPE_PREPENDED_SALT
8038 | OPTI_TYPE_RAW_HASH;
8039 dgst_pos0 = 3;
8040 dgst_pos1 = 7;
8041 dgst_pos2 = 2;
8042 dgst_pos3 = 6;
8043 break;
8044
8045 case 1430: hash_type = HASH_TYPE_SHA256;
8046 salt_type = SALT_TYPE_INTERN;
8047 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8048 opts_type = OPTS_TYPE_PT_GENERATE_BE
8049 | OPTS_TYPE_PT_UNICODE
8050 | OPTS_TYPE_ST_ADD80
8051 | OPTS_TYPE_ST_ADDBITS15;
8052 kern_type = KERN_TYPE_SHA256_PWUSLT;
8053 dgst_size = DGST_SIZE_4_8;
8054 parse_func = sha256s_parse_hash;
8055 sort_by_digest = sort_by_digest_4_8;
8056 opti_type = OPTI_TYPE_ZERO_BYTE
8057 | OPTI_TYPE_PRECOMPUTE_INIT
8058 | OPTI_TYPE_PRECOMPUTE_MERKLE
8059 | OPTI_TYPE_EARLY_SKIP
8060 | OPTI_TYPE_NOT_ITERATED
8061 | OPTI_TYPE_APPENDED_SALT
8062 | OPTI_TYPE_RAW_HASH;
8063 dgst_pos0 = 3;
8064 dgst_pos1 = 7;
8065 dgst_pos2 = 2;
8066 dgst_pos3 = 6;
8067 break;
8068
8069 case 1440: hash_type = HASH_TYPE_SHA256;
8070 salt_type = SALT_TYPE_INTERN;
8071 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8072 opts_type = OPTS_TYPE_PT_GENERATE_BE
8073 | OPTS_TYPE_PT_ADD80
8074 | OPTS_TYPE_PT_ADDBITS15
8075 | OPTS_TYPE_PT_UNICODE;
8076 kern_type = KERN_TYPE_SHA256_SLTPWU;
8077 dgst_size = DGST_SIZE_4_8;
8078 parse_func = sha256s_parse_hash;
8079 sort_by_digest = sort_by_digest_4_8;
8080 opti_type = OPTI_TYPE_ZERO_BYTE
8081 | OPTI_TYPE_PRECOMPUTE_INIT
8082 | OPTI_TYPE_PRECOMPUTE_MERKLE
8083 | OPTI_TYPE_EARLY_SKIP
8084 | OPTI_TYPE_NOT_ITERATED
8085 | OPTI_TYPE_PREPENDED_SALT
8086 | OPTI_TYPE_RAW_HASH;
8087 dgst_pos0 = 3;
8088 dgst_pos1 = 7;
8089 dgst_pos2 = 2;
8090 dgst_pos3 = 6;
8091 break;
8092
8093 case 1441: hash_type = HASH_TYPE_SHA256;
8094 salt_type = SALT_TYPE_EMBEDDED;
8095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8096 opts_type = OPTS_TYPE_PT_GENERATE_BE
8097 | OPTS_TYPE_PT_ADD80
8098 | OPTS_TYPE_PT_ADDBITS15
8099 | OPTS_TYPE_PT_UNICODE
8100 | OPTS_TYPE_ST_BASE64;
8101 kern_type = KERN_TYPE_SHA256_SLTPWU;
8102 dgst_size = DGST_SIZE_4_8;
8103 parse_func = episerver4_parse_hash;
8104 sort_by_digest = sort_by_digest_4_8;
8105 opti_type = OPTI_TYPE_ZERO_BYTE
8106 | OPTI_TYPE_PRECOMPUTE_INIT
8107 | OPTI_TYPE_PRECOMPUTE_MERKLE
8108 | OPTI_TYPE_EARLY_SKIP
8109 | OPTI_TYPE_NOT_ITERATED
8110 | OPTI_TYPE_PREPENDED_SALT
8111 | OPTI_TYPE_RAW_HASH;
8112 dgst_pos0 = 3;
8113 dgst_pos1 = 7;
8114 dgst_pos2 = 2;
8115 dgst_pos3 = 6;
8116 break;
8117
8118 case 1450: hash_type = HASH_TYPE_SHA256;
8119 salt_type = SALT_TYPE_INTERN;
8120 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8121 opts_type = OPTS_TYPE_PT_GENERATE_BE
8122 | OPTS_TYPE_ST_ADD80;
8123 kern_type = KERN_TYPE_HMACSHA256_PW;
8124 dgst_size = DGST_SIZE_4_8;
8125 parse_func = hmacsha256_parse_hash;
8126 sort_by_digest = sort_by_digest_4_8;
8127 opti_type = OPTI_TYPE_ZERO_BYTE
8128 | OPTI_TYPE_NOT_ITERATED;
8129 dgst_pos0 = 3;
8130 dgst_pos1 = 7;
8131 dgst_pos2 = 2;
8132 dgst_pos3 = 6;
8133 break;
8134
8135 case 1460: hash_type = HASH_TYPE_SHA256;
8136 salt_type = SALT_TYPE_INTERN;
8137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8138 opts_type = OPTS_TYPE_PT_GENERATE_BE
8139 | OPTS_TYPE_PT_ADD80
8140 | OPTS_TYPE_PT_ADDBITS15;
8141 kern_type = KERN_TYPE_HMACSHA256_SLT;
8142 dgst_size = DGST_SIZE_4_8;
8143 parse_func = hmacsha256_parse_hash;
8144 sort_by_digest = sort_by_digest_4_8;
8145 opti_type = OPTI_TYPE_ZERO_BYTE
8146 | OPTI_TYPE_NOT_ITERATED;
8147 dgst_pos0 = 3;
8148 dgst_pos1 = 7;
8149 dgst_pos2 = 2;
8150 dgst_pos3 = 6;
8151 break;
8152
8153 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8154 salt_type = SALT_TYPE_EMBEDDED;
8155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8156 opts_type = OPTS_TYPE_PT_GENERATE_LE
8157 | OPTS_TYPE_PT_BITSLICE;
8158 kern_type = KERN_TYPE_DESCRYPT;
8159 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8160 parse_func = descrypt_parse_hash;
8161 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8162 opti_type = OPTI_TYPE_ZERO_BYTE
8163 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8164 dgst_pos0 = 0;
8165 dgst_pos1 = 1;
8166 dgst_pos2 = 2;
8167 dgst_pos3 = 3;
8168 break;
8169
8170 case 1600: 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_APR1CRYPT;
8175 dgst_size = DGST_SIZE_4_4;
8176 parse_func = md5apr1_parse_hash;
8177 sort_by_digest = sort_by_digest_4_4;
8178 opti_type = OPTI_TYPE_ZERO_BYTE;
8179 dgst_pos0 = 0;
8180 dgst_pos1 = 1;
8181 dgst_pos2 = 2;
8182 dgst_pos3 = 3;
8183 break;
8184
8185 case 1700: hash_type = HASH_TYPE_SHA512;
8186 salt_type = SALT_TYPE_NONE;
8187 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8188 opts_type = OPTS_TYPE_PT_GENERATE_BE
8189 | OPTS_TYPE_PT_ADD80
8190 | OPTS_TYPE_PT_ADDBITS15;
8191 kern_type = KERN_TYPE_SHA512;
8192 dgst_size = DGST_SIZE_8_8;
8193 parse_func = sha512_parse_hash;
8194 sort_by_digest = sort_by_digest_8_8;
8195 opti_type = OPTI_TYPE_ZERO_BYTE
8196 | OPTI_TYPE_PRECOMPUTE_INIT
8197 | OPTI_TYPE_PRECOMPUTE_MERKLE
8198 | OPTI_TYPE_EARLY_SKIP
8199 | OPTI_TYPE_NOT_ITERATED
8200 | OPTI_TYPE_NOT_SALTED
8201 | OPTI_TYPE_USES_BITS_64
8202 | OPTI_TYPE_RAW_HASH;
8203 dgst_pos0 = 14;
8204 dgst_pos1 = 15;
8205 dgst_pos2 = 6;
8206 dgst_pos3 = 7;
8207 break;
8208
8209 case 1710: hash_type = HASH_TYPE_SHA512;
8210 salt_type = SALT_TYPE_INTERN;
8211 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8212 opts_type = OPTS_TYPE_PT_GENERATE_BE
8213 | OPTS_TYPE_ST_ADD80
8214 | OPTS_TYPE_ST_ADDBITS15;
8215 kern_type = KERN_TYPE_SHA512_PWSLT;
8216 dgst_size = DGST_SIZE_8_8;
8217 parse_func = sha512s_parse_hash;
8218 sort_by_digest = sort_by_digest_8_8;
8219 opti_type = OPTI_TYPE_ZERO_BYTE
8220 | OPTI_TYPE_PRECOMPUTE_INIT
8221 | OPTI_TYPE_PRECOMPUTE_MERKLE
8222 | OPTI_TYPE_EARLY_SKIP
8223 | OPTI_TYPE_NOT_ITERATED
8224 | OPTI_TYPE_APPENDED_SALT
8225 | OPTI_TYPE_USES_BITS_64
8226 | OPTI_TYPE_RAW_HASH;
8227 dgst_pos0 = 14;
8228 dgst_pos1 = 15;
8229 dgst_pos2 = 6;
8230 dgst_pos3 = 7;
8231 break;
8232
8233 case 1711: hash_type = HASH_TYPE_SHA512;
8234 salt_type = SALT_TYPE_EMBEDDED;
8235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8236 opts_type = OPTS_TYPE_PT_GENERATE_BE
8237 | OPTS_TYPE_ST_ADD80
8238 | OPTS_TYPE_ST_ADDBITS15;
8239 kern_type = KERN_TYPE_SHA512_PWSLT;
8240 dgst_size = DGST_SIZE_8_8;
8241 parse_func = sha512b64s_parse_hash;
8242 sort_by_digest = sort_by_digest_8_8;
8243 opti_type = OPTI_TYPE_ZERO_BYTE
8244 | OPTI_TYPE_PRECOMPUTE_INIT
8245 | OPTI_TYPE_PRECOMPUTE_MERKLE
8246 | OPTI_TYPE_EARLY_SKIP
8247 | OPTI_TYPE_NOT_ITERATED
8248 | OPTI_TYPE_APPENDED_SALT
8249 | OPTI_TYPE_USES_BITS_64
8250 | OPTI_TYPE_RAW_HASH;
8251 dgst_pos0 = 14;
8252 dgst_pos1 = 15;
8253 dgst_pos2 = 6;
8254 dgst_pos3 = 7;
8255 break;
8256
8257 case 1720: hash_type = HASH_TYPE_SHA512;
8258 salt_type = SALT_TYPE_INTERN;
8259 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8260 opts_type = OPTS_TYPE_PT_GENERATE_BE
8261 | OPTS_TYPE_PT_ADD80
8262 | OPTS_TYPE_PT_ADDBITS15;
8263 kern_type = KERN_TYPE_SHA512_SLTPW;
8264 dgst_size = DGST_SIZE_8_8;
8265 parse_func = sha512s_parse_hash;
8266 sort_by_digest = sort_by_digest_8_8;
8267 opti_type = OPTI_TYPE_ZERO_BYTE
8268 | OPTI_TYPE_PRECOMPUTE_INIT
8269 | OPTI_TYPE_PRECOMPUTE_MERKLE
8270 | OPTI_TYPE_EARLY_SKIP
8271 | OPTI_TYPE_NOT_ITERATED
8272 | OPTI_TYPE_PREPENDED_SALT
8273 | OPTI_TYPE_USES_BITS_64
8274 | OPTI_TYPE_RAW_HASH;
8275 dgst_pos0 = 14;
8276 dgst_pos1 = 15;
8277 dgst_pos2 = 6;
8278 dgst_pos3 = 7;
8279 break;
8280
8281 case 1722: hash_type = HASH_TYPE_SHA512;
8282 salt_type = SALT_TYPE_EMBEDDED;
8283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8284 opts_type = OPTS_TYPE_PT_GENERATE_BE
8285 | OPTS_TYPE_PT_ADD80
8286 | OPTS_TYPE_PT_ADDBITS15
8287 | OPTS_TYPE_ST_HEX;
8288 kern_type = KERN_TYPE_SHA512_SLTPW;
8289 dgst_size = DGST_SIZE_8_8;
8290 parse_func = osx512_parse_hash;
8291 sort_by_digest = sort_by_digest_8_8;
8292 opti_type = OPTI_TYPE_ZERO_BYTE
8293 | OPTI_TYPE_PRECOMPUTE_INIT
8294 | OPTI_TYPE_PRECOMPUTE_MERKLE
8295 | OPTI_TYPE_EARLY_SKIP
8296 | OPTI_TYPE_NOT_ITERATED
8297 | OPTI_TYPE_PREPENDED_SALT
8298 | OPTI_TYPE_USES_BITS_64
8299 | OPTI_TYPE_RAW_HASH;
8300 dgst_pos0 = 14;
8301 dgst_pos1 = 15;
8302 dgst_pos2 = 6;
8303 dgst_pos3 = 7;
8304 break;
8305
8306 case 1730: hash_type = HASH_TYPE_SHA512;
8307 salt_type = SALT_TYPE_INTERN;
8308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8309 opts_type = OPTS_TYPE_PT_GENERATE_BE
8310 | OPTS_TYPE_PT_UNICODE
8311 | OPTS_TYPE_ST_ADD80
8312 | OPTS_TYPE_ST_ADDBITS15;
8313 kern_type = KERN_TYPE_SHA512_PWSLTU;
8314 dgst_size = DGST_SIZE_8_8;
8315 parse_func = sha512s_parse_hash;
8316 sort_by_digest = sort_by_digest_8_8;
8317 opti_type = OPTI_TYPE_ZERO_BYTE
8318 | OPTI_TYPE_PRECOMPUTE_INIT
8319 | OPTI_TYPE_PRECOMPUTE_MERKLE
8320 | OPTI_TYPE_EARLY_SKIP
8321 | OPTI_TYPE_NOT_ITERATED
8322 | OPTI_TYPE_APPENDED_SALT
8323 | OPTI_TYPE_USES_BITS_64
8324 | OPTI_TYPE_RAW_HASH;
8325 dgst_pos0 = 14;
8326 dgst_pos1 = 15;
8327 dgst_pos2 = 6;
8328 dgst_pos3 = 7;
8329 break;
8330
8331 case 1731: hash_type = HASH_TYPE_SHA512;
8332 salt_type = SALT_TYPE_EMBEDDED;
8333 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8334 opts_type = OPTS_TYPE_PT_GENERATE_BE
8335 | OPTS_TYPE_PT_UNICODE
8336 | OPTS_TYPE_ST_ADD80
8337 | OPTS_TYPE_ST_ADDBITS15
8338 | OPTS_TYPE_ST_HEX;
8339 kern_type = KERN_TYPE_SHA512_PWSLTU;
8340 dgst_size = DGST_SIZE_8_8;
8341 parse_func = mssql2012_parse_hash;
8342 sort_by_digest = sort_by_digest_8_8;
8343 opti_type = OPTI_TYPE_ZERO_BYTE
8344 | OPTI_TYPE_PRECOMPUTE_INIT
8345 | OPTI_TYPE_PRECOMPUTE_MERKLE
8346 | OPTI_TYPE_EARLY_SKIP
8347 | OPTI_TYPE_NOT_ITERATED
8348 | OPTI_TYPE_APPENDED_SALT
8349 | OPTI_TYPE_USES_BITS_64
8350 | OPTI_TYPE_RAW_HASH;
8351 dgst_pos0 = 14;
8352 dgst_pos1 = 15;
8353 dgst_pos2 = 6;
8354 dgst_pos3 = 7;
8355 break;
8356
8357 case 1740: hash_type = HASH_TYPE_SHA512;
8358 salt_type = SALT_TYPE_INTERN;
8359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8360 opts_type = OPTS_TYPE_PT_GENERATE_BE
8361 | OPTS_TYPE_PT_ADD80
8362 | OPTS_TYPE_PT_ADDBITS15
8363 | OPTS_TYPE_PT_UNICODE;
8364 kern_type = KERN_TYPE_SHA512_SLTPWU;
8365 dgst_size = DGST_SIZE_8_8;
8366 parse_func = sha512s_parse_hash;
8367 sort_by_digest = sort_by_digest_8_8;
8368 opti_type = OPTI_TYPE_ZERO_BYTE
8369 | OPTI_TYPE_PRECOMPUTE_INIT
8370 | OPTI_TYPE_PRECOMPUTE_MERKLE
8371 | OPTI_TYPE_EARLY_SKIP
8372 | OPTI_TYPE_NOT_ITERATED
8373 | OPTI_TYPE_PREPENDED_SALT
8374 | OPTI_TYPE_USES_BITS_64
8375 | OPTI_TYPE_RAW_HASH;
8376 dgst_pos0 = 14;
8377 dgst_pos1 = 15;
8378 dgst_pos2 = 6;
8379 dgst_pos3 = 7;
8380 break;
8381
8382 case 1750: hash_type = HASH_TYPE_SHA512;
8383 salt_type = SALT_TYPE_INTERN;
8384 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8385 opts_type = OPTS_TYPE_PT_GENERATE_BE
8386 | OPTS_TYPE_ST_ADD80;
8387 kern_type = KERN_TYPE_HMACSHA512_PW;
8388 dgst_size = DGST_SIZE_8_8;
8389 parse_func = hmacsha512_parse_hash;
8390 sort_by_digest = sort_by_digest_8_8;
8391 opti_type = OPTI_TYPE_ZERO_BYTE
8392 | OPTI_TYPE_USES_BITS_64
8393 | OPTI_TYPE_NOT_ITERATED;
8394 dgst_pos0 = 14;
8395 dgst_pos1 = 15;
8396 dgst_pos2 = 6;
8397 dgst_pos3 = 7;
8398 break;
8399
8400 case 1760: hash_type = HASH_TYPE_SHA512;
8401 salt_type = SALT_TYPE_INTERN;
8402 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8403 opts_type = OPTS_TYPE_PT_GENERATE_BE
8404 | OPTS_TYPE_PT_ADD80
8405 | OPTS_TYPE_PT_ADDBITS15;
8406 kern_type = KERN_TYPE_HMACSHA512_SLT;
8407 dgst_size = DGST_SIZE_8_8;
8408 parse_func = hmacsha512_parse_hash;
8409 sort_by_digest = sort_by_digest_8_8;
8410 opti_type = OPTI_TYPE_ZERO_BYTE
8411 | OPTI_TYPE_USES_BITS_64
8412 | OPTI_TYPE_NOT_ITERATED;
8413 dgst_pos0 = 14;
8414 dgst_pos1 = 15;
8415 dgst_pos2 = 6;
8416 dgst_pos3 = 7;
8417 break;
8418
8419 case 1800: hash_type = HASH_TYPE_SHA512;
8420 salt_type = SALT_TYPE_EMBEDDED;
8421 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8422 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8423 kern_type = KERN_TYPE_SHA512CRYPT;
8424 dgst_size = DGST_SIZE_8_8;
8425 parse_func = sha512crypt_parse_hash;
8426 sort_by_digest = sort_by_digest_8_8;
8427 opti_type = OPTI_TYPE_ZERO_BYTE
8428 | OPTI_TYPE_USES_BITS_64;
8429 dgst_pos0 = 0;
8430 dgst_pos1 = 1;
8431 dgst_pos2 = 2;
8432 dgst_pos3 = 3;
8433 break;
8434
8435 case 2100: hash_type = HASH_TYPE_DCC2;
8436 salt_type = SALT_TYPE_EMBEDDED;
8437 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8438 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8439 | OPTS_TYPE_ST_LOWER
8440 | OPTS_TYPE_ST_UNICODE;
8441 kern_type = KERN_TYPE_DCC2;
8442 dgst_size = DGST_SIZE_4_4;
8443 parse_func = dcc2_parse_hash;
8444 sort_by_digest = sort_by_digest_4_4;
8445 opti_type = OPTI_TYPE_ZERO_BYTE
8446 | OPTI_TYPE_SLOW_HASH_SIMD;
8447 dgst_pos0 = 0;
8448 dgst_pos1 = 1;
8449 dgst_pos2 = 2;
8450 dgst_pos3 = 3;
8451 break;
8452
8453 case 2400: hash_type = HASH_TYPE_MD5;
8454 salt_type = SALT_TYPE_NONE;
8455 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8456 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8457 kern_type = KERN_TYPE_MD5PIX;
8458 dgst_size = DGST_SIZE_4_4;
8459 parse_func = md5pix_parse_hash;
8460 sort_by_digest = sort_by_digest_4_4;
8461 opti_type = OPTI_TYPE_ZERO_BYTE
8462 | OPTI_TYPE_PRECOMPUTE_INIT
8463 | OPTI_TYPE_PRECOMPUTE_MERKLE
8464 | OPTI_TYPE_EARLY_SKIP
8465 | OPTI_TYPE_NOT_ITERATED
8466 | OPTI_TYPE_NOT_SALTED;
8467 dgst_pos0 = 0;
8468 dgst_pos1 = 3;
8469 dgst_pos2 = 2;
8470 dgst_pos3 = 1;
8471 break;
8472
8473 case 2410: hash_type = HASH_TYPE_MD5;
8474 salt_type = SALT_TYPE_INTERN;
8475 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8476 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8477 kern_type = KERN_TYPE_MD5ASA;
8478 dgst_size = DGST_SIZE_4_4;
8479 parse_func = md5asa_parse_hash;
8480 sort_by_digest = sort_by_digest_4_4;
8481 opti_type = OPTI_TYPE_ZERO_BYTE
8482 | OPTI_TYPE_PRECOMPUTE_INIT
8483 | OPTI_TYPE_PRECOMPUTE_MERKLE
8484 | OPTI_TYPE_EARLY_SKIP
8485 | OPTI_TYPE_NOT_ITERATED;
8486 dgst_pos0 = 0;
8487 dgst_pos1 = 3;
8488 dgst_pos2 = 2;
8489 dgst_pos3 = 1;
8490 break;
8491
8492 case 2500: hash_type = HASH_TYPE_WPA;
8493 salt_type = SALT_TYPE_EMBEDDED;
8494 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8495 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8496 kern_type = KERN_TYPE_WPA;
8497 dgst_size = DGST_SIZE_4_4;
8498 parse_func = wpa_parse_hash;
8499 sort_by_digest = sort_by_digest_4_4;
8500 opti_type = OPTI_TYPE_ZERO_BYTE
8501 | OPTI_TYPE_SLOW_HASH_SIMD;
8502 dgst_pos0 = 0;
8503 dgst_pos1 = 1;
8504 dgst_pos2 = 2;
8505 dgst_pos3 = 3;
8506 break;
8507
8508 case 2600: hash_type = HASH_TYPE_MD5;
8509 salt_type = SALT_TYPE_VIRTUAL;
8510 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8511 opts_type = OPTS_TYPE_PT_GENERATE_LE
8512 | OPTS_TYPE_PT_ADD80
8513 | OPTS_TYPE_PT_ADDBITS14
8514 | OPTS_TYPE_ST_ADD80;
8515 kern_type = KERN_TYPE_MD55_PWSLT1;
8516 dgst_size = DGST_SIZE_4_4;
8517 parse_func = md5md5_parse_hash;
8518 sort_by_digest = sort_by_digest_4_4;
8519 opti_type = OPTI_TYPE_ZERO_BYTE
8520 | OPTI_TYPE_PRECOMPUTE_INIT
8521 | OPTI_TYPE_PRECOMPUTE_MERKLE
8522 | OPTI_TYPE_EARLY_SKIP;
8523 dgst_pos0 = 0;
8524 dgst_pos1 = 3;
8525 dgst_pos2 = 2;
8526 dgst_pos3 = 1;
8527 break;
8528
8529 case 2611: hash_type = HASH_TYPE_MD5;
8530 salt_type = SALT_TYPE_INTERN;
8531 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8532 opts_type = OPTS_TYPE_PT_GENERATE_LE
8533 | OPTS_TYPE_PT_ADD80
8534 | OPTS_TYPE_PT_ADDBITS14
8535 | OPTS_TYPE_ST_ADD80;
8536 kern_type = KERN_TYPE_MD55_PWSLT1;
8537 dgst_size = DGST_SIZE_4_4;
8538 parse_func = vb3_parse_hash;
8539 sort_by_digest = sort_by_digest_4_4;
8540 opti_type = OPTI_TYPE_ZERO_BYTE
8541 | OPTI_TYPE_PRECOMPUTE_INIT
8542 | OPTI_TYPE_PRECOMPUTE_MERKLE
8543 | OPTI_TYPE_EARLY_SKIP;
8544 dgst_pos0 = 0;
8545 dgst_pos1 = 3;
8546 dgst_pos2 = 2;
8547 dgst_pos3 = 1;
8548 break;
8549
8550 case 2612: hash_type = HASH_TYPE_MD5;
8551 salt_type = SALT_TYPE_EMBEDDED;
8552 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8553 opts_type = OPTS_TYPE_PT_GENERATE_LE
8554 | OPTS_TYPE_PT_ADD80
8555 | OPTS_TYPE_PT_ADDBITS14
8556 | OPTS_TYPE_ST_ADD80
8557 | OPTS_TYPE_ST_HEX;
8558 kern_type = KERN_TYPE_MD55_PWSLT1;
8559 dgst_size = DGST_SIZE_4_4;
8560 parse_func = phps_parse_hash;
8561 sort_by_digest = sort_by_digest_4_4;
8562 opti_type = OPTI_TYPE_ZERO_BYTE
8563 | OPTI_TYPE_PRECOMPUTE_INIT
8564 | OPTI_TYPE_PRECOMPUTE_MERKLE
8565 | OPTI_TYPE_EARLY_SKIP;
8566 dgst_pos0 = 0;
8567 dgst_pos1 = 3;
8568 dgst_pos2 = 2;
8569 dgst_pos3 = 1;
8570 break;
8571
8572 case 2711: hash_type = HASH_TYPE_MD5;
8573 salt_type = SALT_TYPE_INTERN;
8574 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8575 opts_type = OPTS_TYPE_PT_GENERATE_LE
8576 | OPTS_TYPE_PT_ADD80
8577 | OPTS_TYPE_PT_ADDBITS14
8578 | OPTS_TYPE_ST_ADD80;
8579 kern_type = KERN_TYPE_MD55_PWSLT2;
8580 dgst_size = DGST_SIZE_4_4;
8581 parse_func = vb30_parse_hash;
8582 sort_by_digest = sort_by_digest_4_4;
8583 opti_type = OPTI_TYPE_ZERO_BYTE
8584 | OPTI_TYPE_PRECOMPUTE_INIT
8585 | OPTI_TYPE_EARLY_SKIP;
8586 dgst_pos0 = 0;
8587 dgst_pos1 = 3;
8588 dgst_pos2 = 2;
8589 dgst_pos3 = 1;
8590 break;
8591
8592 case 2811: hash_type = HASH_TYPE_MD5;
8593 salt_type = SALT_TYPE_INTERN;
8594 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8595 opts_type = OPTS_TYPE_PT_GENERATE_LE
8596 | OPTS_TYPE_PT_ADD80
8597 | OPTS_TYPE_PT_ADDBITS14;
8598 kern_type = KERN_TYPE_MD55_SLTPW;
8599 dgst_size = DGST_SIZE_4_4;
8600 parse_func = ipb2_parse_hash;
8601 sort_by_digest = sort_by_digest_4_4;
8602 opti_type = OPTI_TYPE_ZERO_BYTE
8603 | OPTI_TYPE_PRECOMPUTE_INIT
8604 | OPTI_TYPE_EARLY_SKIP;
8605 dgst_pos0 = 0;
8606 dgst_pos1 = 3;
8607 dgst_pos2 = 2;
8608 dgst_pos3 = 1;
8609 break;
8610
8611 case 3000: hash_type = HASH_TYPE_LM;
8612 salt_type = SALT_TYPE_NONE;
8613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8614 opts_type = OPTS_TYPE_PT_GENERATE_LE
8615 | OPTS_TYPE_PT_UPPER
8616 | OPTS_TYPE_PT_BITSLICE;
8617 kern_type = KERN_TYPE_LM;
8618 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8619 parse_func = lm_parse_hash;
8620 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8621 opti_type = OPTI_TYPE_ZERO_BYTE
8622 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8623 dgst_pos0 = 0;
8624 dgst_pos1 = 1;
8625 dgst_pos2 = 2;
8626 dgst_pos3 = 3;
8627 break;
8628
8629 case 3100: hash_type = HASH_TYPE_ORACLEH;
8630 salt_type = SALT_TYPE_INTERN;
8631 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8632 opts_type = OPTS_TYPE_PT_GENERATE_LE
8633 | OPTS_TYPE_PT_UPPER
8634 | OPTS_TYPE_ST_UPPER;
8635 kern_type = KERN_TYPE_ORACLEH;
8636 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8637 parse_func = oracleh_parse_hash;
8638 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8639 opti_type = OPTI_TYPE_ZERO_BYTE;
8640 dgst_pos0 = 0;
8641 dgst_pos1 = 1;
8642 dgst_pos2 = 2;
8643 dgst_pos3 = 3;
8644 break;
8645
8646 case 3200: hash_type = HASH_TYPE_BCRYPT;
8647 salt_type = SALT_TYPE_EMBEDDED;
8648 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8649 opts_type = OPTS_TYPE_PT_GENERATE_LE
8650 | OPTS_TYPE_ST_GENERATE_LE;
8651 kern_type = KERN_TYPE_BCRYPT;
8652 dgst_size = DGST_SIZE_4_6;
8653 parse_func = bcrypt_parse_hash;
8654 sort_by_digest = sort_by_digest_4_6;
8655 opti_type = OPTI_TYPE_ZERO_BYTE;
8656 dgst_pos0 = 0;
8657 dgst_pos1 = 1;
8658 dgst_pos2 = 2;
8659 dgst_pos3 = 3;
8660 break;
8661
8662 case 3710: hash_type = HASH_TYPE_MD5;
8663 salt_type = SALT_TYPE_INTERN;
8664 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8665 opts_type = OPTS_TYPE_PT_GENERATE_LE
8666 | OPTS_TYPE_PT_ADD80
8667 | OPTS_TYPE_PT_ADDBITS14;
8668 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8669 dgst_size = DGST_SIZE_4_4;
8670 parse_func = md5s_parse_hash;
8671 sort_by_digest = sort_by_digest_4_4;
8672 opti_type = OPTI_TYPE_ZERO_BYTE
8673 | OPTI_TYPE_PRECOMPUTE_INIT
8674 | OPTI_TYPE_PRECOMPUTE_MERKLE
8675 | OPTI_TYPE_EARLY_SKIP;
8676 dgst_pos0 = 0;
8677 dgst_pos1 = 3;
8678 dgst_pos2 = 2;
8679 dgst_pos3 = 1;
8680 break;
8681
8682 case 3711: hash_type = HASH_TYPE_MD5;
8683 salt_type = SALT_TYPE_EMBEDDED;
8684 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8685 opts_type = OPTS_TYPE_PT_GENERATE_LE
8686 | OPTS_TYPE_PT_ADD80
8687 | OPTS_TYPE_PT_ADDBITS14;
8688 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8689 dgst_size = DGST_SIZE_4_4;
8690 parse_func = mediawiki_b_parse_hash;
8691 sort_by_digest = sort_by_digest_4_4;
8692 opti_type = OPTI_TYPE_ZERO_BYTE
8693 | OPTI_TYPE_PRECOMPUTE_INIT
8694 | OPTI_TYPE_PRECOMPUTE_MERKLE
8695 | OPTI_TYPE_EARLY_SKIP;
8696 dgst_pos0 = 0;
8697 dgst_pos1 = 3;
8698 dgst_pos2 = 2;
8699 dgst_pos3 = 1;
8700 break;
8701
8702 case 3800: hash_type = HASH_TYPE_MD5;
8703 salt_type = SALT_TYPE_INTERN;
8704 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8705 opts_type = OPTS_TYPE_PT_GENERATE_LE
8706 | OPTS_TYPE_ST_ADDBITS14;
8707 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8708 dgst_size = DGST_SIZE_4_4;
8709 parse_func = md5s_parse_hash;
8710 sort_by_digest = sort_by_digest_4_4;
8711 opti_type = OPTI_TYPE_ZERO_BYTE
8712 | OPTI_TYPE_PRECOMPUTE_INIT
8713 | OPTI_TYPE_PRECOMPUTE_MERKLE
8714 | OPTI_TYPE_EARLY_SKIP
8715 | OPTI_TYPE_NOT_ITERATED
8716 | OPTI_TYPE_RAW_HASH;
8717 dgst_pos0 = 0;
8718 dgst_pos1 = 3;
8719 dgst_pos2 = 2;
8720 dgst_pos3 = 1;
8721 break;
8722
8723 case 4300: hash_type = HASH_TYPE_MD5;
8724 salt_type = SALT_TYPE_VIRTUAL;
8725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8726 opts_type = OPTS_TYPE_PT_GENERATE_LE
8727 | OPTS_TYPE_PT_ADD80
8728 | OPTS_TYPE_PT_ADDBITS14
8729 | OPTS_TYPE_ST_ADD80;
8730 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8731 dgst_size = DGST_SIZE_4_4;
8732 parse_func = md5md5_parse_hash;
8733 sort_by_digest = sort_by_digest_4_4;
8734 opti_type = OPTI_TYPE_ZERO_BYTE
8735 | OPTI_TYPE_PRECOMPUTE_INIT
8736 | OPTI_TYPE_PRECOMPUTE_MERKLE
8737 | OPTI_TYPE_EARLY_SKIP;
8738 dgst_pos0 = 0;
8739 dgst_pos1 = 3;
8740 dgst_pos2 = 2;
8741 dgst_pos3 = 1;
8742 break;
8743
8744
8745 case 4400: hash_type = HASH_TYPE_MD5;
8746 salt_type = SALT_TYPE_NONE;
8747 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8748 opts_type = OPTS_TYPE_PT_GENERATE_BE
8749 | OPTS_TYPE_PT_ADD80
8750 | OPTS_TYPE_PT_ADDBITS15;
8751 kern_type = KERN_TYPE_MD5_SHA1;
8752 dgst_size = DGST_SIZE_4_4;
8753 parse_func = md5_parse_hash;
8754 sort_by_digest = sort_by_digest_4_4;
8755 opti_type = OPTI_TYPE_ZERO_BYTE
8756 | OPTI_TYPE_PRECOMPUTE_INIT
8757 | OPTI_TYPE_PRECOMPUTE_MERKLE
8758 | OPTI_TYPE_EARLY_SKIP
8759 | OPTI_TYPE_NOT_ITERATED
8760 | OPTI_TYPE_NOT_SALTED
8761 | OPTI_TYPE_RAW_HASH;
8762 dgst_pos0 = 0;
8763 dgst_pos1 = 3;
8764 dgst_pos2 = 2;
8765 dgst_pos3 = 1;
8766 break;
8767
8768 case 4500: hash_type = HASH_TYPE_SHA1;
8769 salt_type = SALT_TYPE_NONE;
8770 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8771 opts_type = OPTS_TYPE_PT_GENERATE_BE
8772 | OPTS_TYPE_PT_ADD80
8773 | OPTS_TYPE_PT_ADDBITS15;
8774 kern_type = KERN_TYPE_SHA11;
8775 dgst_size = DGST_SIZE_4_5;
8776 parse_func = sha1_parse_hash;
8777 sort_by_digest = sort_by_digest_4_5;
8778 opti_type = OPTI_TYPE_ZERO_BYTE
8779 | OPTI_TYPE_PRECOMPUTE_INIT
8780 | OPTI_TYPE_PRECOMPUTE_MERKLE
8781 | OPTI_TYPE_EARLY_SKIP
8782 | OPTI_TYPE_NOT_SALTED;
8783 dgst_pos0 = 3;
8784 dgst_pos1 = 4;
8785 dgst_pos2 = 2;
8786 dgst_pos3 = 1;
8787 break;
8788
8789 case 4700: hash_type = HASH_TYPE_SHA1;
8790 salt_type = SALT_TYPE_NONE;
8791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8792 opts_type = OPTS_TYPE_PT_GENERATE_LE
8793 | OPTS_TYPE_PT_ADD80
8794 | OPTS_TYPE_PT_ADDBITS14;
8795 kern_type = KERN_TYPE_SHA1_MD5;
8796 dgst_size = DGST_SIZE_4_5;
8797 parse_func = sha1_parse_hash;
8798 sort_by_digest = sort_by_digest_4_5;
8799 opti_type = OPTI_TYPE_ZERO_BYTE
8800 | OPTI_TYPE_PRECOMPUTE_INIT
8801 | OPTI_TYPE_PRECOMPUTE_MERKLE
8802 | OPTI_TYPE_EARLY_SKIP
8803 | OPTI_TYPE_NOT_ITERATED
8804 | OPTI_TYPE_NOT_SALTED
8805 | OPTI_TYPE_RAW_HASH;
8806 dgst_pos0 = 3;
8807 dgst_pos1 = 4;
8808 dgst_pos2 = 2;
8809 dgst_pos3 = 1;
8810 break;
8811
8812 case 4800: hash_type = HASH_TYPE_MD5;
8813 salt_type = SALT_TYPE_EMBEDDED;
8814 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8815 opts_type = OPTS_TYPE_PT_GENERATE_LE
8816 | OPTS_TYPE_PT_ADDBITS14;
8817 kern_type = KERN_TYPE_MD5_CHAP;
8818 dgst_size = DGST_SIZE_4_4;
8819 parse_func = chap_parse_hash;
8820 sort_by_digest = sort_by_digest_4_4;
8821 opti_type = OPTI_TYPE_ZERO_BYTE
8822 | OPTI_TYPE_PRECOMPUTE_INIT
8823 | OPTI_TYPE_PRECOMPUTE_MERKLE
8824 | OPTI_TYPE_MEET_IN_MIDDLE
8825 | OPTI_TYPE_EARLY_SKIP
8826 | OPTI_TYPE_NOT_ITERATED
8827 | OPTI_TYPE_RAW_HASH;
8828 dgst_pos0 = 0;
8829 dgst_pos1 = 3;
8830 dgst_pos2 = 2;
8831 dgst_pos3 = 1;
8832 break;
8833
8834 case 4900: hash_type = HASH_TYPE_SHA1;
8835 salt_type = SALT_TYPE_INTERN;
8836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8837 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8838 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8839 dgst_size = DGST_SIZE_4_5;
8840 parse_func = sha1s_parse_hash;
8841 sort_by_digest = sort_by_digest_4_5;
8842 opti_type = OPTI_TYPE_ZERO_BYTE
8843 | OPTI_TYPE_PRECOMPUTE_INIT
8844 | OPTI_TYPE_PRECOMPUTE_MERKLE
8845 | OPTI_TYPE_EARLY_SKIP;
8846 dgst_pos0 = 3;
8847 dgst_pos1 = 4;
8848 dgst_pos2 = 2;
8849 dgst_pos3 = 1;
8850 break;
8851
8852 case 5000: hash_type = HASH_TYPE_KECCAK;
8853 salt_type = SALT_TYPE_EMBEDDED;
8854 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8855 opts_type = OPTS_TYPE_PT_GENERATE_LE
8856 | OPTS_TYPE_PT_ADD01;
8857 kern_type = KERN_TYPE_KECCAK;
8858 dgst_size = DGST_SIZE_8_25;
8859 parse_func = keccak_parse_hash;
8860 sort_by_digest = sort_by_digest_8_25;
8861 opti_type = OPTI_TYPE_ZERO_BYTE
8862 | OPTI_TYPE_USES_BITS_64
8863 | OPTI_TYPE_RAW_HASH;
8864 dgst_pos0 = 2;
8865 dgst_pos1 = 3;
8866 dgst_pos2 = 4;
8867 dgst_pos3 = 5;
8868 break;
8869
8870 case 5100: hash_type = HASH_TYPE_MD5H;
8871 salt_type = SALT_TYPE_NONE;
8872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8873 opts_type = OPTS_TYPE_PT_GENERATE_LE
8874 | OPTS_TYPE_PT_ADD80
8875 | OPTS_TYPE_PT_ADDBITS14;
8876 kern_type = KERN_TYPE_MD5H;
8877 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8878 parse_func = md5half_parse_hash;
8879 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8880 opti_type = OPTI_TYPE_ZERO_BYTE
8881 | OPTI_TYPE_RAW_HASH;
8882 dgst_pos0 = 0;
8883 dgst_pos1 = 1;
8884 dgst_pos2 = 2;
8885 dgst_pos3 = 3;
8886 break;
8887
8888 case 5200: hash_type = HASH_TYPE_SHA256;
8889 salt_type = SALT_TYPE_EMBEDDED;
8890 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8891 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8892 kern_type = KERN_TYPE_PSAFE3;
8893 dgst_size = DGST_SIZE_4_8;
8894 parse_func = psafe3_parse_hash;
8895 sort_by_digest = sort_by_digest_4_8;
8896 opti_type = OPTI_TYPE_ZERO_BYTE;
8897 dgst_pos0 = 0;
8898 dgst_pos1 = 1;
8899 dgst_pos2 = 2;
8900 dgst_pos3 = 3;
8901 break;
8902
8903 case 5300: 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_ST_ADD80;
8908 kern_type = KERN_TYPE_IKEPSK_MD5;
8909 dgst_size = DGST_SIZE_4_4;
8910 parse_func = ikepsk_md5_parse_hash;
8911 sort_by_digest = sort_by_digest_4_4;
8912 opti_type = OPTI_TYPE_ZERO_BYTE;
8913 dgst_pos0 = 0;
8914 dgst_pos1 = 3;
8915 dgst_pos2 = 2;
8916 dgst_pos3 = 1;
8917 break;
8918
8919 case 5400: hash_type = HASH_TYPE_SHA1;
8920 salt_type = SALT_TYPE_EMBEDDED;
8921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8922 opts_type = OPTS_TYPE_PT_GENERATE_BE
8923 | OPTS_TYPE_ST_ADD80;
8924 kern_type = KERN_TYPE_IKEPSK_SHA1;
8925 dgst_size = DGST_SIZE_4_5;
8926 parse_func = ikepsk_sha1_parse_hash;
8927 sort_by_digest = sort_by_digest_4_5;
8928 opti_type = OPTI_TYPE_ZERO_BYTE;
8929 dgst_pos0 = 3;
8930 dgst_pos1 = 4;
8931 dgst_pos2 = 2;
8932 dgst_pos3 = 1;
8933 break;
8934
8935 case 5500: hash_type = HASH_TYPE_NETNTLM;
8936 salt_type = SALT_TYPE_EMBEDDED;
8937 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8938 opts_type = OPTS_TYPE_PT_GENERATE_LE
8939 | OPTS_TYPE_PT_ADD80
8940 | OPTS_TYPE_PT_ADDBITS14
8941 | OPTS_TYPE_PT_UNICODE
8942 | OPTS_TYPE_ST_HEX;
8943 kern_type = KERN_TYPE_NETNTLMv1;
8944 dgst_size = DGST_SIZE_4_4;
8945 parse_func = netntlmv1_parse_hash;
8946 sort_by_digest = sort_by_digest_4_4;
8947 opti_type = OPTI_TYPE_ZERO_BYTE
8948 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8949 dgst_pos0 = 0;
8950 dgst_pos1 = 1;
8951 dgst_pos2 = 2;
8952 dgst_pos3 = 3;
8953 break;
8954
8955 case 5600: hash_type = HASH_TYPE_MD5;
8956 salt_type = SALT_TYPE_EMBEDDED;
8957 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8958 opts_type = OPTS_TYPE_PT_GENERATE_LE
8959 | OPTS_TYPE_PT_ADD80
8960 | OPTS_TYPE_PT_ADDBITS14
8961 | OPTS_TYPE_PT_UNICODE;
8962 kern_type = KERN_TYPE_NETNTLMv2;
8963 dgst_size = DGST_SIZE_4_4;
8964 parse_func = netntlmv2_parse_hash;
8965 sort_by_digest = sort_by_digest_4_4;
8966 opti_type = OPTI_TYPE_ZERO_BYTE;
8967 dgst_pos0 = 0;
8968 dgst_pos1 = 3;
8969 dgst_pos2 = 2;
8970 dgst_pos3 = 1;
8971 break;
8972
8973 case 5700: hash_type = HASH_TYPE_SHA256;
8974 salt_type = SALT_TYPE_NONE;
8975 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8976 opts_type = OPTS_TYPE_PT_GENERATE_BE
8977 | OPTS_TYPE_PT_ADD80
8978 | OPTS_TYPE_PT_ADDBITS15;
8979 kern_type = KERN_TYPE_SHA256;
8980 dgst_size = DGST_SIZE_4_8;
8981 parse_func = cisco4_parse_hash;
8982 sort_by_digest = sort_by_digest_4_8;
8983 opti_type = OPTI_TYPE_ZERO_BYTE
8984 | OPTI_TYPE_PRECOMPUTE_INIT
8985 | OPTI_TYPE_PRECOMPUTE_MERKLE
8986 | OPTI_TYPE_EARLY_SKIP
8987 | OPTI_TYPE_NOT_ITERATED
8988 | OPTI_TYPE_NOT_SALTED
8989 | OPTI_TYPE_RAW_HASH;
8990 dgst_pos0 = 3;
8991 dgst_pos1 = 7;
8992 dgst_pos2 = 2;
8993 dgst_pos3 = 6;
8994 break;
8995
8996 case 5800: hash_type = HASH_TYPE_SHA1;
8997 salt_type = SALT_TYPE_INTERN;
8998 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8999 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9000 | OPTS_TYPE_ST_ADD80;
9001 kern_type = KERN_TYPE_ANDROIDPIN;
9002 dgst_size = DGST_SIZE_4_5;
9003 parse_func = androidpin_parse_hash;
9004 sort_by_digest = sort_by_digest_4_5;
9005 opti_type = OPTI_TYPE_ZERO_BYTE;
9006 dgst_pos0 = 0;
9007 dgst_pos1 = 1;
9008 dgst_pos2 = 2;
9009 dgst_pos3 = 3;
9010 break;
9011
9012 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9013 salt_type = SALT_TYPE_NONE;
9014 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9015 opts_type = OPTS_TYPE_PT_GENERATE_LE
9016 | OPTS_TYPE_PT_ADD80;
9017 kern_type = KERN_TYPE_RIPEMD160;
9018 dgst_size = DGST_SIZE_4_5;
9019 parse_func = ripemd160_parse_hash;
9020 sort_by_digest = sort_by_digest_4_5;
9021 opti_type = OPTI_TYPE_ZERO_BYTE;
9022 dgst_pos0 = 0;
9023 dgst_pos1 = 1;
9024 dgst_pos2 = 2;
9025 dgst_pos3 = 3;
9026 break;
9027
9028 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9029 salt_type = SALT_TYPE_NONE;
9030 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9031 opts_type = OPTS_TYPE_PT_GENERATE_BE
9032 | OPTS_TYPE_PT_ADD80;
9033 kern_type = KERN_TYPE_WHIRLPOOL;
9034 dgst_size = DGST_SIZE_4_16;
9035 parse_func = whirlpool_parse_hash;
9036 sort_by_digest = sort_by_digest_4_16;
9037 opti_type = OPTI_TYPE_ZERO_BYTE;
9038 dgst_pos0 = 0;
9039 dgst_pos1 = 1;
9040 dgst_pos2 = 2;
9041 dgst_pos3 = 3;
9042 break;
9043
9044 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9045 salt_type = SALT_TYPE_EMBEDDED;
9046 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9047 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9048 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9049 dgst_size = DGST_SIZE_4_5;
9050 parse_func = truecrypt_parse_hash_2k;
9051 sort_by_digest = sort_by_digest_4_5;
9052 opti_type = OPTI_TYPE_ZERO_BYTE;
9053 dgst_pos0 = 0;
9054 dgst_pos1 = 1;
9055 dgst_pos2 = 2;
9056 dgst_pos3 = 3;
9057 break;
9058
9059 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9060 salt_type = SALT_TYPE_EMBEDDED;
9061 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9062 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9063 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9064 dgst_size = DGST_SIZE_4_5;
9065 parse_func = truecrypt_parse_hash_2k;
9066 sort_by_digest = sort_by_digest_4_5;
9067 opti_type = OPTI_TYPE_ZERO_BYTE;
9068 dgst_pos0 = 0;
9069 dgst_pos1 = 1;
9070 dgst_pos2 = 2;
9071 dgst_pos3 = 3;
9072 break;
9073
9074 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9075 salt_type = SALT_TYPE_EMBEDDED;
9076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9077 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9078 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9079 dgst_size = DGST_SIZE_4_5;
9080 parse_func = truecrypt_parse_hash_2k;
9081 sort_by_digest = sort_by_digest_4_5;
9082 opti_type = OPTI_TYPE_ZERO_BYTE;
9083 dgst_pos0 = 0;
9084 dgst_pos1 = 1;
9085 dgst_pos2 = 2;
9086 dgst_pos3 = 3;
9087 break;
9088
9089 case 6221: hash_type = HASH_TYPE_SHA512;
9090 salt_type = SALT_TYPE_EMBEDDED;
9091 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9092 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9093 kern_type = KERN_TYPE_TCSHA512_XTS512;
9094 dgst_size = DGST_SIZE_8_8;
9095 parse_func = truecrypt_parse_hash_1k;
9096 sort_by_digest = sort_by_digest_8_8;
9097 opti_type = OPTI_TYPE_ZERO_BYTE
9098 | OPTI_TYPE_USES_BITS_64;
9099 dgst_pos0 = 0;
9100 dgst_pos1 = 1;
9101 dgst_pos2 = 2;
9102 dgst_pos3 = 3;
9103 break;
9104
9105 case 6222: hash_type = HASH_TYPE_SHA512;
9106 salt_type = SALT_TYPE_EMBEDDED;
9107 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9108 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9109 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9110 dgst_size = DGST_SIZE_8_8;
9111 parse_func = truecrypt_parse_hash_1k;
9112 sort_by_digest = sort_by_digest_8_8;
9113 opti_type = OPTI_TYPE_ZERO_BYTE
9114 | OPTI_TYPE_USES_BITS_64;
9115 dgst_pos0 = 0;
9116 dgst_pos1 = 1;
9117 dgst_pos2 = 2;
9118 dgst_pos3 = 3;
9119 break;
9120
9121 case 6223: hash_type = HASH_TYPE_SHA512;
9122 salt_type = SALT_TYPE_EMBEDDED;
9123 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9124 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9125 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9126 dgst_size = DGST_SIZE_8_8;
9127 parse_func = truecrypt_parse_hash_1k;
9128 sort_by_digest = sort_by_digest_8_8;
9129 opti_type = OPTI_TYPE_ZERO_BYTE
9130 | OPTI_TYPE_USES_BITS_64;
9131 dgst_pos0 = 0;
9132 dgst_pos1 = 1;
9133 dgst_pos2 = 2;
9134 dgst_pos3 = 3;
9135 break;
9136
9137 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9138 salt_type = SALT_TYPE_EMBEDDED;
9139 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9140 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9141 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9142 dgst_size = DGST_SIZE_4_8;
9143 parse_func = truecrypt_parse_hash_1k;
9144 sort_by_digest = sort_by_digest_4_8;
9145 opti_type = OPTI_TYPE_ZERO_BYTE;
9146 dgst_pos0 = 0;
9147 dgst_pos1 = 1;
9148 dgst_pos2 = 2;
9149 dgst_pos3 = 3;
9150 break;
9151
9152 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9153 salt_type = SALT_TYPE_EMBEDDED;
9154 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9155 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9156 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9157 dgst_size = DGST_SIZE_4_8;
9158 parse_func = truecrypt_parse_hash_1k;
9159 sort_by_digest = sort_by_digest_4_8;
9160 opti_type = OPTI_TYPE_ZERO_BYTE;
9161 dgst_pos0 = 0;
9162 dgst_pos1 = 1;
9163 dgst_pos2 = 2;
9164 dgst_pos3 = 3;
9165 break;
9166
9167 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9168 salt_type = SALT_TYPE_EMBEDDED;
9169 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9170 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9171 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9172 dgst_size = DGST_SIZE_4_8;
9173 parse_func = truecrypt_parse_hash_1k;
9174 sort_by_digest = sort_by_digest_4_8;
9175 opti_type = OPTI_TYPE_ZERO_BYTE;
9176 dgst_pos0 = 0;
9177 dgst_pos1 = 1;
9178 dgst_pos2 = 2;
9179 dgst_pos3 = 3;
9180 break;
9181
9182 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9183 salt_type = SALT_TYPE_EMBEDDED;
9184 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9185 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9186 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9187 dgst_size = DGST_SIZE_4_5;
9188 parse_func = truecrypt_parse_hash_1k;
9189 sort_by_digest = sort_by_digest_4_5;
9190 opti_type = OPTI_TYPE_ZERO_BYTE;
9191 dgst_pos0 = 0;
9192 dgst_pos1 = 1;
9193 dgst_pos2 = 2;
9194 dgst_pos3 = 3;
9195 break;
9196
9197 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9198 salt_type = SALT_TYPE_EMBEDDED;
9199 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9200 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9201 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9202 dgst_size = DGST_SIZE_4_5;
9203 parse_func = truecrypt_parse_hash_1k;
9204 sort_by_digest = sort_by_digest_4_5;
9205 opti_type = OPTI_TYPE_ZERO_BYTE;
9206 dgst_pos0 = 0;
9207 dgst_pos1 = 1;
9208 dgst_pos2 = 2;
9209 dgst_pos3 = 3;
9210 break;
9211
9212 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9213 salt_type = SALT_TYPE_EMBEDDED;
9214 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9215 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9216 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9217 dgst_size = DGST_SIZE_4_5;
9218 parse_func = truecrypt_parse_hash_1k;
9219 sort_by_digest = sort_by_digest_4_5;
9220 opti_type = OPTI_TYPE_ZERO_BYTE;
9221 dgst_pos0 = 0;
9222 dgst_pos1 = 1;
9223 dgst_pos2 = 2;
9224 dgst_pos3 = 3;
9225 break;
9226
9227 case 6300: hash_type = HASH_TYPE_MD5;
9228 salt_type = SALT_TYPE_EMBEDDED;
9229 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9230 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9231 kern_type = KERN_TYPE_MD5AIX;
9232 dgst_size = DGST_SIZE_4_4;
9233 parse_func = md5aix_parse_hash;
9234 sort_by_digest = sort_by_digest_4_4;
9235 opti_type = OPTI_TYPE_ZERO_BYTE;
9236 dgst_pos0 = 0;
9237 dgst_pos1 = 1;
9238 dgst_pos2 = 2;
9239 dgst_pos3 = 3;
9240 break;
9241
9242 case 6400: hash_type = HASH_TYPE_SHA256;
9243 salt_type = SALT_TYPE_EMBEDDED;
9244 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9245 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9246 kern_type = KERN_TYPE_SHA256AIX;
9247 dgst_size = DGST_SIZE_4_8;
9248 parse_func = sha256aix_parse_hash;
9249 sort_by_digest = sort_by_digest_4_8;
9250 opti_type = OPTI_TYPE_ZERO_BYTE;
9251 dgst_pos0 = 0;
9252 dgst_pos1 = 1;
9253 dgst_pos2 = 2;
9254 dgst_pos3 = 3;
9255 break;
9256
9257 case 6500: hash_type = HASH_TYPE_SHA512;
9258 salt_type = SALT_TYPE_EMBEDDED;
9259 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9260 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9261 kern_type = KERN_TYPE_SHA512AIX;
9262 dgst_size = DGST_SIZE_8_8;
9263 parse_func = sha512aix_parse_hash;
9264 sort_by_digest = sort_by_digest_8_8;
9265 opti_type = OPTI_TYPE_ZERO_BYTE
9266 | OPTI_TYPE_USES_BITS_64;
9267 dgst_pos0 = 0;
9268 dgst_pos1 = 1;
9269 dgst_pos2 = 2;
9270 dgst_pos3 = 3;
9271 break;
9272
9273 case 6600: hash_type = HASH_TYPE_AES;
9274 salt_type = SALT_TYPE_EMBEDDED;
9275 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9276 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9277 kern_type = KERN_TYPE_AGILEKEY;
9278 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9279 parse_func = agilekey_parse_hash;
9280 sort_by_digest = sort_by_digest_4_5;
9281 opti_type = OPTI_TYPE_ZERO_BYTE;
9282 dgst_pos0 = 0;
9283 dgst_pos1 = 1;
9284 dgst_pos2 = 2;
9285 dgst_pos3 = 3;
9286 break;
9287
9288 case 6700: hash_type = HASH_TYPE_SHA1;
9289 salt_type = SALT_TYPE_EMBEDDED;
9290 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9291 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9292 kern_type = KERN_TYPE_SHA1AIX;
9293 dgst_size = DGST_SIZE_4_5;
9294 parse_func = sha1aix_parse_hash;
9295 sort_by_digest = sort_by_digest_4_5;
9296 opti_type = OPTI_TYPE_ZERO_BYTE;
9297 dgst_pos0 = 0;
9298 dgst_pos1 = 1;
9299 dgst_pos2 = 2;
9300 dgst_pos3 = 3;
9301 break;
9302
9303 case 6800: hash_type = HASH_TYPE_AES;
9304 salt_type = SALT_TYPE_EMBEDDED;
9305 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9306 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9307 kern_type = KERN_TYPE_LASTPASS;
9308 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9309 parse_func = lastpass_parse_hash;
9310 sort_by_digest = sort_by_digest_4_8;
9311 opti_type = OPTI_TYPE_ZERO_BYTE;
9312 dgst_pos0 = 0;
9313 dgst_pos1 = 1;
9314 dgst_pos2 = 2;
9315 dgst_pos3 = 3;
9316 break;
9317
9318 case 6900: hash_type = HASH_TYPE_GOST;
9319 salt_type = SALT_TYPE_NONE;
9320 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9321 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9322 kern_type = KERN_TYPE_GOST;
9323 dgst_size = DGST_SIZE_4_8;
9324 parse_func = gost_parse_hash;
9325 sort_by_digest = sort_by_digest_4_8;
9326 opti_type = OPTI_TYPE_ZERO_BYTE;
9327 dgst_pos0 = 0;
9328 dgst_pos1 = 1;
9329 dgst_pos2 = 2;
9330 dgst_pos3 = 3;
9331 break;
9332
9333 case 7100: hash_type = HASH_TYPE_SHA512;
9334 salt_type = SALT_TYPE_EMBEDDED;
9335 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9336 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9337 kern_type = KERN_TYPE_PBKDF2_SHA512;
9338 dgst_size = DGST_SIZE_8_16;
9339 parse_func = sha512osx_parse_hash;
9340 sort_by_digest = sort_by_digest_8_16;
9341 opti_type = OPTI_TYPE_ZERO_BYTE
9342 | OPTI_TYPE_USES_BITS_64
9343 | OPTI_TYPE_SLOW_HASH_SIMD;
9344 dgst_pos0 = 0;
9345 dgst_pos1 = 1;
9346 dgst_pos2 = 2;
9347 dgst_pos3 = 3;
9348 break;
9349
9350 case 7200: hash_type = HASH_TYPE_SHA512;
9351 salt_type = SALT_TYPE_EMBEDDED;
9352 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9353 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9354 kern_type = KERN_TYPE_PBKDF2_SHA512;
9355 dgst_size = DGST_SIZE_8_16;
9356 parse_func = sha512grub_parse_hash;
9357 sort_by_digest = sort_by_digest_8_16;
9358 opti_type = OPTI_TYPE_ZERO_BYTE
9359 | OPTI_TYPE_USES_BITS_64
9360 | OPTI_TYPE_SLOW_HASH_SIMD;
9361 dgst_pos0 = 0;
9362 dgst_pos1 = 1;
9363 dgst_pos2 = 2;
9364 dgst_pos3 = 3;
9365 break;
9366
9367 case 7300: hash_type = HASH_TYPE_SHA1;
9368 salt_type = SALT_TYPE_EMBEDDED;
9369 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9370 opts_type = OPTS_TYPE_PT_GENERATE_BE
9371 | OPTS_TYPE_ST_ADD80
9372 | OPTS_TYPE_ST_ADDBITS15;
9373 kern_type = KERN_TYPE_RAKP;
9374 dgst_size = DGST_SIZE_4_5;
9375 parse_func = rakp_parse_hash;
9376 sort_by_digest = sort_by_digest_4_5;
9377 opti_type = OPTI_TYPE_ZERO_BYTE
9378 | OPTI_TYPE_NOT_ITERATED;
9379 dgst_pos0 = 3;
9380 dgst_pos1 = 4;
9381 dgst_pos2 = 2;
9382 dgst_pos3 = 1;
9383 break;
9384
9385 case 7400: hash_type = HASH_TYPE_SHA256;
9386 salt_type = SALT_TYPE_EMBEDDED;
9387 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9388 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9389 kern_type = KERN_TYPE_SHA256CRYPT;
9390 dgst_size = DGST_SIZE_4_8;
9391 parse_func = sha256crypt_parse_hash;
9392 sort_by_digest = sort_by_digest_4_8;
9393 opti_type = OPTI_TYPE_ZERO_BYTE;
9394 dgst_pos0 = 0;
9395 dgst_pos1 = 1;
9396 dgst_pos2 = 2;
9397 dgst_pos3 = 3;
9398 break;
9399
9400 case 7500: hash_type = HASH_TYPE_KRB5PA;
9401 salt_type = SALT_TYPE_EMBEDDED;
9402 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9403 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9404 kern_type = KERN_TYPE_KRB5PA;
9405 dgst_size = DGST_SIZE_4_4;
9406 parse_func = krb5pa_parse_hash;
9407 sort_by_digest = sort_by_digest_4_4;
9408 opti_type = OPTI_TYPE_ZERO_BYTE
9409 | OPTI_TYPE_NOT_ITERATED;
9410 dgst_pos0 = 0;
9411 dgst_pos1 = 1;
9412 dgst_pos2 = 2;
9413 dgst_pos3 = 3;
9414 break;
9415
9416 case 7600: hash_type = HASH_TYPE_SHA1;
9417 salt_type = SALT_TYPE_INTERN;
9418 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9419 opts_type = OPTS_TYPE_PT_GENERATE_BE
9420 | OPTS_TYPE_PT_ADD80
9421 | OPTS_TYPE_PT_ADDBITS15;
9422 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9423 dgst_size = DGST_SIZE_4_5;
9424 parse_func = redmine_parse_hash;
9425 sort_by_digest = sort_by_digest_4_5;
9426 opti_type = OPTI_TYPE_ZERO_BYTE
9427 | OPTI_TYPE_PRECOMPUTE_INIT
9428 | OPTI_TYPE_EARLY_SKIP
9429 | OPTI_TYPE_NOT_ITERATED
9430 | OPTI_TYPE_PREPENDED_SALT;
9431 dgst_pos0 = 3;
9432 dgst_pos1 = 4;
9433 dgst_pos2 = 2;
9434 dgst_pos3 = 1;
9435 break;
9436
9437 case 7700: hash_type = HASH_TYPE_SAPB;
9438 salt_type = SALT_TYPE_EMBEDDED;
9439 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9440 opts_type = OPTS_TYPE_PT_GENERATE_LE
9441 | OPTS_TYPE_PT_UPPER
9442 | OPTS_TYPE_ST_UPPER;
9443 kern_type = KERN_TYPE_SAPB;
9444 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9445 parse_func = sapb_parse_hash;
9446 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9447 opti_type = OPTI_TYPE_ZERO_BYTE
9448 | OPTI_TYPE_PRECOMPUTE_INIT
9449 | OPTI_TYPE_NOT_ITERATED;
9450 dgst_pos0 = 0;
9451 dgst_pos1 = 1;
9452 dgst_pos2 = 2;
9453 dgst_pos3 = 3;
9454 break;
9455
9456 case 7800: hash_type = HASH_TYPE_SAPG;
9457 salt_type = SALT_TYPE_EMBEDDED;
9458 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9459 opts_type = OPTS_TYPE_PT_GENERATE_BE
9460 | OPTS_TYPE_ST_ADD80
9461 | OPTS_TYPE_ST_UPPER;
9462 kern_type = KERN_TYPE_SAPG;
9463 dgst_size = DGST_SIZE_4_5;
9464 parse_func = sapg_parse_hash;
9465 sort_by_digest = sort_by_digest_4_5;
9466 opti_type = OPTI_TYPE_ZERO_BYTE
9467 | OPTI_TYPE_PRECOMPUTE_INIT
9468 | OPTI_TYPE_NOT_ITERATED;
9469 dgst_pos0 = 3;
9470 dgst_pos1 = 4;
9471 dgst_pos2 = 2;
9472 dgst_pos3 = 1;
9473 break;
9474
9475 case 7900: hash_type = HASH_TYPE_SHA512;
9476 salt_type = SALT_TYPE_EMBEDDED;
9477 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9478 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9479 kern_type = KERN_TYPE_DRUPAL7;
9480 dgst_size = DGST_SIZE_8_8;
9481 parse_func = drupal7_parse_hash;
9482 sort_by_digest = sort_by_digest_8_8;
9483 opti_type = OPTI_TYPE_ZERO_BYTE
9484 | OPTI_TYPE_USES_BITS_64;
9485 dgst_pos0 = 0;
9486 dgst_pos1 = 1;
9487 dgst_pos2 = 2;
9488 dgst_pos3 = 3;
9489 break;
9490
9491 case 8000: hash_type = HASH_TYPE_SHA256;
9492 salt_type = SALT_TYPE_EMBEDDED;
9493 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9494 opts_type = OPTS_TYPE_PT_GENERATE_BE
9495 | OPTS_TYPE_PT_UNICODE
9496 | OPTS_TYPE_ST_ADD80
9497 | OPTS_TYPE_ST_HEX;
9498 kern_type = KERN_TYPE_SYBASEASE;
9499 dgst_size = DGST_SIZE_4_8;
9500 parse_func = sybasease_parse_hash;
9501 sort_by_digest = sort_by_digest_4_8;
9502 opti_type = OPTI_TYPE_ZERO_BYTE
9503 | OPTI_TYPE_PRECOMPUTE_INIT
9504 | OPTI_TYPE_EARLY_SKIP
9505 | OPTI_TYPE_NOT_ITERATED
9506 | OPTI_TYPE_RAW_HASH;
9507 dgst_pos0 = 3;
9508 dgst_pos1 = 7;
9509 dgst_pos2 = 2;
9510 dgst_pos3 = 6;
9511 break;
9512
9513 case 8100: hash_type = HASH_TYPE_SHA1;
9514 salt_type = SALT_TYPE_EMBEDDED;
9515 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9516 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9517 kern_type = KERN_TYPE_NETSCALER;
9518 dgst_size = DGST_SIZE_4_5;
9519 parse_func = netscaler_parse_hash;
9520 sort_by_digest = sort_by_digest_4_5;
9521 opti_type = OPTI_TYPE_ZERO_BYTE
9522 | OPTI_TYPE_PRECOMPUTE_INIT
9523 | OPTI_TYPE_PRECOMPUTE_MERKLE
9524 | OPTI_TYPE_EARLY_SKIP
9525 | OPTI_TYPE_NOT_ITERATED
9526 | OPTI_TYPE_PREPENDED_SALT
9527 | OPTI_TYPE_RAW_HASH;
9528 dgst_pos0 = 3;
9529 dgst_pos1 = 4;
9530 dgst_pos2 = 2;
9531 dgst_pos3 = 1;
9532 break;
9533
9534 case 8200: hash_type = HASH_TYPE_SHA256;
9535 salt_type = SALT_TYPE_EMBEDDED;
9536 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9537 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9538 kern_type = KERN_TYPE_CLOUDKEY;
9539 dgst_size = DGST_SIZE_4_8;
9540 parse_func = cloudkey_parse_hash;
9541 sort_by_digest = sort_by_digest_4_8;
9542 opti_type = OPTI_TYPE_ZERO_BYTE;
9543 dgst_pos0 = 0;
9544 dgst_pos1 = 1;
9545 dgst_pos2 = 2;
9546 dgst_pos3 = 3;
9547 break;
9548
9549 case 8300: hash_type = HASH_TYPE_SHA1;
9550 salt_type = SALT_TYPE_EMBEDDED;
9551 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9552 opts_type = OPTS_TYPE_PT_GENERATE_BE
9553 | OPTS_TYPE_ST_HEX
9554 | OPTS_TYPE_ST_ADD80;
9555 kern_type = KERN_TYPE_NSEC3;
9556 dgst_size = DGST_SIZE_4_5;
9557 parse_func = nsec3_parse_hash;
9558 sort_by_digest = sort_by_digest_4_5;
9559 opti_type = OPTI_TYPE_ZERO_BYTE;
9560 dgst_pos0 = 3;
9561 dgst_pos1 = 4;
9562 dgst_pos2 = 2;
9563 dgst_pos3 = 1;
9564 break;
9565
9566 case 8400: hash_type = HASH_TYPE_SHA1;
9567 salt_type = SALT_TYPE_INTERN;
9568 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9569 opts_type = OPTS_TYPE_PT_GENERATE_BE
9570 | OPTS_TYPE_PT_ADD80
9571 | OPTS_TYPE_PT_ADDBITS15;
9572 kern_type = KERN_TYPE_WBB3;
9573 dgst_size = DGST_SIZE_4_5;
9574 parse_func = wbb3_parse_hash;
9575 sort_by_digest = sort_by_digest_4_5;
9576 opti_type = OPTI_TYPE_ZERO_BYTE
9577 | OPTI_TYPE_PRECOMPUTE_INIT
9578 | OPTI_TYPE_NOT_ITERATED;
9579 dgst_pos0 = 3;
9580 dgst_pos1 = 4;
9581 dgst_pos2 = 2;
9582 dgst_pos3 = 1;
9583 break;
9584
9585 case 8500: hash_type = HASH_TYPE_DESRACF;
9586 salt_type = SALT_TYPE_EMBEDDED;
9587 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9588 opts_type = OPTS_TYPE_PT_GENERATE_LE
9589 | OPTS_TYPE_ST_UPPER;
9590 kern_type = KERN_TYPE_RACF;
9591 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9592 parse_func = racf_parse_hash;
9593 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9594 opti_type = OPTI_TYPE_ZERO_BYTE
9595 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9596 dgst_pos0 = 0;
9597 dgst_pos1 = 1;
9598 dgst_pos2 = 2;
9599 dgst_pos3 = 3;
9600 break;
9601
9602 case 8600: hash_type = HASH_TYPE_LOTUS5;
9603 salt_type = SALT_TYPE_NONE;
9604 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9605 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9606 kern_type = KERN_TYPE_LOTUS5;
9607 dgst_size = DGST_SIZE_4_4;
9608 parse_func = lotus5_parse_hash;
9609 sort_by_digest = sort_by_digest_4_4;
9610 opti_type = OPTI_TYPE_EARLY_SKIP
9611 | OPTI_TYPE_NOT_ITERATED
9612 | OPTI_TYPE_NOT_SALTED
9613 | OPTI_TYPE_RAW_HASH;
9614 dgst_pos0 = 0;
9615 dgst_pos1 = 1;
9616 dgst_pos2 = 2;
9617 dgst_pos3 = 3;
9618 break;
9619
9620 case 8700: hash_type = HASH_TYPE_LOTUS6;
9621 salt_type = SALT_TYPE_EMBEDDED;
9622 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9623 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9624 kern_type = KERN_TYPE_LOTUS6;
9625 dgst_size = DGST_SIZE_4_4;
9626 parse_func = lotus6_parse_hash;
9627 sort_by_digest = sort_by_digest_4_4;
9628 opti_type = OPTI_TYPE_EARLY_SKIP
9629 | OPTI_TYPE_NOT_ITERATED
9630 | OPTI_TYPE_RAW_HASH;
9631 dgst_pos0 = 0;
9632 dgst_pos1 = 1;
9633 dgst_pos2 = 2;
9634 dgst_pos3 = 3;
9635 break;
9636
9637 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9638 salt_type = SALT_TYPE_EMBEDDED;
9639 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9640 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9641 kern_type = KERN_TYPE_ANDROIDFDE;
9642 dgst_size = DGST_SIZE_4_4;
9643 parse_func = androidfde_parse_hash;
9644 sort_by_digest = sort_by_digest_4_4;
9645 opti_type = OPTI_TYPE_ZERO_BYTE;
9646 dgst_pos0 = 0;
9647 dgst_pos1 = 1;
9648 dgst_pos2 = 2;
9649 dgst_pos3 = 3;
9650 break;
9651
9652 case 8900: hash_type = HASH_TYPE_SCRYPT;
9653 salt_type = SALT_TYPE_EMBEDDED;
9654 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9655 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9656 kern_type = KERN_TYPE_SCRYPT;
9657 dgst_size = DGST_SIZE_4_8;
9658 parse_func = scrypt_parse_hash;
9659 sort_by_digest = sort_by_digest_4_8;
9660 opti_type = OPTI_TYPE_ZERO_BYTE;
9661 dgst_pos0 = 0;
9662 dgst_pos1 = 1;
9663 dgst_pos2 = 2;
9664 dgst_pos3 = 3;
9665 break;
9666
9667 case 9000: hash_type = HASH_TYPE_SHA1;
9668 salt_type = SALT_TYPE_EMBEDDED;
9669 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9670 opts_type = OPTS_TYPE_PT_GENERATE_LE
9671 | OPTS_TYPE_ST_GENERATE_LE;
9672 kern_type = KERN_TYPE_PSAFE2;
9673 dgst_size = DGST_SIZE_4_5;
9674 parse_func = psafe2_parse_hash;
9675 sort_by_digest = sort_by_digest_4_5;
9676 opti_type = OPTI_TYPE_ZERO_BYTE;
9677 dgst_pos0 = 0;
9678 dgst_pos1 = 1;
9679 dgst_pos2 = 2;
9680 dgst_pos3 = 3;
9681 break;
9682
9683 case 9100: hash_type = HASH_TYPE_LOTUS8;
9684 salt_type = SALT_TYPE_EMBEDDED;
9685 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9686 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9687 kern_type = KERN_TYPE_LOTUS8;
9688 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9689 parse_func = lotus8_parse_hash;
9690 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9691 opti_type = OPTI_TYPE_ZERO_BYTE;
9692 dgst_pos0 = 0;
9693 dgst_pos1 = 1;
9694 dgst_pos2 = 2;
9695 dgst_pos3 = 3;
9696 break;
9697
9698 case 9200: hash_type = HASH_TYPE_SHA256;
9699 salt_type = SALT_TYPE_EMBEDDED;
9700 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9701 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9702 kern_type = KERN_TYPE_PBKDF2_SHA256;
9703 dgst_size = DGST_SIZE_4_32;
9704 parse_func = cisco8_parse_hash;
9705 sort_by_digest = sort_by_digest_4_32;
9706 opti_type = OPTI_TYPE_ZERO_BYTE
9707 | OPTI_TYPE_SLOW_HASH_SIMD;
9708 dgst_pos0 = 0;
9709 dgst_pos1 = 1;
9710 dgst_pos2 = 2;
9711 dgst_pos3 = 3;
9712 break;
9713
9714 case 9300: hash_type = HASH_TYPE_SCRYPT;
9715 salt_type = SALT_TYPE_EMBEDDED;
9716 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9717 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9718 kern_type = KERN_TYPE_SCRYPT;
9719 dgst_size = DGST_SIZE_4_8;
9720 parse_func = cisco9_parse_hash;
9721 sort_by_digest = sort_by_digest_4_8;
9722 opti_type = OPTI_TYPE_ZERO_BYTE;
9723 dgst_pos0 = 0;
9724 dgst_pos1 = 1;
9725 dgst_pos2 = 2;
9726 dgst_pos3 = 3;
9727 break;
9728
9729 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9730 salt_type = SALT_TYPE_EMBEDDED;
9731 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9732 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9733 kern_type = KERN_TYPE_OFFICE2007;
9734 dgst_size = DGST_SIZE_4_4;
9735 parse_func = office2007_parse_hash;
9736 sort_by_digest = sort_by_digest_4_4;
9737 opti_type = OPTI_TYPE_ZERO_BYTE;
9738 dgst_pos0 = 0;
9739 dgst_pos1 = 1;
9740 dgst_pos2 = 2;
9741 dgst_pos3 = 3;
9742 break;
9743
9744 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9745 salt_type = SALT_TYPE_EMBEDDED;
9746 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9747 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9748 kern_type = KERN_TYPE_OFFICE2010;
9749 dgst_size = DGST_SIZE_4_4;
9750 parse_func = office2010_parse_hash;
9751 sort_by_digest = sort_by_digest_4_4;
9752 opti_type = OPTI_TYPE_ZERO_BYTE;
9753 dgst_pos0 = 0;
9754 dgst_pos1 = 1;
9755 dgst_pos2 = 2;
9756 dgst_pos3 = 3;
9757 break;
9758
9759 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9760 salt_type = SALT_TYPE_EMBEDDED;
9761 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9762 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9763 kern_type = KERN_TYPE_OFFICE2013;
9764 dgst_size = DGST_SIZE_4_4;
9765 parse_func = office2013_parse_hash;
9766 sort_by_digest = sort_by_digest_4_4;
9767 opti_type = OPTI_TYPE_ZERO_BYTE;
9768 dgst_pos0 = 0;
9769 dgst_pos1 = 1;
9770 dgst_pos2 = 2;
9771 dgst_pos3 = 3;
9772 break;
9773
9774 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9775 salt_type = SALT_TYPE_EMBEDDED;
9776 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9777 opts_type = OPTS_TYPE_PT_GENERATE_LE
9778 | OPTS_TYPE_PT_ADD80
9779 | OPTS_TYPE_PT_UNICODE;
9780 kern_type = KERN_TYPE_OLDOFFICE01;
9781 dgst_size = DGST_SIZE_4_4;
9782 parse_func = oldoffice01_parse_hash;
9783 sort_by_digest = sort_by_digest_4_4;
9784 opti_type = OPTI_TYPE_ZERO_BYTE
9785 | OPTI_TYPE_PRECOMPUTE_INIT
9786 | OPTI_TYPE_NOT_ITERATED;
9787 dgst_pos0 = 0;
9788 dgst_pos1 = 1;
9789 dgst_pos2 = 2;
9790 dgst_pos3 = 3;
9791 break;
9792
9793 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9794 salt_type = SALT_TYPE_EMBEDDED;
9795 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9796 opts_type = OPTS_TYPE_PT_GENERATE_LE
9797 | OPTS_TYPE_PT_ADD80;
9798 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9799 dgst_size = DGST_SIZE_4_4;
9800 parse_func = oldoffice01cm1_parse_hash;
9801 sort_by_digest = sort_by_digest_4_4;
9802 opti_type = OPTI_TYPE_ZERO_BYTE
9803 | OPTI_TYPE_PRECOMPUTE_INIT
9804 | OPTI_TYPE_NOT_ITERATED;
9805 dgst_pos0 = 0;
9806 dgst_pos1 = 1;
9807 dgst_pos2 = 2;
9808 dgst_pos3 = 3;
9809 break;
9810
9811 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9812 salt_type = SALT_TYPE_EMBEDDED;
9813 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9814 opts_type = OPTS_TYPE_PT_GENERATE_LE
9815 | OPTS_TYPE_PT_ADD80
9816 | OPTS_TYPE_PT_UNICODE
9817 | OPTS_TYPE_PT_NEVERCRACK;
9818 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9819 dgst_size = DGST_SIZE_4_4;
9820 parse_func = oldoffice01cm2_parse_hash;
9821 sort_by_digest = sort_by_digest_4_4;
9822 opti_type = OPTI_TYPE_ZERO_BYTE
9823 | OPTI_TYPE_PRECOMPUTE_INIT
9824 | OPTI_TYPE_NOT_ITERATED;
9825 dgst_pos0 = 0;
9826 dgst_pos1 = 1;
9827 dgst_pos2 = 2;
9828 dgst_pos3 = 3;
9829 break;
9830
9831 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9832 salt_type = SALT_TYPE_EMBEDDED;
9833 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9834 opts_type = OPTS_TYPE_PT_GENERATE_BE
9835 | OPTS_TYPE_PT_ADD80
9836 | OPTS_TYPE_PT_UNICODE;
9837 kern_type = KERN_TYPE_OLDOFFICE34;
9838 dgst_size = DGST_SIZE_4_4;
9839 parse_func = oldoffice34_parse_hash;
9840 sort_by_digest = sort_by_digest_4_4;
9841 opti_type = OPTI_TYPE_ZERO_BYTE
9842 | OPTI_TYPE_PRECOMPUTE_INIT
9843 | OPTI_TYPE_NOT_ITERATED;
9844 dgst_pos0 = 0;
9845 dgst_pos1 = 1;
9846 dgst_pos2 = 2;
9847 dgst_pos3 = 3;
9848 break;
9849
9850 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9851 salt_type = SALT_TYPE_EMBEDDED;
9852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9853 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9854 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9855 dgst_size = DGST_SIZE_4_4;
9856 parse_func = oldoffice34cm1_parse_hash;
9857 sort_by_digest = sort_by_digest_4_4;
9858 opti_type = OPTI_TYPE_ZERO_BYTE
9859 | OPTI_TYPE_PRECOMPUTE_INIT
9860 | OPTI_TYPE_NOT_ITERATED;
9861 dgst_pos0 = 0;
9862 dgst_pos1 = 1;
9863 dgst_pos2 = 2;
9864 dgst_pos3 = 3;
9865 break;
9866
9867 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9868 salt_type = SALT_TYPE_EMBEDDED;
9869 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9870 opts_type = OPTS_TYPE_PT_GENERATE_BE
9871 | OPTS_TYPE_PT_ADD80
9872 | OPTS_TYPE_PT_UNICODE
9873 | OPTS_TYPE_PT_NEVERCRACK;
9874 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9875 dgst_size = DGST_SIZE_4_4;
9876 parse_func = oldoffice34cm2_parse_hash;
9877 sort_by_digest = sort_by_digest_4_4;
9878 opti_type = OPTI_TYPE_ZERO_BYTE
9879 | OPTI_TYPE_PRECOMPUTE_INIT
9880 | OPTI_TYPE_NOT_ITERATED;
9881 dgst_pos0 = 0;
9882 dgst_pos1 = 1;
9883 dgst_pos2 = 2;
9884 dgst_pos3 = 3;
9885 break;
9886
9887 case 9900: hash_type = HASH_TYPE_MD5;
9888 salt_type = SALT_TYPE_NONE;
9889 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9890 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9891 kern_type = KERN_TYPE_RADMIN2;
9892 dgst_size = DGST_SIZE_4_4;
9893 parse_func = radmin2_parse_hash;
9894 sort_by_digest = sort_by_digest_4_4;
9895 opti_type = OPTI_TYPE_ZERO_BYTE
9896 | OPTI_TYPE_PRECOMPUTE_INIT
9897 | OPTI_TYPE_EARLY_SKIP
9898 | OPTI_TYPE_NOT_ITERATED
9899 | OPTI_TYPE_NOT_SALTED;
9900 dgst_pos0 = 0;
9901 dgst_pos1 = 3;
9902 dgst_pos2 = 2;
9903 dgst_pos3 = 1;
9904 break;
9905
9906 case 10000: hash_type = HASH_TYPE_SHA256;
9907 salt_type = SALT_TYPE_EMBEDDED;
9908 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9909 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9910 kern_type = KERN_TYPE_PBKDF2_SHA256;
9911 dgst_size = DGST_SIZE_4_32;
9912 parse_func = djangopbkdf2_parse_hash;
9913 sort_by_digest = sort_by_digest_4_32;
9914 opti_type = OPTI_TYPE_ZERO_BYTE
9915 | OPTI_TYPE_SLOW_HASH_SIMD;
9916 dgst_pos0 = 0;
9917 dgst_pos1 = 1;
9918 dgst_pos2 = 2;
9919 dgst_pos3 = 3;
9920 break;
9921
9922 case 10100: hash_type = HASH_TYPE_SIPHASH;
9923 salt_type = SALT_TYPE_EMBEDDED;
9924 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9925 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9926 kern_type = KERN_TYPE_SIPHASH;
9927 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9928 parse_func = siphash_parse_hash;
9929 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9930 opti_type = OPTI_TYPE_ZERO_BYTE
9931 | OPTI_TYPE_NOT_ITERATED
9932 | OPTI_TYPE_RAW_HASH;
9933 dgst_pos0 = 0;
9934 dgst_pos1 = 1;
9935 dgst_pos2 = 2;
9936 dgst_pos3 = 3;
9937 break;
9938
9939 case 10200: hash_type = HASH_TYPE_MD5;
9940 salt_type = SALT_TYPE_EMBEDDED;
9941 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9942 opts_type = OPTS_TYPE_PT_GENERATE_LE
9943 | OPTS_TYPE_ST_ADD80
9944 | OPTS_TYPE_ST_ADDBITS14;
9945 kern_type = KERN_TYPE_HMACMD5_PW;
9946 dgst_size = DGST_SIZE_4_4;
9947 parse_func = crammd5_parse_hash;
9948 sort_by_digest = sort_by_digest_4_4;
9949 opti_type = OPTI_TYPE_ZERO_BYTE
9950 | OPTI_TYPE_NOT_ITERATED;
9951 dgst_pos0 = 0;
9952 dgst_pos1 = 3;
9953 dgst_pos2 = 2;
9954 dgst_pos3 = 1;
9955 break;
9956
9957 case 10300: hash_type = HASH_TYPE_SHA1;
9958 salt_type = SALT_TYPE_EMBEDDED;
9959 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9960 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9961 kern_type = KERN_TYPE_SAPH_SHA1;
9962 dgst_size = DGST_SIZE_4_5;
9963 parse_func = saph_sha1_parse_hash;
9964 sort_by_digest = sort_by_digest_4_5;
9965 opti_type = OPTI_TYPE_ZERO_BYTE;
9966 dgst_pos0 = 0;
9967 dgst_pos1 = 1;
9968 dgst_pos2 = 2;
9969 dgst_pos3 = 3;
9970 break;
9971
9972 case 10400: hash_type = HASH_TYPE_PDFU16;
9973 salt_type = SALT_TYPE_EMBEDDED;
9974 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9975 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9976 kern_type = KERN_TYPE_PDF11;
9977 dgst_size = DGST_SIZE_4_4;
9978 parse_func = pdf11_parse_hash;
9979 sort_by_digest = sort_by_digest_4_4;
9980 opti_type = OPTI_TYPE_ZERO_BYTE
9981 | OPTI_TYPE_NOT_ITERATED;
9982 dgst_pos0 = 0;
9983 dgst_pos1 = 1;
9984 dgst_pos2 = 2;
9985 dgst_pos3 = 3;
9986 break;
9987
9988 case 10410: hash_type = HASH_TYPE_PDFU16;
9989 salt_type = SALT_TYPE_EMBEDDED;
9990 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9991 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9992 kern_type = KERN_TYPE_PDF11CM1;
9993 dgst_size = DGST_SIZE_4_4;
9994 parse_func = pdf11cm1_parse_hash;
9995 sort_by_digest = sort_by_digest_4_4;
9996 opti_type = OPTI_TYPE_ZERO_BYTE
9997 | OPTI_TYPE_NOT_ITERATED;
9998 dgst_pos0 = 0;
9999 dgst_pos1 = 1;
10000 dgst_pos2 = 2;
10001 dgst_pos3 = 3;
10002 break;
10003
10004 case 10420: hash_type = HASH_TYPE_PDFU16;
10005 salt_type = SALT_TYPE_EMBEDDED;
10006 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10007 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10008 kern_type = KERN_TYPE_PDF11CM2;
10009 dgst_size = DGST_SIZE_4_4;
10010 parse_func = pdf11cm2_parse_hash;
10011 sort_by_digest = sort_by_digest_4_4;
10012 opti_type = OPTI_TYPE_ZERO_BYTE
10013 | OPTI_TYPE_NOT_ITERATED;
10014 dgst_pos0 = 0;
10015 dgst_pos1 = 1;
10016 dgst_pos2 = 2;
10017 dgst_pos3 = 3;
10018 break;
10019
10020 case 10500: hash_type = HASH_TYPE_PDFU16;
10021 salt_type = SALT_TYPE_EMBEDDED;
10022 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10023 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10024 kern_type = KERN_TYPE_PDF14;
10025 dgst_size = DGST_SIZE_4_4;
10026 parse_func = pdf14_parse_hash;
10027 sort_by_digest = sort_by_digest_4_4;
10028 opti_type = OPTI_TYPE_ZERO_BYTE
10029 | OPTI_TYPE_NOT_ITERATED;
10030 dgst_pos0 = 0;
10031 dgst_pos1 = 1;
10032 dgst_pos2 = 2;
10033 dgst_pos3 = 3;
10034 break;
10035
10036 case 10600: hash_type = HASH_TYPE_SHA256;
10037 salt_type = SALT_TYPE_EMBEDDED;
10038 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10039 opts_type = OPTS_TYPE_PT_GENERATE_BE
10040 | OPTS_TYPE_ST_ADD80
10041 | OPTS_TYPE_ST_ADDBITS15
10042 | OPTS_TYPE_HASH_COPY;
10043 kern_type = KERN_TYPE_SHA256_PWSLT;
10044 dgst_size = DGST_SIZE_4_8;
10045 parse_func = pdf17l3_parse_hash;
10046 sort_by_digest = sort_by_digest_4_8;
10047 opti_type = OPTI_TYPE_ZERO_BYTE
10048 | OPTI_TYPE_PRECOMPUTE_INIT
10049 | OPTI_TYPE_PRECOMPUTE_MERKLE
10050 | OPTI_TYPE_EARLY_SKIP
10051 | OPTI_TYPE_NOT_ITERATED
10052 | OPTI_TYPE_APPENDED_SALT
10053 | OPTI_TYPE_RAW_HASH;
10054 dgst_pos0 = 3;
10055 dgst_pos1 = 7;
10056 dgst_pos2 = 2;
10057 dgst_pos3 = 6;
10058 break;
10059
10060 case 10700: hash_type = HASH_TYPE_PDFU32;
10061 salt_type = SALT_TYPE_EMBEDDED;
10062 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10063 opts_type = OPTS_TYPE_PT_GENERATE_LE
10064 | OPTS_TYPE_HASH_COPY;
10065 kern_type = KERN_TYPE_PDF17L8;
10066 dgst_size = DGST_SIZE_4_8;
10067 parse_func = pdf17l8_parse_hash;
10068 sort_by_digest = sort_by_digest_4_8;
10069 opti_type = OPTI_TYPE_ZERO_BYTE
10070 | OPTI_TYPE_NOT_ITERATED;
10071 dgst_pos0 = 0;
10072 dgst_pos1 = 1;
10073 dgst_pos2 = 2;
10074 dgst_pos3 = 3;
10075 break;
10076
10077 case 10800: hash_type = HASH_TYPE_SHA384;
10078 salt_type = SALT_TYPE_NONE;
10079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10080 opts_type = OPTS_TYPE_PT_GENERATE_BE
10081 | OPTS_TYPE_PT_ADD80
10082 | OPTS_TYPE_PT_ADDBITS15;
10083 kern_type = KERN_TYPE_SHA384;
10084 dgst_size = DGST_SIZE_8_8;
10085 parse_func = sha384_parse_hash;
10086 sort_by_digest = sort_by_digest_8_8;
10087 opti_type = OPTI_TYPE_ZERO_BYTE
10088 | OPTI_TYPE_PRECOMPUTE_INIT
10089 | OPTI_TYPE_PRECOMPUTE_MERKLE
10090 | OPTI_TYPE_EARLY_SKIP
10091 | OPTI_TYPE_NOT_ITERATED
10092 | OPTI_TYPE_NOT_SALTED
10093 | OPTI_TYPE_USES_BITS_64
10094 | OPTI_TYPE_RAW_HASH;
10095 dgst_pos0 = 6;
10096 dgst_pos1 = 7;
10097 dgst_pos2 = 4;
10098 dgst_pos3 = 5;
10099 break;
10100
10101 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10102 salt_type = SALT_TYPE_EMBEDDED;
10103 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10104 opts_type = OPTS_TYPE_PT_GENERATE_LE
10105 | OPTS_TYPE_ST_BASE64
10106 | OPTS_TYPE_HASH_COPY;
10107 kern_type = KERN_TYPE_PBKDF2_SHA256;
10108 dgst_size = DGST_SIZE_4_32;
10109 parse_func = pbkdf2_sha256_parse_hash;
10110 sort_by_digest = sort_by_digest_4_32;
10111 opti_type = OPTI_TYPE_ZERO_BYTE
10112 | OPTI_TYPE_SLOW_HASH_SIMD;
10113 dgst_pos0 = 0;
10114 dgst_pos1 = 1;
10115 dgst_pos2 = 2;
10116 dgst_pos3 = 3;
10117 break;
10118
10119 case 11000: hash_type = HASH_TYPE_MD5;
10120 salt_type = SALT_TYPE_INTERN;
10121 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10122 opts_type = OPTS_TYPE_PT_GENERATE_LE
10123 | OPTS_TYPE_PT_ADD80;
10124 kern_type = KERN_TYPE_PRESTASHOP;
10125 dgst_size = DGST_SIZE_4_4;
10126 parse_func = prestashop_parse_hash;
10127 sort_by_digest = sort_by_digest_4_4;
10128 opti_type = OPTI_TYPE_ZERO_BYTE
10129 | OPTI_TYPE_PRECOMPUTE_INIT
10130 | OPTI_TYPE_NOT_ITERATED
10131 | OPTI_TYPE_PREPENDED_SALT;
10132 dgst_pos0 = 0;
10133 dgst_pos1 = 3;
10134 dgst_pos2 = 2;
10135 dgst_pos3 = 1;
10136 break;
10137
10138 case 11100: hash_type = HASH_TYPE_MD5;
10139 salt_type = SALT_TYPE_EMBEDDED;
10140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10141 opts_type = OPTS_TYPE_PT_GENERATE_LE
10142 | OPTS_TYPE_ST_ADD80;
10143 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10144 dgst_size = DGST_SIZE_4_4;
10145 parse_func = postgresql_auth_parse_hash;
10146 sort_by_digest = sort_by_digest_4_4;
10147 opti_type = OPTI_TYPE_ZERO_BYTE
10148 | OPTI_TYPE_PRECOMPUTE_INIT
10149 | OPTI_TYPE_PRECOMPUTE_MERKLE
10150 | OPTI_TYPE_EARLY_SKIP;
10151 dgst_pos0 = 0;
10152 dgst_pos1 = 3;
10153 dgst_pos2 = 2;
10154 dgst_pos3 = 1;
10155 break;
10156
10157 case 11200: hash_type = HASH_TYPE_SHA1;
10158 salt_type = SALT_TYPE_EMBEDDED;
10159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10160 opts_type = OPTS_TYPE_PT_GENERATE_BE
10161 | OPTS_TYPE_PT_ADD80
10162 | OPTS_TYPE_ST_HEX;
10163 kern_type = KERN_TYPE_MYSQL_AUTH;
10164 dgst_size = DGST_SIZE_4_5;
10165 parse_func = mysql_auth_parse_hash;
10166 sort_by_digest = sort_by_digest_4_5;
10167 opti_type = OPTI_TYPE_ZERO_BYTE
10168 | OPTI_TYPE_EARLY_SKIP;
10169 dgst_pos0 = 3;
10170 dgst_pos1 = 4;
10171 dgst_pos2 = 2;
10172 dgst_pos3 = 1;
10173 break;
10174
10175 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10176 salt_type = SALT_TYPE_EMBEDDED;
10177 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10178 opts_type = OPTS_TYPE_PT_GENERATE_LE
10179 | OPTS_TYPE_ST_HEX
10180 | OPTS_TYPE_ST_ADD80;
10181 kern_type = KERN_TYPE_BITCOIN_WALLET;
10182 dgst_size = DGST_SIZE_4_4;
10183 parse_func = bitcoin_wallet_parse_hash;
10184 sort_by_digest = sort_by_digest_4_4;
10185 opti_type = OPTI_TYPE_ZERO_BYTE;
10186 dgst_pos0 = 0;
10187 dgst_pos1 = 1;
10188 dgst_pos2 = 2;
10189 dgst_pos3 = 3;
10190 break;
10191
10192 case 11400: hash_type = HASH_TYPE_MD5;
10193 salt_type = SALT_TYPE_EMBEDDED;
10194 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10195 opts_type = OPTS_TYPE_PT_GENERATE_LE
10196 | OPTS_TYPE_PT_ADD80
10197 | OPTS_TYPE_HASH_COPY;
10198 kern_type = KERN_TYPE_SIP_AUTH;
10199 dgst_size = DGST_SIZE_4_4;
10200 parse_func = sip_auth_parse_hash;
10201 sort_by_digest = sort_by_digest_4_4;
10202 opti_type = OPTI_TYPE_ZERO_BYTE;
10203 dgst_pos0 = 0;
10204 dgst_pos1 = 3;
10205 dgst_pos2 = 2;
10206 dgst_pos3 = 1;
10207 break;
10208
10209 case 11500: hash_type = HASH_TYPE_CRC32;
10210 salt_type = SALT_TYPE_INTERN;
10211 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10212 opts_type = OPTS_TYPE_PT_GENERATE_LE
10213 | OPTS_TYPE_ST_GENERATE_LE
10214 | OPTS_TYPE_ST_HEX;
10215 kern_type = KERN_TYPE_CRC32;
10216 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10217 parse_func = crc32_parse_hash;
10218 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10219 opti_type = OPTI_TYPE_ZERO_BYTE;
10220 dgst_pos0 = 0;
10221 dgst_pos1 = 1;
10222 dgst_pos2 = 2;
10223 dgst_pos3 = 3;
10224 break;
10225
10226 case 11600: hash_type = HASH_TYPE_AES;
10227 salt_type = SALT_TYPE_EMBEDDED;
10228 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10229 opts_type = OPTS_TYPE_PT_GENERATE_LE
10230 | OPTS_TYPE_PT_NEVERCRACK;
10231 kern_type = KERN_TYPE_SEVEN_ZIP;
10232 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10233 parse_func = seven_zip_parse_hash;
10234 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10235 opti_type = OPTI_TYPE_ZERO_BYTE;
10236 dgst_pos0 = 0;
10237 dgst_pos1 = 1;
10238 dgst_pos2 = 2;
10239 dgst_pos3 = 3;
10240 break;
10241
10242 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10243 salt_type = SALT_TYPE_NONE;
10244 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10245 opts_type = OPTS_TYPE_PT_GENERATE_LE
10246 | OPTS_TYPE_PT_ADD01;
10247 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10248 dgst_size = DGST_SIZE_4_8;
10249 parse_func = gost2012sbog_256_parse_hash;
10250 sort_by_digest = sort_by_digest_4_8;
10251 opti_type = OPTI_TYPE_ZERO_BYTE;
10252 dgst_pos0 = 0;
10253 dgst_pos1 = 1;
10254 dgst_pos2 = 2;
10255 dgst_pos3 = 3;
10256 break;
10257
10258 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10259 salt_type = SALT_TYPE_NONE;
10260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10261 opts_type = OPTS_TYPE_PT_GENERATE_LE
10262 | OPTS_TYPE_PT_ADD01;
10263 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10264 dgst_size = DGST_SIZE_4_16;
10265 parse_func = gost2012sbog_512_parse_hash;
10266 sort_by_digest = sort_by_digest_4_16;
10267 opti_type = OPTI_TYPE_ZERO_BYTE;
10268 dgst_pos0 = 0;
10269 dgst_pos1 = 1;
10270 dgst_pos2 = 2;
10271 dgst_pos3 = 3;
10272 break;
10273
10274 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10275 salt_type = SALT_TYPE_EMBEDDED;
10276 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10277 opts_type = OPTS_TYPE_PT_GENERATE_LE
10278 | OPTS_TYPE_ST_BASE64
10279 | OPTS_TYPE_HASH_COPY;
10280 kern_type = KERN_TYPE_PBKDF2_MD5;
10281 dgst_size = DGST_SIZE_4_32;
10282 parse_func = pbkdf2_md5_parse_hash;
10283 sort_by_digest = sort_by_digest_4_32;
10284 opti_type = OPTI_TYPE_ZERO_BYTE
10285 | OPTI_TYPE_SLOW_HASH_SIMD;
10286 dgst_pos0 = 0;
10287 dgst_pos1 = 1;
10288 dgst_pos2 = 2;
10289 dgst_pos3 = 3;
10290 break;
10291
10292 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10293 salt_type = SALT_TYPE_EMBEDDED;
10294 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10295 opts_type = OPTS_TYPE_PT_GENERATE_LE
10296 | OPTS_TYPE_ST_BASE64
10297 | OPTS_TYPE_HASH_COPY;
10298 kern_type = KERN_TYPE_PBKDF2_SHA1;
10299 dgst_size = DGST_SIZE_4_32;
10300 parse_func = pbkdf2_sha1_parse_hash;
10301 sort_by_digest = sort_by_digest_4_32;
10302 opti_type = OPTI_TYPE_ZERO_BYTE
10303 | OPTI_TYPE_SLOW_HASH_SIMD;
10304 dgst_pos0 = 0;
10305 dgst_pos1 = 1;
10306 dgst_pos2 = 2;
10307 dgst_pos3 = 3;
10308 break;
10309
10310 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10311 salt_type = SALT_TYPE_EMBEDDED;
10312 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10313 opts_type = OPTS_TYPE_PT_GENERATE_LE
10314 | OPTS_TYPE_ST_BASE64
10315 | OPTS_TYPE_HASH_COPY;
10316 kern_type = KERN_TYPE_PBKDF2_SHA512;
10317 dgst_size = DGST_SIZE_8_16;
10318 parse_func = pbkdf2_sha512_parse_hash;
10319 sort_by_digest = sort_by_digest_8_16;
10320 opti_type = OPTI_TYPE_ZERO_BYTE
10321 | OPTI_TYPE_USES_BITS_64
10322 | OPTI_TYPE_SLOW_HASH_SIMD;
10323 dgst_pos0 = 0;
10324 dgst_pos1 = 1;
10325 dgst_pos2 = 2;
10326 dgst_pos3 = 3;
10327 break;
10328
10329 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10330 salt_type = SALT_TYPE_EMBEDDED;
10331 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10332 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10333 kern_type = KERN_TYPE_ECRYPTFS;
10334 dgst_size = DGST_SIZE_8_8;
10335 parse_func = ecryptfs_parse_hash;
10336 sort_by_digest = sort_by_digest_8_8;
10337 opti_type = OPTI_TYPE_ZERO_BYTE
10338 | OPTI_TYPE_USES_BITS_64;
10339 dgst_pos0 = 0;
10340 dgst_pos1 = 1;
10341 dgst_pos2 = 2;
10342 dgst_pos3 = 3;
10343 break;
10344
10345 case 12300: hash_type = HASH_TYPE_ORACLET;
10346 salt_type = SALT_TYPE_EMBEDDED;
10347 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10348 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10349 kern_type = KERN_TYPE_ORACLET;
10350 dgst_size = DGST_SIZE_8_16;
10351 parse_func = oraclet_parse_hash;
10352 sort_by_digest = sort_by_digest_8_16;
10353 opti_type = OPTI_TYPE_ZERO_BYTE
10354 | OPTI_TYPE_USES_BITS_64;
10355 dgst_pos0 = 0;
10356 dgst_pos1 = 1;
10357 dgst_pos2 = 2;
10358 dgst_pos3 = 3;
10359 break;
10360
10361 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10362 salt_type = SALT_TYPE_EMBEDDED;
10363 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10364 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10365 kern_type = KERN_TYPE_BSDICRYPT;
10366 dgst_size = DGST_SIZE_4_4;
10367 parse_func = bsdicrypt_parse_hash;
10368 sort_by_digest = sort_by_digest_4_4;
10369 opti_type = OPTI_TYPE_ZERO_BYTE
10370 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10371 dgst_pos0 = 0;
10372 dgst_pos1 = 1;
10373 dgst_pos2 = 2;
10374 dgst_pos3 = 3;
10375 break;
10376
10377 case 12500: hash_type = HASH_TYPE_RAR3HP;
10378 salt_type = SALT_TYPE_EMBEDDED;
10379 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10380 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10381 kern_type = KERN_TYPE_RAR3;
10382 dgst_size = DGST_SIZE_4_4;
10383 parse_func = rar3hp_parse_hash;
10384 sort_by_digest = sort_by_digest_4_4;
10385 opti_type = OPTI_TYPE_ZERO_BYTE;
10386 dgst_pos0 = 0;
10387 dgst_pos1 = 1;
10388 dgst_pos2 = 2;
10389 dgst_pos3 = 3;
10390 break;
10391
10392 case 12600: hash_type = HASH_TYPE_SHA256;
10393 salt_type = SALT_TYPE_INTERN;
10394 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10395 opts_type = OPTS_TYPE_PT_GENERATE_BE
10396 | OPTS_TYPE_PT_ADD80;
10397 kern_type = KERN_TYPE_CF10;
10398 dgst_size = DGST_SIZE_4_8;
10399 parse_func = cf10_parse_hash;
10400 sort_by_digest = sort_by_digest_4_8;
10401 opti_type = OPTI_TYPE_ZERO_BYTE
10402 | OPTI_TYPE_PRECOMPUTE_INIT
10403 | OPTI_TYPE_EARLY_SKIP
10404 | OPTI_TYPE_NOT_ITERATED;
10405 dgst_pos0 = 3;
10406 dgst_pos1 = 7;
10407 dgst_pos2 = 2;
10408 dgst_pos3 = 6;
10409 break;
10410
10411 case 12700: hash_type = HASH_TYPE_AES;
10412 salt_type = SALT_TYPE_EMBEDDED;
10413 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10414 opts_type = OPTS_TYPE_PT_GENERATE_LE
10415 | OPTS_TYPE_HASH_COPY;
10416 kern_type = KERN_TYPE_MYWALLET;
10417 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10418 parse_func = mywallet_parse_hash;
10419 sort_by_digest = sort_by_digest_4_5;
10420 opti_type = OPTI_TYPE_ZERO_BYTE;
10421 dgst_pos0 = 0;
10422 dgst_pos1 = 1;
10423 dgst_pos2 = 2;
10424 dgst_pos3 = 3;
10425 break;
10426
10427 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10428 salt_type = SALT_TYPE_EMBEDDED;
10429 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10430 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10431 kern_type = KERN_TYPE_MS_DRSR;
10432 dgst_size = DGST_SIZE_4_8;
10433 parse_func = ms_drsr_parse_hash;
10434 sort_by_digest = sort_by_digest_4_8;
10435 opti_type = OPTI_TYPE_ZERO_BYTE;
10436 dgst_pos0 = 0;
10437 dgst_pos1 = 1;
10438 dgst_pos2 = 2;
10439 dgst_pos3 = 3;
10440 break;
10441
10442 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10443 salt_type = SALT_TYPE_EMBEDDED;
10444 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10445 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10446 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10447 dgst_size = DGST_SIZE_4_8;
10448 parse_func = androidfde_samsung_parse_hash;
10449 sort_by_digest = sort_by_digest_4_8;
10450 opti_type = OPTI_TYPE_ZERO_BYTE;
10451 dgst_pos0 = 0;
10452 dgst_pos1 = 1;
10453 dgst_pos2 = 2;
10454 dgst_pos3 = 3;
10455 break;
10456
10457 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10458 salt_type = SALT_TYPE_EMBEDDED;
10459 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10460 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10461 kern_type = KERN_TYPE_RAR5;
10462 dgst_size = DGST_SIZE_4_4;
10463 parse_func = rar5_parse_hash;
10464 sort_by_digest = sort_by_digest_4_4;
10465 opti_type = OPTI_TYPE_ZERO_BYTE;
10466 dgst_pos0 = 0;
10467 dgst_pos1 = 1;
10468 dgst_pos2 = 2;
10469 dgst_pos3 = 3;
10470 break;
10471
10472 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10473 salt_type = SALT_TYPE_EMBEDDED;
10474 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10475 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10476 kern_type = KERN_TYPE_KRB5TGS;
10477 dgst_size = DGST_SIZE_4_4;
10478 parse_func = krb5tgs_parse_hash;
10479 sort_by_digest = sort_by_digest_4_4;
10480 opti_type = OPTI_TYPE_ZERO_BYTE
10481 | OPTI_TYPE_NOT_ITERATED;
10482 dgst_pos0 = 0;
10483 dgst_pos1 = 1;
10484 dgst_pos2 = 2;
10485 dgst_pos3 = 3;
10486 break;
10487
10488 case 13200: hash_type = HASH_TYPE_AES;
10489 salt_type = SALT_TYPE_EMBEDDED;
10490 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10491 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10492 kern_type = KERN_TYPE_AXCRYPT;
10493 dgst_size = DGST_SIZE_4_4;
10494 parse_func = axcrypt_parse_hash;
10495 sort_by_digest = sort_by_digest_4_4;
10496 opti_type = OPTI_TYPE_ZERO_BYTE;
10497 dgst_pos0 = 0;
10498 dgst_pos1 = 1;
10499 dgst_pos2 = 2;
10500 dgst_pos3 = 3;
10501 break;
10502
10503 case 13300: hash_type = HASH_TYPE_SHA1;
10504 salt_type = SALT_TYPE_NONE;
10505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10506 opts_type = OPTS_TYPE_PT_GENERATE_BE
10507 | OPTS_TYPE_PT_ADD80
10508 | OPTS_TYPE_PT_ADDBITS15;
10509 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10510 dgst_size = DGST_SIZE_4_5;
10511 parse_func = sha1axcrypt_parse_hash;
10512 sort_by_digest = sort_by_digest_4_5;
10513 opti_type = OPTI_TYPE_ZERO_BYTE
10514 | OPTI_TYPE_PRECOMPUTE_INIT
10515 | OPTI_TYPE_EARLY_SKIP
10516 | OPTI_TYPE_NOT_ITERATED
10517 | OPTI_TYPE_NOT_SALTED;
10518 dgst_pos0 = 0;
10519 dgst_pos1 = 4;
10520 dgst_pos2 = 3;
10521 dgst_pos3 = 2;
10522 break;
10523
10524 case 13400: hash_type = HASH_TYPE_AES;
10525 salt_type = SALT_TYPE_EMBEDDED;
10526 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10527 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10528 kern_type = KERN_TYPE_KEEPASS;
10529 dgst_size = DGST_SIZE_4_4;
10530 parse_func = keepass_parse_hash;
10531 sort_by_digest = sort_by_digest_4_4;
10532 opti_type = OPTI_TYPE_ZERO_BYTE;
10533 dgst_pos0 = 0;
10534 dgst_pos1 = 1;
10535 dgst_pos2 = 2;
10536 dgst_pos3 = 3;
10537 break;
10538
10539 case 13500: hash_type = HASH_TYPE_SHA1;
10540 salt_type = SALT_TYPE_EMBEDDED;
10541 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10542 opts_type = OPTS_TYPE_PT_GENERATE_BE
10543 | OPTS_TYPE_PT_UNICODE
10544 | OPTS_TYPE_PT_ADD80;
10545 kern_type = KERN_TYPE_PSTOKEN;
10546 dgst_size = DGST_SIZE_4_5;
10547 parse_func = pstoken_parse_hash;
10548 sort_by_digest = sort_by_digest_4_5;
10549 opti_type = OPTI_TYPE_ZERO_BYTE
10550 | OPTI_TYPE_PRECOMPUTE_INIT
10551 | OPTI_TYPE_EARLY_SKIP
10552 | OPTI_TYPE_NOT_ITERATED
10553 | OPTI_TYPE_PREPENDED_SALT
10554 | OPTI_TYPE_RAW_HASH;
10555 dgst_pos0 = 3;
10556 dgst_pos1 = 4;
10557 dgst_pos2 = 2;
10558 dgst_pos3 = 1;
10559 break;
10560
10561 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10562 salt_type = SALT_TYPE_EMBEDDED;
10563 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10564 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10565 kern_type = KERN_TYPE_ZIP2;
10566 dgst_size = DGST_SIZE_4_4;
10567 parse_func = zip2_parse_hash;
10568 sort_by_digest = sort_by_digest_4_4;
10569 opti_type = OPTI_TYPE_ZERO_BYTE;
10570 dgst_pos0 = 0;
10571 dgst_pos1 = 1;
10572 dgst_pos2 = 2;
10573 dgst_pos3 = 3;
10574 break;
10575
10576 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10577 salt_type = SALT_TYPE_EMBEDDED;
10578 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10579 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10580 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10581 dgst_size = DGST_SIZE_4_5;
10582 parse_func = veracrypt_parse_hash_655331;
10583 sort_by_digest = sort_by_digest_4_5;
10584 opti_type = OPTI_TYPE_ZERO_BYTE;
10585 dgst_pos0 = 0;
10586 dgst_pos1 = 1;
10587 dgst_pos2 = 2;
10588 dgst_pos3 = 3;
10589 break;
10590
10591 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10592 salt_type = SALT_TYPE_EMBEDDED;
10593 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10594 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10595 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10596 dgst_size = DGST_SIZE_4_5;
10597 parse_func = veracrypt_parse_hash_655331;
10598 sort_by_digest = sort_by_digest_4_5;
10599 opti_type = OPTI_TYPE_ZERO_BYTE;
10600 dgst_pos0 = 0;
10601 dgst_pos1 = 1;
10602 dgst_pos2 = 2;
10603 dgst_pos3 = 3;
10604 break;
10605
10606 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10607 salt_type = SALT_TYPE_EMBEDDED;
10608 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10609 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10610 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10611 dgst_size = DGST_SIZE_4_5;
10612 parse_func = veracrypt_parse_hash_655331;
10613 sort_by_digest = sort_by_digest_4_5;
10614 opti_type = OPTI_TYPE_ZERO_BYTE;
10615 dgst_pos0 = 0;
10616 dgst_pos1 = 1;
10617 dgst_pos2 = 2;
10618 dgst_pos3 = 3;
10619 break;
10620
10621 case 13721: hash_type = HASH_TYPE_SHA512;
10622 salt_type = SALT_TYPE_EMBEDDED;
10623 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10624 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10625 kern_type = KERN_TYPE_TCSHA512_XTS512;
10626 dgst_size = DGST_SIZE_8_8;
10627 parse_func = veracrypt_parse_hash_500000;
10628 sort_by_digest = sort_by_digest_8_8;
10629 opti_type = OPTI_TYPE_ZERO_BYTE
10630 | OPTI_TYPE_USES_BITS_64;
10631 dgst_pos0 = 0;
10632 dgst_pos1 = 1;
10633 dgst_pos2 = 2;
10634 dgst_pos3 = 3;
10635 break;
10636
10637 case 13722: hash_type = HASH_TYPE_SHA512;
10638 salt_type = SALT_TYPE_EMBEDDED;
10639 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10640 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10641 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10642 dgst_size = DGST_SIZE_8_8;
10643 parse_func = veracrypt_parse_hash_500000;
10644 sort_by_digest = sort_by_digest_8_8;
10645 opti_type = OPTI_TYPE_ZERO_BYTE
10646 | OPTI_TYPE_USES_BITS_64;
10647 dgst_pos0 = 0;
10648 dgst_pos1 = 1;
10649 dgst_pos2 = 2;
10650 dgst_pos3 = 3;
10651 break;
10652
10653 case 13723: hash_type = HASH_TYPE_SHA512;
10654 salt_type = SALT_TYPE_EMBEDDED;
10655 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10656 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10657 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10658 dgst_size = DGST_SIZE_8_8;
10659 parse_func = veracrypt_parse_hash_500000;
10660 sort_by_digest = sort_by_digest_8_8;
10661 opti_type = OPTI_TYPE_ZERO_BYTE
10662 | OPTI_TYPE_USES_BITS_64;
10663 dgst_pos0 = 0;
10664 dgst_pos1 = 1;
10665 dgst_pos2 = 2;
10666 dgst_pos3 = 3;
10667 break;
10668
10669 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10670 salt_type = SALT_TYPE_EMBEDDED;
10671 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10672 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10673 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10674 dgst_size = DGST_SIZE_4_8;
10675 parse_func = veracrypt_parse_hash_500000;
10676 sort_by_digest = sort_by_digest_4_8;
10677 opti_type = OPTI_TYPE_ZERO_BYTE;
10678 dgst_pos0 = 0;
10679 dgst_pos1 = 1;
10680 dgst_pos2 = 2;
10681 dgst_pos3 = 3;
10682 break;
10683
10684 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10685 salt_type = SALT_TYPE_EMBEDDED;
10686 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10687 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10688 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10689 dgst_size = DGST_SIZE_4_8;
10690 parse_func = veracrypt_parse_hash_500000;
10691 sort_by_digest = sort_by_digest_4_8;
10692 opti_type = OPTI_TYPE_ZERO_BYTE;
10693 dgst_pos0 = 0;
10694 dgst_pos1 = 1;
10695 dgst_pos2 = 2;
10696 dgst_pos3 = 3;
10697 break;
10698
10699 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10700 salt_type = SALT_TYPE_EMBEDDED;
10701 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10702 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10703 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10704 dgst_size = DGST_SIZE_4_8;
10705 parse_func = veracrypt_parse_hash_500000;
10706 sort_by_digest = sort_by_digest_4_8;
10707 opti_type = OPTI_TYPE_ZERO_BYTE;
10708 dgst_pos0 = 0;
10709 dgst_pos1 = 1;
10710 dgst_pos2 = 2;
10711 dgst_pos3 = 3;
10712 break;
10713
10714 case 13741: hash_type = HASH_TYPE_RIPEMD160;
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_TCRIPEMD160_XTS512;
10719 dgst_size = DGST_SIZE_4_5;
10720 parse_func = veracrypt_parse_hash_327661;
10721 sort_by_digest = sort_by_digest_4_5;
10722 opti_type = OPTI_TYPE_ZERO_BYTE;
10723 dgst_pos0 = 0;
10724 dgst_pos1 = 1;
10725 dgst_pos2 = 2;
10726 dgst_pos3 = 3;
10727 break;
10728
10729 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10730 salt_type = SALT_TYPE_EMBEDDED;
10731 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10732 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10733 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10734 dgst_size = DGST_SIZE_4_5;
10735 parse_func = veracrypt_parse_hash_327661;
10736 sort_by_digest = sort_by_digest_4_5;
10737 opti_type = OPTI_TYPE_ZERO_BYTE;
10738 dgst_pos0 = 0;
10739 dgst_pos1 = 1;
10740 dgst_pos2 = 2;
10741 dgst_pos3 = 3;
10742 break;
10743
10744 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10745 salt_type = SALT_TYPE_EMBEDDED;
10746 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10747 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10748 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10749 dgst_size = DGST_SIZE_4_5;
10750 parse_func = veracrypt_parse_hash_327661;
10751 sort_by_digest = sort_by_digest_4_5;
10752 opti_type = OPTI_TYPE_ZERO_BYTE;
10753 dgst_pos0 = 0;
10754 dgst_pos1 = 1;
10755 dgst_pos2 = 2;
10756 dgst_pos3 = 3;
10757 break;
10758
10759 case 13751: hash_type = HASH_TYPE_SHA256;
10760 salt_type = SALT_TYPE_EMBEDDED;
10761 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10762 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10763 kern_type = KERN_TYPE_VCSHA256_XTS512;
10764 dgst_size = DGST_SIZE_4_8;
10765 parse_func = veracrypt_parse_hash_500000;
10766 sort_by_digest = sort_by_digest_4_8;
10767 opti_type = OPTI_TYPE_ZERO_BYTE;
10768 dgst_pos0 = 0;
10769 dgst_pos1 = 1;
10770 dgst_pos2 = 2;
10771 dgst_pos3 = 3;
10772 break;
10773
10774 case 13752: hash_type = HASH_TYPE_SHA256;
10775 salt_type = SALT_TYPE_EMBEDDED;
10776 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10777 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10778 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10779 dgst_size = DGST_SIZE_4_8;
10780 parse_func = veracrypt_parse_hash_500000;
10781 sort_by_digest = sort_by_digest_4_8;
10782 opti_type = OPTI_TYPE_ZERO_BYTE;
10783 dgst_pos0 = 0;
10784 dgst_pos1 = 1;
10785 dgst_pos2 = 2;
10786 dgst_pos3 = 3;
10787 break;
10788
10789 case 13753: hash_type = HASH_TYPE_SHA256;
10790 salt_type = SALT_TYPE_EMBEDDED;
10791 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10792 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10793 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10794 dgst_size = DGST_SIZE_4_8;
10795 parse_func = veracrypt_parse_hash_500000;
10796 sort_by_digest = sort_by_digest_4_8;
10797 opti_type = OPTI_TYPE_ZERO_BYTE;
10798 dgst_pos0 = 0;
10799 dgst_pos1 = 1;
10800 dgst_pos2 = 2;
10801 dgst_pos3 = 3;
10802 break;
10803
10804 case 13761: hash_type = HASH_TYPE_SHA256;
10805 salt_type = SALT_TYPE_EMBEDDED;
10806 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10807 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10808 kern_type = KERN_TYPE_VCSHA256_XTS512;
10809 dgst_size = DGST_SIZE_4_8;
10810 parse_func = veracrypt_parse_hash_200000;
10811 sort_by_digest = sort_by_digest_4_8;
10812 opti_type = OPTI_TYPE_ZERO_BYTE;
10813 dgst_pos0 = 0;
10814 dgst_pos1 = 1;
10815 dgst_pos2 = 2;
10816 dgst_pos3 = 3;
10817 break;
10818
10819 case 13762: hash_type = HASH_TYPE_SHA256;
10820 salt_type = SALT_TYPE_EMBEDDED;
10821 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10822 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10823 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10824 dgst_size = DGST_SIZE_4_8;
10825 parse_func = veracrypt_parse_hash_200000;
10826 sort_by_digest = sort_by_digest_4_8;
10827 opti_type = OPTI_TYPE_ZERO_BYTE;
10828 dgst_pos0 = 0;
10829 dgst_pos1 = 1;
10830 dgst_pos2 = 2;
10831 dgst_pos3 = 3;
10832 break;
10833
10834 case 13763: hash_type = HASH_TYPE_SHA256;
10835 salt_type = SALT_TYPE_EMBEDDED;
10836 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10837 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10838 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10839 dgst_size = DGST_SIZE_4_8;
10840 parse_func = veracrypt_parse_hash_200000;
10841 sort_by_digest = sort_by_digest_4_8;
10842 opti_type = OPTI_TYPE_ZERO_BYTE;
10843 dgst_pos0 = 0;
10844 dgst_pos1 = 1;
10845 dgst_pos2 = 2;
10846 dgst_pos3 = 3;
10847 break;
10848
10849 case 13800: hash_type = HASH_TYPE_SHA256;
10850 salt_type = SALT_TYPE_EMBEDDED;
10851 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10852 opts_type = OPTS_TYPE_PT_GENERATE_BE
10853 | OPTS_TYPE_PT_UNICODE;
10854 kern_type = KERN_TYPE_WIN8PHONE;
10855 dgst_size = DGST_SIZE_4_8;
10856 parse_func = win8phone_parse_hash;
10857 sort_by_digest = sort_by_digest_4_8;
10858 opti_type = OPTI_TYPE_ZERO_BYTE
10859 | OPTI_TYPE_PRECOMPUTE_INIT
10860 | OPTI_TYPE_EARLY_SKIP
10861 | OPTI_TYPE_NOT_ITERATED
10862 | OPTI_TYPE_RAW_HASH;
10863 dgst_pos0 = 3;
10864 dgst_pos1 = 7;
10865 dgst_pos2 = 2;
10866 dgst_pos3 = 6;
10867 break;
10868
10869
10870 default: usage_mini_print (PROGNAME); return (-1);
10871 }
10872
10873 /**
10874 * parser
10875 */
10876
10877 data.parse_func = parse_func;
10878
10879 /**
10880 * misc stuff
10881 */
10882
10883 if (hex_salt)
10884 {
10885 if (salt_type == SALT_TYPE_INTERN)
10886 {
10887 opts_type |= OPTS_TYPE_ST_HEX;
10888 }
10889 else
10890 {
10891 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10892
10893 return (-1);
10894 }
10895 }
10896
10897 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10898 | (salt_type == SALT_TYPE_EXTERN)
10899 | (salt_type == SALT_TYPE_EMBEDDED)
10900 | (salt_type == SALT_TYPE_VIRTUAL));
10901
10902 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10903
10904 data.hash_type = hash_type;
10905 data.attack_mode = attack_mode;
10906 data.attack_kern = attack_kern;
10907 data.attack_exec = attack_exec;
10908 data.kern_type = kern_type;
10909 data.opts_type = opts_type;
10910 data.dgst_size = dgst_size;
10911 data.salt_type = salt_type;
10912 data.isSalted = isSalted;
10913 data.sort_by_digest = sort_by_digest;
10914 data.dgst_pos0 = dgst_pos0;
10915 data.dgst_pos1 = dgst_pos1;
10916 data.dgst_pos2 = dgst_pos2;
10917 data.dgst_pos3 = dgst_pos3;
10918
10919 esalt_size = 0;
10920
10921 switch (hash_mode)
10922 {
10923 case 2500: esalt_size = sizeof (wpa_t); break;
10924 case 5300: esalt_size = sizeof (ikepsk_t); break;
10925 case 5400: esalt_size = sizeof (ikepsk_t); break;
10926 case 5500: esalt_size = sizeof (netntlm_t); break;
10927 case 5600: esalt_size = sizeof (netntlm_t); break;
10928 case 6211: esalt_size = sizeof (tc_t); break;
10929 case 6212: esalt_size = sizeof (tc_t); break;
10930 case 6213: esalt_size = sizeof (tc_t); break;
10931 case 6221: esalt_size = sizeof (tc_t); break;
10932 case 6222: esalt_size = sizeof (tc_t); break;
10933 case 6223: esalt_size = sizeof (tc_t); break;
10934 case 6231: esalt_size = sizeof (tc_t); break;
10935 case 6232: esalt_size = sizeof (tc_t); break;
10936 case 6233: esalt_size = sizeof (tc_t); break;
10937 case 6241: esalt_size = sizeof (tc_t); break;
10938 case 6242: esalt_size = sizeof (tc_t); break;
10939 case 6243: esalt_size = sizeof (tc_t); break;
10940 case 6600: esalt_size = sizeof (agilekey_t); break;
10941 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10942 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10943 case 7300: esalt_size = sizeof (rakp_t); break;
10944 case 7500: esalt_size = sizeof (krb5pa_t); break;
10945 case 8200: esalt_size = sizeof (cloudkey_t); break;
10946 case 8800: esalt_size = sizeof (androidfde_t); break;
10947 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10948 case 9400: esalt_size = sizeof (office2007_t); break;
10949 case 9500: esalt_size = sizeof (office2010_t); break;
10950 case 9600: esalt_size = sizeof (office2013_t); break;
10951 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10952 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10953 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10954 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10955 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10956 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10957 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10958 case 10200: esalt_size = sizeof (cram_md5_t); break;
10959 case 10400: esalt_size = sizeof (pdf_t); break;
10960 case 10410: esalt_size = sizeof (pdf_t); break;
10961 case 10420: esalt_size = sizeof (pdf_t); break;
10962 case 10500: esalt_size = sizeof (pdf_t); break;
10963 case 10600: esalt_size = sizeof (pdf_t); break;
10964 case 10700: esalt_size = sizeof (pdf_t); break;
10965 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10966 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10967 case 11400: esalt_size = sizeof (sip_t); break;
10968 case 11600: esalt_size = sizeof (seven_zip_t); break;
10969 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10970 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10971 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10972 case 13000: esalt_size = sizeof (rar5_t); break;
10973 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10974 case 13400: esalt_size = sizeof (keepass_t); break;
10975 case 13500: esalt_size = sizeof (pstoken_t); break;
10976 case 13600: esalt_size = sizeof (zip2_t); break;
10977 case 13711: esalt_size = sizeof (tc_t); break;
10978 case 13712: esalt_size = sizeof (tc_t); break;
10979 case 13713: esalt_size = sizeof (tc_t); break;
10980 case 13721: esalt_size = sizeof (tc_t); break;
10981 case 13722: esalt_size = sizeof (tc_t); break;
10982 case 13723: esalt_size = sizeof (tc_t); break;
10983 case 13731: esalt_size = sizeof (tc_t); break;
10984 case 13732: esalt_size = sizeof (tc_t); break;
10985 case 13733: esalt_size = sizeof (tc_t); break;
10986 case 13741: esalt_size = sizeof (tc_t); break;
10987 case 13742: esalt_size = sizeof (tc_t); break;
10988 case 13743: esalt_size = sizeof (tc_t); break;
10989 case 13751: esalt_size = sizeof (tc_t); break;
10990 case 13752: esalt_size = sizeof (tc_t); break;
10991 case 13753: esalt_size = sizeof (tc_t); break;
10992 case 13761: esalt_size = sizeof (tc_t); break;
10993 case 13762: esalt_size = sizeof (tc_t); break;
10994 case 13763: esalt_size = sizeof (tc_t); break;
10995 case 13800: esalt_size = sizeof (win8phone_t); break;
10996 }
10997
10998 data.esalt_size = esalt_size;
10999
11000 /**
11001 * choose dictionary parser
11002 */
11003
11004 if (hash_type == HASH_TYPE_LM)
11005 {
11006 get_next_word_func = get_next_word_lm;
11007 }
11008 else if (opts_type & OPTS_TYPE_PT_UPPER)
11009 {
11010 get_next_word_func = get_next_word_uc;
11011 }
11012 else
11013 {
11014 get_next_word_func = get_next_word_std;
11015 }
11016
11017 /**
11018 * dictstat
11019 */
11020
11021 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11022
11023 #ifdef _POSIX
11024 size_t dictstat_nmemb = 0;
11025 #endif
11026
11027 #ifdef _WIN
11028 uint dictstat_nmemb = 0;
11029 #endif
11030
11031 char dictstat[256] = { 0 };
11032
11033 FILE *dictstat_fp = NULL;
11034
11035 if (keyspace == 0)
11036 {
11037 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11038
11039 dictstat_fp = fopen (dictstat, "rb");
11040
11041 if (dictstat_fp)
11042 {
11043 #ifdef _POSIX
11044 struct stat tmpstat;
11045
11046 fstat (fileno (dictstat_fp), &tmpstat);
11047 #endif
11048
11049 #ifdef _WIN
11050 struct stat64 tmpstat;
11051
11052 _fstat64 (fileno (dictstat_fp), &tmpstat);
11053 #endif
11054
11055 if (tmpstat.st_mtime < COMPTIME)
11056 {
11057 /* with v0.15 the format changed so we have to ensure user is using a good version
11058 since there is no version-header in the dictstat file */
11059
11060 fclose (dictstat_fp);
11061
11062 unlink (dictstat);
11063 }
11064 else
11065 {
11066 while (!feof (dictstat_fp))
11067 {
11068 dictstat_t d;
11069
11070 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11071
11072 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11073
11074 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11075 {
11076 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11077
11078 return -1;
11079 }
11080 }
11081
11082 fclose (dictstat_fp);
11083 }
11084 }
11085 }
11086
11087 /**
11088 * potfile
11089 */
11090
11091 char potfile[256] = { 0 };
11092
11093 if (potfile_path == NULL)
11094 {
11095 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11096 }
11097 else
11098 {
11099 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11100 }
11101
11102 data.pot_fp = NULL;
11103
11104 FILE *out_fp = NULL;
11105 FILE *pot_fp = NULL;
11106
11107 if (show == 1 || left == 1)
11108 {
11109 pot_fp = fopen (potfile, "rb");
11110
11111 if (pot_fp == NULL)
11112 {
11113 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11114
11115 return (-1);
11116 }
11117
11118 if (outfile != NULL)
11119 {
11120 if ((out_fp = fopen (outfile, "ab")) == NULL)
11121 {
11122 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11123
11124 fclose (pot_fp);
11125
11126 return (-1);
11127 }
11128 }
11129 else
11130 {
11131 out_fp = stdout;
11132 }
11133 }
11134 else
11135 {
11136 if (potfile_disable == 0)
11137 {
11138 pot_fp = fopen (potfile, "ab");
11139
11140 if (pot_fp == NULL)
11141 {
11142 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11143
11144 return (-1);
11145 }
11146
11147 data.pot_fp = pot_fp;
11148 }
11149 }
11150
11151 pot_t *pot = NULL;
11152
11153 uint pot_cnt = 0;
11154 uint pot_avail = 0;
11155
11156 if (show == 1 || left == 1)
11157 {
11158 SUPPRESS_OUTPUT = 1;
11159
11160 pot_avail = count_lines (pot_fp);
11161
11162 rewind (pot_fp);
11163
11164 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11165
11166 uint pot_hashes_avail = 0;
11167
11168 uint line_num = 0;
11169
11170 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11171
11172 while (!feof (pot_fp))
11173 {
11174 line_num++;
11175
11176 int line_len = fgetl (pot_fp, line_buf);
11177
11178 if (line_len == 0) continue;
11179
11180 char *plain_buf = line_buf + line_len;
11181
11182 pot_t *pot_ptr = &pot[pot_cnt];
11183
11184 hash_t *hashes_buf = &pot_ptr->hash;
11185
11186 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11187 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11188
11189 if (pot_cnt == pot_hashes_avail)
11190 {
11191 uint pos = 0;
11192
11193 for (pos = 0; pos < INCR_POT; pos++)
11194 {
11195 if ((pot_cnt + pos) >= pot_avail) break;
11196
11197 pot_t *tmp_pot = &pot[pot_cnt + pos];
11198
11199 hash_t *tmp_hash = &tmp_pot->hash;
11200
11201 tmp_hash->digest = mymalloc (dgst_size);
11202
11203 if (isSalted)
11204 {
11205 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11206 }
11207
11208 if (esalt_size)
11209 {
11210 tmp_hash->esalt = mymalloc (esalt_size);
11211 }
11212
11213 pot_hashes_avail++;
11214 }
11215 }
11216
11217 int plain_len = 0;
11218
11219 int parser_status;
11220
11221 int iter = MAX_CUT_TRIES;
11222
11223 do
11224 {
11225 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11226 {
11227 if (line_buf[i] == ':')
11228 {
11229 line_len--;
11230
11231 break;
11232 }
11233 }
11234
11235 if (data.hash_mode != 2500)
11236 {
11237 parser_status = parse_func (line_buf, line_len, hashes_buf);
11238 }
11239 else
11240 {
11241 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11242
11243 if (line_len > max_salt_size)
11244 {
11245 parser_status = PARSER_GLOBAL_LENGTH;
11246 }
11247 else
11248 {
11249 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11250
11251 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11252
11253 hashes_buf->salt->salt_len = line_len;
11254
11255 parser_status = PARSER_OK;
11256 }
11257 }
11258
11259 // if NOT parsed without error, we add the ":" to the plain
11260
11261 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11262 {
11263 plain_len++;
11264 plain_buf--;
11265 }
11266
11267 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11268
11269 if (parser_status < PARSER_GLOBAL_ZERO)
11270 {
11271 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11272
11273 continue;
11274 }
11275
11276 if (plain_len >= 255) continue;
11277
11278 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11279
11280 pot_ptr->plain_len = plain_len;
11281
11282 pot_cnt++;
11283 }
11284
11285 myfree (line_buf);
11286
11287 fclose (pot_fp);
11288
11289 SUPPRESS_OUTPUT = 0;
11290
11291 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11292 }
11293
11294 /**
11295 * word len
11296 */
11297
11298 uint pw_min = PW_MIN;
11299 uint pw_max = PW_MAX;
11300
11301 switch (hash_mode)
11302 {
11303 case 125: if (pw_max > 32) pw_max = 32;
11304 break;
11305 case 400: if (pw_max > 40) pw_max = 40;
11306 break;
11307 case 500: if (pw_max > 16) pw_max = 16;
11308 break;
11309 case 1500: if (pw_max > 8) pw_max = 8;
11310 break;
11311 case 1600: if (pw_max > 16) pw_max = 16;
11312 break;
11313 case 1800: if (pw_max > 16) pw_max = 16;
11314 break;
11315 case 2100: if (pw_max > 16) pw_max = 16;
11316 break;
11317 case 2500: if (pw_min < 8) pw_min = 8;
11318 break;
11319 case 3000: if (pw_max > 7) pw_max = 7;
11320 break;
11321 case 5200: if (pw_max > 24) pw_max = 24;
11322 break;
11323 case 5800: if (pw_max > 16) pw_max = 16;
11324 break;
11325 case 6300: if (pw_max > 16) pw_max = 16;
11326 break;
11327 case 7400: if (pw_max > 16) pw_max = 16;
11328 break;
11329 case 7700: if (pw_max > 8) pw_max = 8;
11330 break;
11331 case 7900: if (pw_max > 48) pw_max = 48;
11332 break;
11333 case 8500: if (pw_max > 8) pw_max = 8;
11334 break;
11335 case 8600: if (pw_max > 16) pw_max = 16;
11336 break;
11337 case 9710: pw_min = 5;
11338 pw_max = 5;
11339 break;
11340 case 9810: pw_min = 5;
11341 pw_max = 5;
11342 break;
11343 case 10410: pw_min = 5;
11344 pw_max = 5;
11345 break;
11346 case 10300: if (pw_max < 3) pw_min = 3;
11347 if (pw_max > 40) pw_max = 40;
11348 break;
11349 case 10500: if (pw_max < 3) pw_min = 3;
11350 if (pw_max > 40) pw_max = 40;
11351 break;
11352 case 10700: if (pw_max > 16) pw_max = 16;
11353 break;
11354 case 11300: if (pw_max > 40) pw_max = 40;
11355 break;
11356 case 11600: if (pw_max > 32) pw_max = 32;
11357 break;
11358 case 12500: if (pw_max > 20) pw_max = 20;
11359 break;
11360 case 12800: if (pw_max > 24) pw_max = 24;
11361 break;
11362 }
11363
11364 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11365 {
11366 switch (attack_kern)
11367 {
11368 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11369 break;
11370 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11371 break;
11372 }
11373 }
11374
11375 /**
11376 * charsets : keep them together for more easy maintainnce
11377 */
11378
11379 cs_t mp_sys[6] = { { { 0 }, 0 } };
11380 cs_t mp_usr[4] = { { { 0 }, 0 } };
11381
11382 mp_setup_sys (mp_sys);
11383
11384 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11385 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11386 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11387 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11388
11389 /**
11390 * load hashes, part I: find input mode, count hashes
11391 */
11392
11393 uint hashlist_mode = 0;
11394 uint hashlist_format = HLFMT_HASHCAT;
11395
11396 uint hashes_avail = 0;
11397
11398 if (benchmark == 0)
11399 {
11400 struct stat f;
11401
11402 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11403
11404 if ((hash_mode == 2500) ||
11405 (hash_mode == 5200) ||
11406 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11407 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11408 (hash_mode == 9000))
11409 {
11410 hashlist_mode = HL_MODE_ARG;
11411
11412 char *hashfile = myargv[optind];
11413
11414 data.hashfile = hashfile;
11415
11416 logfile_top_var_string ("target", hashfile);
11417 }
11418
11419 if (hashlist_mode == HL_MODE_ARG)
11420 {
11421 if (hash_mode == 2500)
11422 {
11423 struct stat st;
11424
11425 if (stat (data.hashfile, &st) == -1)
11426 {
11427 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11428
11429 return (-1);
11430 }
11431
11432 hashes_avail = st.st_size / sizeof (hccap_t);
11433 }
11434 else
11435 {
11436 hashes_avail = 1;
11437 }
11438 }
11439 else if (hashlist_mode == HL_MODE_FILE)
11440 {
11441 char *hashfile = myargv[optind];
11442
11443 data.hashfile = hashfile;
11444
11445 logfile_top_var_string ("target", hashfile);
11446
11447 FILE *fp = NULL;
11448
11449 if ((fp = fopen (hashfile, "rb")) == NULL)
11450 {
11451 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11452
11453 return (-1);
11454 }
11455
11456 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11457
11458 hashes_avail = count_lines (fp);
11459
11460 rewind (fp);
11461
11462 if (hashes_avail == 0)
11463 {
11464 log_error ("ERROR: hashfile is empty or corrupt");
11465
11466 fclose (fp);
11467
11468 return (-1);
11469 }
11470
11471 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11472
11473 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11474 {
11475 log_error ("ERROR: remove not supported in native hashfile-format mode");
11476
11477 fclose (fp);
11478
11479 return (-1);
11480 }
11481
11482 fclose (fp);
11483 }
11484 }
11485 else
11486 {
11487 hashlist_mode = HL_MODE_ARG;
11488
11489 hashes_avail = 1;
11490 }
11491
11492 if (hash_mode == 3000) hashes_avail *= 2;
11493
11494 data.hashlist_mode = hashlist_mode;
11495 data.hashlist_format = hashlist_format;
11496
11497 logfile_top_uint (hashlist_mode);
11498 logfile_top_uint (hashlist_format);
11499
11500 /**
11501 * load hashes, part II: allocate required memory, set pointers
11502 */
11503
11504 hash_t *hashes_buf = NULL;
11505 void *digests_buf = NULL;
11506 salt_t *salts_buf = NULL;
11507 void *esalts_buf = NULL;
11508
11509 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11510
11511 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11512
11513 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11514 {
11515 u32 hash_pos;
11516
11517 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11518 {
11519 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11520
11521 hashes_buf[hash_pos].hash_info = hash_info;
11522
11523 if (username && (remove || show || left))
11524 {
11525 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11526 }
11527
11528 if (benchmark)
11529 {
11530 hash_info->orighash = (char *) mymalloc (256);
11531 }
11532 }
11533 }
11534
11535 if (isSalted)
11536 {
11537 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11538
11539 if (esalt_size)
11540 {
11541 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11542 }
11543 }
11544 else
11545 {
11546 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11547 }
11548
11549 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11550 {
11551 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11552
11553 if (isSalted)
11554 {
11555 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11556
11557 if (esalt_size)
11558 {
11559 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11560 }
11561 }
11562 else
11563 {
11564 hashes_buf[hash_pos].salt = &salts_buf[0];
11565 }
11566 }
11567
11568 /**
11569 * load hashes, part III: parse hashes or generate them if benchmark
11570 */
11571
11572 uint hashes_cnt = 0;
11573
11574 if (benchmark == 0)
11575 {
11576 if (keyspace == 1)
11577 {
11578 // useless to read hash file for keyspace, cheat a little bit w/ optind
11579 }
11580 else if (hashes_avail == 0)
11581 {
11582 }
11583 else if (hashlist_mode == HL_MODE_ARG)
11584 {
11585 char *input_buf = myargv[optind];
11586
11587 uint input_len = strlen (input_buf);
11588
11589 logfile_top_var_string ("target", input_buf);
11590
11591 char *hash_buf = NULL;
11592 int hash_len = 0;
11593
11594 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11595
11596 bool hash_fmt_error = 0;
11597
11598 if (hash_len < 1) hash_fmt_error = 1;
11599 if (hash_buf == NULL) hash_fmt_error = 1;
11600
11601 if (hash_fmt_error)
11602 {
11603 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11604 }
11605 else
11606 {
11607 if (opts_type & OPTS_TYPE_HASH_COPY)
11608 {
11609 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11610
11611 hash_info_tmp->orighash = mystrdup (hash_buf);
11612 }
11613
11614 if (isSalted)
11615 {
11616 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11617 }
11618
11619 int parser_status = PARSER_OK;
11620
11621 if (hash_mode == 2500)
11622 {
11623 if (hash_len == 0)
11624 {
11625 log_error ("ERROR: hccap file not specified");
11626
11627 return (-1);
11628 }
11629
11630 hashlist_mode = HL_MODE_FILE;
11631
11632 data.hashlist_mode = hashlist_mode;
11633
11634 FILE *fp = fopen (hash_buf, "rb");
11635
11636 if (fp == NULL)
11637 {
11638 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11639
11640 return (-1);
11641 }
11642
11643 if (hashes_avail < 1)
11644 {
11645 log_error ("ERROR: hccap file is empty or corrupt");
11646
11647 fclose (fp);
11648
11649 return (-1);
11650 }
11651
11652 uint hccap_size = sizeof (hccap_t);
11653
11654 char *in = (char *) mymalloc (hccap_size);
11655
11656 while (!feof (fp))
11657 {
11658 int n = fread (in, hccap_size, 1, fp);
11659
11660 if (n != 1)
11661 {
11662 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11663
11664 break;
11665 }
11666
11667 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11668
11669 if (parser_status != PARSER_OK)
11670 {
11671 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11672
11673 continue;
11674 }
11675
11676 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11677
11678 if ((show == 1) || (left == 1))
11679 {
11680 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11681
11682 char *salt_ptr = (char *) tmp_salt->salt_buf;
11683
11684 int cur_pos = tmp_salt->salt_len;
11685 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11686
11687 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11688
11689 // do the appending task
11690
11691 snprintf (salt_ptr + cur_pos,
11692 rem_len,
11693 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11694 wpa->orig_mac1[0],
11695 wpa->orig_mac1[1],
11696 wpa->orig_mac1[2],
11697 wpa->orig_mac1[3],
11698 wpa->orig_mac1[4],
11699 wpa->orig_mac1[5],
11700 wpa->orig_mac2[0],
11701 wpa->orig_mac2[1],
11702 wpa->orig_mac2[2],
11703 wpa->orig_mac2[3],
11704 wpa->orig_mac2[4],
11705 wpa->orig_mac2[5]);
11706
11707 // memset () the remaining part of the salt
11708
11709 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11710 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11711
11712 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11713
11714 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11715 }
11716
11717 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);
11718 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);
11719
11720 hashes_cnt++;
11721 }
11722
11723 fclose (fp);
11724
11725 myfree (in);
11726 }
11727 else if (hash_mode == 3000)
11728 {
11729 if (hash_len == 32)
11730 {
11731 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11732
11733 hash_t *lm_hash_left = NULL;
11734
11735 if (parser_status == PARSER_OK)
11736 {
11737 lm_hash_left = &hashes_buf[hashes_cnt];
11738
11739 hashes_cnt++;
11740 }
11741 else
11742 {
11743 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11744 }
11745
11746 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11747
11748 hash_t *lm_hash_right = NULL;
11749
11750 if (parser_status == PARSER_OK)
11751 {
11752 lm_hash_right = &hashes_buf[hashes_cnt];
11753
11754 hashes_cnt++;
11755 }
11756 else
11757 {
11758 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11759 }
11760
11761 // show / left
11762
11763 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11764 {
11765 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);
11766 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);
11767 }
11768 }
11769 else
11770 {
11771 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11772
11773 if (parser_status == PARSER_OK)
11774 {
11775 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11776 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11777 }
11778
11779 if (parser_status == PARSER_OK)
11780 {
11781 hashes_cnt++;
11782 }
11783 else
11784 {
11785 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11786 }
11787 }
11788 }
11789 else
11790 {
11791 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11792
11793 if (parser_status == PARSER_OK)
11794 {
11795 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11796 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11797 }
11798
11799 if (parser_status == PARSER_OK)
11800 {
11801 hashes_cnt++;
11802 }
11803 else
11804 {
11805 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11806 }
11807 }
11808 }
11809 }
11810 else if (hashlist_mode == HL_MODE_FILE)
11811 {
11812 char *hashfile = data.hashfile;
11813
11814 FILE *fp;
11815
11816 if ((fp = fopen (hashfile, "rb")) == NULL)
11817 {
11818 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11819
11820 return (-1);
11821 }
11822
11823 uint line_num = 0;
11824
11825 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11826
11827 while (!feof (fp))
11828 {
11829 line_num++;
11830
11831 int line_len = fgetl (fp, line_buf);
11832
11833 if (line_len == 0) continue;
11834
11835 char *hash_buf = NULL;
11836 int hash_len = 0;
11837
11838 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11839
11840 bool hash_fmt_error = 0;
11841
11842 if (hash_len < 1) hash_fmt_error = 1;
11843 if (hash_buf == NULL) hash_fmt_error = 1;
11844
11845 if (hash_fmt_error)
11846 {
11847 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11848
11849 continue;
11850 }
11851
11852 if (username)
11853 {
11854 char *user_buf = NULL;
11855 int user_len = 0;
11856
11857 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11858
11859 if (remove || show)
11860 {
11861 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11862
11863 *user = (user_t *) mymalloc (sizeof (user_t));
11864
11865 user_t *user_ptr = *user;
11866
11867 if (user_buf != NULL)
11868 {
11869 user_ptr->user_name = mystrdup (user_buf);
11870 }
11871 else
11872 {
11873 user_ptr->user_name = mystrdup ("");
11874 }
11875
11876 user_ptr->user_len = user_len;
11877 }
11878 }
11879
11880 if (opts_type & OPTS_TYPE_HASH_COPY)
11881 {
11882 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11883
11884 hash_info_tmp->orighash = mystrdup (hash_buf);
11885 }
11886
11887 if (isSalted)
11888 {
11889 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11890 }
11891
11892 if (hash_mode == 3000)
11893 {
11894 if (hash_len == 32)
11895 {
11896 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11897
11898 if (parser_status < PARSER_GLOBAL_ZERO)
11899 {
11900 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11901
11902 continue;
11903 }
11904
11905 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11906
11907 hashes_cnt++;
11908
11909 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11910
11911 if (parser_status < PARSER_GLOBAL_ZERO)
11912 {
11913 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11914
11915 continue;
11916 }
11917
11918 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11919
11920 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);
11921
11922 hashes_cnt++;
11923
11924 // show / left
11925
11926 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);
11927 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);
11928 }
11929 else
11930 {
11931 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11932
11933 if (parser_status < PARSER_GLOBAL_ZERO)
11934 {
11935 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11936
11937 continue;
11938 }
11939
11940 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);
11941
11942 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11943 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11944
11945 hashes_cnt++;
11946 }
11947 }
11948 else
11949 {
11950 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11951
11952 if (parser_status < PARSER_GLOBAL_ZERO)
11953 {
11954 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11955
11956 continue;
11957 }
11958
11959 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);
11960
11961 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11962 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11963
11964 hashes_cnt++;
11965 }
11966 }
11967
11968 myfree (line_buf);
11969
11970 fclose (fp);
11971
11972 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11973
11974 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11975 }
11976 }
11977 else
11978 {
11979 if (isSalted)
11980 {
11981 hashes_buf[0].salt->salt_len = 8;
11982
11983 // special salt handling
11984
11985 switch (hash_mode)
11986 {
11987 case 1500: hashes_buf[0].salt->salt_len = 2;
11988 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11989 break;
11990 case 1731: hashes_buf[0].salt->salt_len = 4;
11991 break;
11992 case 2410: hashes_buf[0].salt->salt_len = 4;
11993 break;
11994 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11995 break;
11996 case 3100: hashes_buf[0].salt->salt_len = 1;
11997 break;
11998 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11999 break;
12000 case 5800: hashes_buf[0].salt->salt_len = 16;
12001 break;
12002 case 6800: hashes_buf[0].salt->salt_len = 32;
12003 break;
12004 case 8400: hashes_buf[0].salt->salt_len = 40;
12005 break;
12006 case 8800: hashes_buf[0].salt->salt_len = 16;
12007 break;
12008 case 8900: hashes_buf[0].salt->salt_len = 16;
12009 hashes_buf[0].salt->scrypt_N = 1024;
12010 hashes_buf[0].salt->scrypt_r = 1;
12011 hashes_buf[0].salt->scrypt_p = 1;
12012 break;
12013 case 9100: hashes_buf[0].salt->salt_len = 16;
12014 break;
12015 case 9300: hashes_buf[0].salt->salt_len = 14;
12016 hashes_buf[0].salt->scrypt_N = 16384;
12017 hashes_buf[0].salt->scrypt_r = 1;
12018 hashes_buf[0].salt->scrypt_p = 1;
12019 break;
12020 case 9400: hashes_buf[0].salt->salt_len = 16;
12021 break;
12022 case 9500: hashes_buf[0].salt->salt_len = 16;
12023 break;
12024 case 9600: hashes_buf[0].salt->salt_len = 16;
12025 break;
12026 case 9700: hashes_buf[0].salt->salt_len = 16;
12027 break;
12028 case 9710: hashes_buf[0].salt->salt_len = 16;
12029 break;
12030 case 9720: hashes_buf[0].salt->salt_len = 16;
12031 break;
12032 case 9800: hashes_buf[0].salt->salt_len = 16;
12033 break;
12034 case 9810: hashes_buf[0].salt->salt_len = 16;
12035 break;
12036 case 9820: hashes_buf[0].salt->salt_len = 16;
12037 break;
12038 case 10300: hashes_buf[0].salt->salt_len = 12;
12039 break;
12040 case 11500: hashes_buf[0].salt->salt_len = 4;
12041 break;
12042 case 11600: hashes_buf[0].salt->salt_len = 4;
12043 break;
12044 case 12400: hashes_buf[0].salt->salt_len = 4;
12045 break;
12046 case 12500: hashes_buf[0].salt->salt_len = 8;
12047 break;
12048 case 12600: hashes_buf[0].salt->salt_len = 64;
12049 break;
12050 }
12051
12052 // special esalt handling
12053
12054 switch (hash_mode)
12055 {
12056 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12057 break;
12058 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12059 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12060 break;
12061 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12062 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12063 break;
12064 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12065 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12066 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12067 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12068 break;
12069 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12070 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12071 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12072 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12073 break;
12074 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12075 break;
12076 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12077 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12078 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12079 break;
12080 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12081 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12082 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12083 break;
12084 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12085 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12086 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12087 break;
12088 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12089 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12090 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12091 break;
12092 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12093 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12094 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12095 break;
12096 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12097 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12098 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12099 break;
12100 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12101 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12102 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12103 break;
12104 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12105 break;
12106 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12107 break;
12108 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12109 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12110 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12111 break;
12112 }
12113 }
12114
12115 // set hashfile
12116
12117 switch (hash_mode)
12118 {
12119 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12120 break;
12121 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12122 break;
12123 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12124 break;
12125 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12126 break;
12127 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12128 break;
12129 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12130 break;
12131 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12132 break;
12133 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12134 break;
12135 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12136 break;
12137 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12138 break;
12139 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12140 break;
12141 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12142 break;
12143 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12144 break;
12145 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12146 break;
12147 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12148 break;
12149 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12150 break;
12151 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12152 break;
12153 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12154 break;
12155 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12156 break;
12157 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12158 break;
12159 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12160 break;
12161 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12162 break;
12163 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12164 break;
12165 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12166 break;
12167 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12168 break;
12169 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12170 break;
12171 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12172 break;
12173 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12174 break;
12175 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12176 break;
12177 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12178 break;
12179 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12180 break;
12181 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12182 break;
12183 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12184 break;
12185 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12186 break;
12187 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12188 break;
12189 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12190 break;
12191 }
12192
12193 // set default iterations
12194
12195 switch (hash_mode)
12196 {
12197 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12198 break;
12199 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12200 break;
12201 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12202 break;
12203 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12204 break;
12205 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12206 break;
12207 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12208 break;
12209 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12210 break;
12211 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12212 break;
12213 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12214 break;
12215 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12216 break;
12217 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12218 break;
12219 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12220 break;
12221 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12222 break;
12223 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12224 break;
12225 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12226 break;
12227 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12228 break;
12229 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12230 break;
12231 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12232 break;
12233 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12234 break;
12235 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12236 break;
12237 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12238 break;
12239 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12240 break;
12241 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12242 break;
12243 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12244 break;
12245 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12246 break;
12247 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12248 break;
12249 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12250 break;
12251 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12252 break;
12253 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12254 break;
12255 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12256 break;
12257 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12258 break;
12259 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12260 break;
12261 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12262 break;
12263 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12264 break;
12265 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12266 break;
12267 case 8900: hashes_buf[0].salt->salt_iter = 1;
12268 break;
12269 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12270 break;
12271 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12272 break;
12273 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12274 break;
12275 case 9300: hashes_buf[0].salt->salt_iter = 1;
12276 break;
12277 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12278 break;
12279 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12280 break;
12281 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12282 break;
12283 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12284 break;
12285 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12286 break;
12287 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12288 break;
12289 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12290 break;
12291 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12292 break;
12293 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12294 break;
12295 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12296 break;
12297 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12298 break;
12299 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12300 break;
12301 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12302 break;
12303 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12304 break;
12305 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12306 break;
12307 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12308 break;
12309 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12310 break;
12311 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12312 break;
12313 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12314 break;
12315 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12316 break;
12317 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12318 break;
12319 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12320 break;
12321 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12322 break;
12323 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12324 break;
12325 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12326 break;
12327 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12328 break;
12329 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12330 break;
12331 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12332 break;
12333 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12334 break;
12335 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12336 break;
12337 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12338 break;
12339 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12340 break;
12341 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12342 break;
12343 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12344 break;
12345 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12346 break;
12347 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12348 break;
12349 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12350 break;
12351 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12352 break;
12353 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12354 break;
12355 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12356 break;
12357 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12358 break;
12359 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12360 break;
12361 }
12362
12363 hashes_cnt = 1;
12364 }
12365
12366 if (show == 1 || left == 1)
12367 {
12368 for (uint i = 0; i < pot_cnt; i++)
12369 {
12370 pot_t *pot_ptr = &pot[i];
12371
12372 hash_t *hashes_buf = &pot_ptr->hash;
12373
12374 local_free (hashes_buf->digest);
12375
12376 if (isSalted)
12377 {
12378 local_free (hashes_buf->salt);
12379 }
12380 }
12381
12382 local_free (pot);
12383
12384 if (data.quiet == 0) log_info_nn ("");
12385
12386 return (0);
12387 }
12388
12389 if (keyspace == 0)
12390 {
12391 if (hashes_cnt == 0)
12392 {
12393 log_error ("ERROR: No hashes loaded");
12394
12395 return (-1);
12396 }
12397 }
12398
12399 /**
12400 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12401 */
12402
12403 if (data.outfile != NULL)
12404 {
12405 if (data.hashfile != NULL)
12406 {
12407 #ifdef _POSIX
12408 struct stat tmpstat_outfile;
12409 struct stat tmpstat_hashfile;
12410 #endif
12411
12412 #ifdef _WIN
12413 struct stat64 tmpstat_outfile;
12414 struct stat64 tmpstat_hashfile;
12415 #endif
12416
12417 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12418
12419 if (tmp_outfile_fp)
12420 {
12421 #ifdef _POSIX
12422 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12423 #endif
12424
12425 #ifdef _WIN
12426 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12427 #endif
12428
12429 fclose (tmp_outfile_fp);
12430 }
12431
12432 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12433
12434 if (tmp_hashfile_fp)
12435 {
12436 #ifdef _POSIX
12437 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12438 #endif
12439
12440 #ifdef _WIN
12441 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12442 #endif
12443
12444 fclose (tmp_hashfile_fp);
12445 }
12446
12447 if (tmp_outfile_fp && tmp_outfile_fp)
12448 {
12449 tmpstat_outfile.st_mode = 0;
12450 tmpstat_outfile.st_nlink = 0;
12451 tmpstat_outfile.st_uid = 0;
12452 tmpstat_outfile.st_gid = 0;
12453 tmpstat_outfile.st_rdev = 0;
12454 tmpstat_outfile.st_atime = 0;
12455
12456 tmpstat_hashfile.st_mode = 0;
12457 tmpstat_hashfile.st_nlink = 0;
12458 tmpstat_hashfile.st_uid = 0;
12459 tmpstat_hashfile.st_gid = 0;
12460 tmpstat_hashfile.st_rdev = 0;
12461 tmpstat_hashfile.st_atime = 0;
12462
12463 #ifdef _POSIX
12464 tmpstat_outfile.st_blksize = 0;
12465 tmpstat_outfile.st_blocks = 0;
12466
12467 tmpstat_hashfile.st_blksize = 0;
12468 tmpstat_hashfile.st_blocks = 0;
12469 #endif
12470
12471 #ifdef _POSIX
12472 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12473 {
12474 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12475
12476 return (-1);
12477 }
12478 #endif
12479
12480 #ifdef _WIN
12481 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12482 {
12483 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12484
12485 return (-1);
12486 }
12487 #endif
12488 }
12489 }
12490 }
12491
12492 /**
12493 * Remove duplicates
12494 */
12495
12496 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12497
12498 if (isSalted)
12499 {
12500 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12501 }
12502 else
12503 {
12504 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12505 }
12506
12507 uint hashes_cnt_orig = hashes_cnt;
12508
12509 hashes_cnt = 1;
12510
12511 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12512 {
12513 if (isSalted)
12514 {
12515 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12516 {
12517 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12518 }
12519 }
12520 else
12521 {
12522 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12523 }
12524
12525 if (hashes_pos > hashes_cnt)
12526 {
12527 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12528 }
12529
12530 hashes_cnt++;
12531 }
12532
12533 /**
12534 * Potfile removes
12535 */
12536
12537 uint potfile_remove_cracks = 0;
12538
12539 if (potfile_disable == 0)
12540 {
12541 hash_t hash_buf;
12542
12543 hash_buf.digest = mymalloc (dgst_size);
12544 hash_buf.salt = NULL;
12545 hash_buf.esalt = NULL;
12546 hash_buf.hash_info = NULL;
12547 hash_buf.cracked = 0;
12548
12549 if (isSalted)
12550 {
12551 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12552 }
12553
12554 if (esalt_size)
12555 {
12556 hash_buf.esalt = mymalloc (esalt_size);
12557 }
12558
12559 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12560
12561 // no solution for these special hash types (for instane because they use hashfile in output etc)
12562 if ((hash_mode != 5200) &&
12563 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12564 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12565 (hash_mode != 9000))
12566 {
12567 FILE *fp = fopen (potfile, "rb");
12568
12569 if (fp != NULL)
12570 {
12571 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12572
12573 // to be safe work with a copy (because of line_len loop, i etc)
12574 // moved up here because it's easier to handle continue case
12575 // it's just 64kb
12576
12577 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12578
12579 while (!feof (fp))
12580 {
12581 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12582
12583 if (ptr == NULL) break;
12584
12585 int line_len = strlen (line_buf);
12586
12587 if (line_len == 0) continue;
12588
12589 int iter = MAX_CUT_TRIES;
12590
12591 for (int i = line_len - 1; i && iter; i--, line_len--)
12592 {
12593 if (line_buf[i] != ':') continue;
12594
12595 if (isSalted)
12596 {
12597 memset (hash_buf.salt, 0, sizeof (salt_t));
12598 }
12599
12600 hash_t *found = NULL;
12601
12602 if (hash_mode == 6800)
12603 {
12604 if (i < 64) // 64 = 16 * uint in salt_buf[]
12605 {
12606 // manipulate salt_buf
12607 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12608
12609 hash_buf.salt->salt_len = i;
12610
12611 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12612 }
12613 }
12614 else if (hash_mode == 2500)
12615 {
12616 if (i < 64) // 64 = 16 * uint in salt_buf[]
12617 {
12618 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12619 // manipulate salt_buf
12620
12621 memcpy (line_buf_cpy, line_buf, i);
12622
12623 char *mac2_pos = strrchr (line_buf_cpy, ':');
12624
12625 if (mac2_pos == NULL) continue;
12626
12627 mac2_pos[0] = 0;
12628 mac2_pos++;
12629
12630 if (strlen (mac2_pos) != 12) continue;
12631
12632 char *mac1_pos = strrchr (line_buf_cpy, ':');
12633
12634 if (mac1_pos == NULL) continue;
12635
12636 mac1_pos[0] = 0;
12637 mac1_pos++;
12638
12639 if (strlen (mac1_pos) != 12) continue;
12640
12641 uint essid_length = mac1_pos - line_buf_cpy - 1;
12642
12643 // here we need the ESSID
12644 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12645
12646 hash_buf.salt->salt_len = essid_length;
12647
12648 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12649
12650 if (found)
12651 {
12652 wpa_t *wpa = (wpa_t *) found->esalt;
12653
12654 // compare hex string(s) vs binary MAC address(es)
12655
12656 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12657 {
12658 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12659 {
12660 found = NULL;
12661
12662 break;
12663 }
12664 }
12665
12666 // early skip ;)
12667 if (!found) continue;
12668
12669 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12670 {
12671 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12672 {
12673 found = NULL;
12674
12675 break;
12676 }
12677 }
12678 }
12679 }
12680 }
12681 else
12682 {
12683 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12684
12685 if (parser_status == PARSER_OK)
12686 {
12687 if (isSalted)
12688 {
12689 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12690 }
12691 else
12692 {
12693 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12694 }
12695 }
12696 }
12697
12698 if (found == NULL) continue;
12699
12700 if (!found->cracked) potfile_remove_cracks++;
12701
12702 found->cracked = 1;
12703
12704 if (found) break;
12705
12706 iter--;
12707 }
12708 }
12709
12710 myfree (line_buf_cpy);
12711
12712 myfree (line_buf);
12713
12714 fclose (fp);
12715 }
12716 }
12717
12718 if (esalt_size)
12719 {
12720 local_free (hash_buf.esalt);
12721 }
12722
12723 if (isSalted)
12724 {
12725 local_free (hash_buf.salt);
12726 }
12727
12728 local_free (hash_buf.digest);
12729 }
12730
12731 /**
12732 * Now generate all the buffers required for later
12733 */
12734
12735 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12736
12737 salt_t *salts_buf_new = NULL;
12738 void *esalts_buf_new = NULL;
12739
12740 if (isSalted)
12741 {
12742 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12743
12744 if (esalt_size)
12745 {
12746 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12747 }
12748 }
12749 else
12750 {
12751 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12752 }
12753
12754 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12755
12756 uint digests_cnt = hashes_cnt;
12757 uint digests_done = 0;
12758
12759 size_t size_digests = digests_cnt * dgst_size;
12760 size_t size_shown = digests_cnt * sizeof (uint);
12761
12762 uint *digests_shown = (uint *) mymalloc (size_shown);
12763 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12764
12765 uint salts_cnt = 0;
12766 uint salts_done = 0;
12767
12768 hashinfo_t **hash_info = NULL;
12769
12770 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12771 {
12772 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12773
12774 if (username && (remove || show))
12775 {
12776 uint user_pos;
12777
12778 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12779 {
12780 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12781
12782 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12783 }
12784 }
12785 }
12786
12787 uint *salts_shown = (uint *) mymalloc (size_shown);
12788
12789 salt_t *salt_buf;
12790
12791 {
12792 // copied from inner loop
12793
12794 salt_buf = &salts_buf_new[salts_cnt];
12795
12796 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12797
12798 if (esalt_size)
12799 {
12800 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12801 }
12802
12803 salt_buf->digests_cnt = 0;
12804 salt_buf->digests_done = 0;
12805 salt_buf->digests_offset = 0;
12806
12807 salts_cnt++;
12808 }
12809
12810 if (hashes_buf[0].cracked == 1)
12811 {
12812 digests_shown[0] = 1;
12813
12814 digests_done++;
12815
12816 salt_buf->digests_done++;
12817 }
12818
12819 salt_buf->digests_cnt++;
12820
12821 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12822
12823 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12824 {
12825 hash_info[0] = hashes_buf[0].hash_info;
12826 }
12827
12828 // copy from inner loop
12829
12830 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12831 {
12832 if (isSalted)
12833 {
12834 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12835 {
12836 salt_buf = &salts_buf_new[salts_cnt];
12837
12838 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12839
12840 if (esalt_size)
12841 {
12842 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12843 }
12844
12845 salt_buf->digests_cnt = 0;
12846 salt_buf->digests_done = 0;
12847 salt_buf->digests_offset = hashes_pos;
12848
12849 salts_cnt++;
12850 }
12851 }
12852
12853 if (hashes_buf[hashes_pos].cracked == 1)
12854 {
12855 digests_shown[hashes_pos] = 1;
12856
12857 digests_done++;
12858
12859 salt_buf->digests_done++;
12860 }
12861
12862 salt_buf->digests_cnt++;
12863
12864 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12865
12866 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12867 {
12868 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12869 }
12870 }
12871
12872 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12873 {
12874 salt_t *salt_buf = &salts_buf_new[salt_pos];
12875
12876 if (salt_buf->digests_done == salt_buf->digests_cnt)
12877 {
12878 salts_shown[salt_pos] = 1;
12879
12880 salts_done++;
12881 }
12882
12883 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12884 }
12885
12886 local_free (digests_buf);
12887 local_free (salts_buf);
12888 local_free (esalts_buf);
12889
12890 digests_buf = digests_buf_new;
12891 salts_buf = salts_buf_new;
12892 esalts_buf = esalts_buf_new;
12893
12894 local_free (hashes_buf);
12895
12896 /**
12897 * special modification not set from parser
12898 */
12899
12900 switch (hash_mode)
12901 {
12902 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12903 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12904 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12905 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12906 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12907 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12908 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12909 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12910 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12911 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12912 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12913 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12914 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12915 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12916 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12917 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12918 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12919 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12920 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12921 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12922 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12923 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12924 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12925 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12926 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12927 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12928 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12929 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12930 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12931 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12932 }
12933
12934 if (truecrypt_keyfiles)
12935 {
12936 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12937
12938 char *keyfiles = strdup (truecrypt_keyfiles);
12939
12940 char *keyfile = strtok (keyfiles, ",");
12941
12942 do
12943 {
12944 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12945
12946 } while ((keyfile = strtok (NULL, ",")) != NULL);
12947
12948 free (keyfiles);
12949 }
12950
12951 if (veracrypt_keyfiles)
12952 {
12953 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12954
12955 char *keyfiles = strdup (veracrypt_keyfiles);
12956
12957 char *keyfile = strtok (keyfiles, ",");
12958
12959 do
12960 {
12961 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12962
12963 } while ((keyfile = strtok (NULL, ",")) != NULL);
12964
12965 free (keyfiles);
12966 }
12967
12968 data.digests_cnt = digests_cnt;
12969 data.digests_done = digests_done;
12970 data.digests_buf = digests_buf;
12971 data.digests_shown = digests_shown;
12972 data.digests_shown_tmp = digests_shown_tmp;
12973
12974 data.salts_cnt = salts_cnt;
12975 data.salts_done = salts_done;
12976 data.salts_buf = salts_buf;
12977 data.salts_shown = salts_shown;
12978
12979 data.esalts_buf = esalts_buf;
12980 data.hash_info = hash_info;
12981
12982 /**
12983 * Automatic Optimizers
12984 */
12985
12986 if (salts_cnt == 1)
12987 opti_type |= OPTI_TYPE_SINGLE_SALT;
12988
12989 if (digests_cnt == 1)
12990 opti_type |= OPTI_TYPE_SINGLE_HASH;
12991
12992 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12993 opti_type |= OPTI_TYPE_NOT_ITERATED;
12994
12995 if (attack_mode == ATTACK_MODE_BF)
12996 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12997
12998 data.opti_type = opti_type;
12999
13000 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13001 {
13002 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13003 {
13004 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13005 {
13006 if (opts_type & OPTS_TYPE_ST_ADD80)
13007 {
13008 opts_type &= ~OPTS_TYPE_ST_ADD80;
13009 opts_type |= OPTS_TYPE_PT_ADD80;
13010 }
13011
13012 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13013 {
13014 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13015 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13016 }
13017
13018 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13019 {
13020 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13021 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13022 }
13023 }
13024 }
13025 }
13026
13027 /**
13028 * Some algorithm, like descrypt, can benefit from JIT compilation
13029 */
13030
13031 int force_jit_compilation = -1;
13032
13033 if (hash_mode == 8900)
13034 {
13035 force_jit_compilation = 8900;
13036 }
13037 else if (hash_mode == 9300)
13038 {
13039 force_jit_compilation = 8900;
13040 }
13041 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13042 {
13043 force_jit_compilation = 1500;
13044 }
13045
13046 /**
13047 * generate bitmap tables
13048 */
13049
13050 const uint bitmap_shift1 = 5;
13051 const uint bitmap_shift2 = 13;
13052
13053 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13054
13055 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13056 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13057 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13058 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13059 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13060 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13061 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13062 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13063
13064 uint bitmap_bits;
13065 uint bitmap_nums;
13066 uint bitmap_mask;
13067 uint bitmap_size;
13068
13069 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13070 {
13071 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13072
13073 bitmap_nums = 1 << bitmap_bits;
13074
13075 bitmap_mask = bitmap_nums - 1;
13076
13077 bitmap_size = bitmap_nums * sizeof (uint);
13078
13079 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13080
13081 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;
13082 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;
13083
13084 break;
13085 }
13086
13087 bitmap_nums = 1 << bitmap_bits;
13088
13089 bitmap_mask = bitmap_nums - 1;
13090
13091 bitmap_size = bitmap_nums * sizeof (uint);
13092
13093 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);
13094 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);
13095
13096 /**
13097 * prepare quick rule
13098 */
13099
13100 data.rule_buf_l = rule_buf_l;
13101 data.rule_buf_r = rule_buf_r;
13102
13103 int rule_len_l = (int) strlen (rule_buf_l);
13104 int rule_len_r = (int) strlen (rule_buf_r);
13105
13106 data.rule_len_l = rule_len_l;
13107 data.rule_len_r = rule_len_r;
13108
13109 /**
13110 * load rules
13111 */
13112
13113 uint *all_kernel_rules_cnt = NULL;
13114
13115 kernel_rule_t **all_kernel_rules_buf = NULL;
13116
13117 if (rp_files_cnt)
13118 {
13119 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13120
13121 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13122 }
13123
13124 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13125
13126 int rule_len = 0;
13127
13128 for (uint i = 0; i < rp_files_cnt; i++)
13129 {
13130 uint kernel_rules_avail = 0;
13131
13132 uint kernel_rules_cnt = 0;
13133
13134 kernel_rule_t *kernel_rules_buf = NULL;
13135
13136 char *rp_file = rp_files[i];
13137
13138 char in[BLOCK_SIZE] = { 0 };
13139 char out[BLOCK_SIZE] = { 0 };
13140
13141 FILE *fp = NULL;
13142
13143 uint rule_line = 0;
13144
13145 if ((fp = fopen (rp_file, "rb")) == NULL)
13146 {
13147 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13148
13149 return (-1);
13150 }
13151
13152 while (!feof (fp))
13153 {
13154 memset (rule_buf, 0, HCBUFSIZ);
13155
13156 rule_len = fgetl (fp, rule_buf);
13157
13158 rule_line++;
13159
13160 if (rule_len == 0) continue;
13161
13162 if (rule_buf[0] == '#') continue;
13163
13164 if (kernel_rules_avail == kernel_rules_cnt)
13165 {
13166 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13167
13168 kernel_rules_avail += INCR_RULES;
13169 }
13170
13171 memset (in, 0, BLOCK_SIZE);
13172 memset (out, 0, BLOCK_SIZE);
13173
13174 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13175
13176 if (result == -1)
13177 {
13178 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13179
13180 continue;
13181 }
13182
13183 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13184 {
13185 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13186
13187 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13188
13189 continue;
13190 }
13191
13192 /* its so slow
13193 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13194 {
13195 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13196
13197 continue;
13198 }
13199 */
13200
13201 kernel_rules_cnt++;
13202 }
13203
13204 fclose (fp);
13205
13206 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13207
13208 all_kernel_rules_buf[i] = kernel_rules_buf;
13209 }
13210
13211 /**
13212 * merge rules or automatic rule generator
13213 */
13214
13215 uint kernel_rules_cnt = 0;
13216
13217 kernel_rule_t *kernel_rules_buf = NULL;
13218
13219 if (attack_mode == ATTACK_MODE_STRAIGHT)
13220 {
13221 if (rp_files_cnt)
13222 {
13223 kernel_rules_cnt = 1;
13224
13225 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13226
13227 repeats[0] = kernel_rules_cnt;
13228
13229 for (uint i = 0; i < rp_files_cnt; i++)
13230 {
13231 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13232
13233 repeats[i + 1] = kernel_rules_cnt;
13234 }
13235
13236 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13237
13238 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13239
13240 for (uint i = 0; i < kernel_rules_cnt; i++)
13241 {
13242 uint out_pos = 0;
13243
13244 kernel_rule_t *out = &kernel_rules_buf[i];
13245
13246 for (uint j = 0; j < rp_files_cnt; j++)
13247 {
13248 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13249 uint in_pos;
13250
13251 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13252
13253 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13254 {
13255 if (out_pos == RULES_MAX - 1)
13256 {
13257 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13258
13259 break;
13260 }
13261
13262 out->cmds[out_pos] = in->cmds[in_pos];
13263 }
13264 }
13265 }
13266
13267 local_free (repeats);
13268 }
13269 else if (rp_gen)
13270 {
13271 uint kernel_rules_avail = 0;
13272
13273 while (kernel_rules_cnt < rp_gen)
13274 {
13275 if (kernel_rules_avail == kernel_rules_cnt)
13276 {
13277 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13278
13279 kernel_rules_avail += INCR_RULES;
13280 }
13281
13282 memset (rule_buf, 0, HCBUFSIZ);
13283
13284 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13285
13286 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13287
13288 kernel_rules_cnt++;
13289 }
13290 }
13291 }
13292
13293 myfree (rule_buf);
13294
13295 /**
13296 * generate NOP rules
13297 */
13298
13299 if (kernel_rules_cnt == 0)
13300 {
13301 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13302
13303 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13304
13305 kernel_rules_cnt++;
13306 }
13307
13308 data.kernel_rules_cnt = kernel_rules_cnt;
13309 data.kernel_rules_buf = kernel_rules_buf;
13310
13311 /**
13312 * OpenCL platforms: detect
13313 */
13314
13315 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13316 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13317
13318 cl_uint platforms_cnt = 0;
13319 cl_uint platform_devices_cnt = 0;
13320
13321 if (keyspace == 0)
13322 {
13323 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13324
13325 if (platforms_cnt == 0)
13326 {
13327 log_info ("");
13328 log_info ("ATTENTION! No OpenCL compatible platform found");
13329 log_info ("");
13330 log_info ("You're probably missing the OpenCL runtime installation");
13331 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13332 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13333 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13334 log_info ("");
13335
13336 return (-1);
13337 }
13338
13339 if (opencl_platforms_filter != (uint) -1)
13340 {
13341 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13342
13343 if (opencl_platforms_filter > platform_cnt_mask)
13344 {
13345 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13346
13347 return (-1);
13348 }
13349 }
13350 }
13351
13352 /**
13353 * OpenCL device types:
13354 * 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.
13355 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13356 */
13357
13358 if (opencl_device_types == NULL)
13359 {
13360 cl_device_type device_types_all = 0;
13361
13362 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13363 {
13364 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13365
13366 cl_platform_id platform = platforms[platform_id];
13367
13368 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13369
13370 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13371 {
13372 cl_device_id device = platform_devices[platform_devices_id];
13373
13374 cl_device_type device_type;
13375
13376 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13377
13378 device_types_all |= device_type;
13379 }
13380 }
13381
13382 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13383 {
13384 device_types_filter |= CL_DEVICE_TYPE_CPU;
13385 }
13386 }
13387
13388 /**
13389 * OpenCL devices: simply push all devices from all platforms into the same device array
13390 */
13391
13392 int need_adl = 0;
13393 int need_nvapi = 0;
13394 int need_nvml = 0;
13395
13396 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13397
13398 data.devices_param = devices_param;
13399
13400 uint devices_cnt = 0;
13401
13402 uint devices_active = 0;
13403
13404 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13405 {
13406 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13407
13408 cl_platform_id platform = platforms[platform_id];
13409
13410 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13411
13412 char platform_vendor[INFOSZ] = { 0 };
13413
13414 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13415
13416 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13417 // this causes trouble with vendor id based macros
13418 // we'll assign generic to those without special optimization available
13419
13420 cl_uint platform_vendor_id = 0;
13421
13422 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13423 {
13424 platform_vendor_id = VENDOR_ID_AMD;
13425 }
13426 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13427 {
13428 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13429 }
13430 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13431 {
13432 platform_vendor_id = VENDOR_ID_APPLE;
13433 }
13434 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13435 {
13436 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13437 }
13438 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13439 {
13440 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13441 }
13442 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13443 {
13444 platform_vendor_id = VENDOR_ID_MESA;
13445 }
13446 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13447 {
13448 platform_vendor_id = VENDOR_ID_NV;
13449 }
13450 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13451 {
13452 platform_vendor_id = VENDOR_ID_POCL;
13453 }
13454 else
13455 {
13456 platform_vendor_id = VENDOR_ID_GENERIC;
13457 }
13458
13459 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13460 {
13461 size_t param_value_size = 0;
13462
13463 const uint device_id = devices_cnt;
13464
13465 hc_device_param_t *device_param = &data.devices_param[device_id];
13466
13467 device_param->platform_vendor_id = platform_vendor_id;
13468
13469 device_param->device = platform_devices[platform_devices_id];
13470
13471 device_param->device_id = device_id;
13472
13473 device_param->platform_devices_id = platform_devices_id;
13474
13475 // device_type
13476
13477 cl_device_type device_type;
13478
13479 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13480
13481 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13482
13483 device_param->device_type = device_type;
13484
13485 // device_name
13486
13487 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13488
13489 char *device_name = (char *) mymalloc (param_value_size);
13490
13491 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13492
13493 device_param->device_name = device_name;
13494
13495 // device_vendor
13496
13497 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13498
13499 char *device_vendor = (char *) mymalloc (param_value_size);
13500
13501 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13502
13503 device_param->device_vendor = device_vendor;
13504
13505 cl_uint device_vendor_id = 0;
13506
13507 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13508 {
13509 device_vendor_id = VENDOR_ID_AMD;
13510 }
13511 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13512 {
13513 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13514 }
13515 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13516 {
13517 device_vendor_id = VENDOR_ID_APPLE;
13518 }
13519 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13520 {
13521 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13522 }
13523 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13524 {
13525 device_vendor_id = VENDOR_ID_INTEL_SDK;
13526 }
13527 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13528 {
13529 device_vendor_id = VENDOR_ID_MESA;
13530 }
13531 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13532 {
13533 device_vendor_id = VENDOR_ID_NV;
13534 }
13535 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13536 {
13537 device_vendor_id = VENDOR_ID_POCL;
13538 }
13539 else
13540 {
13541 device_vendor_id = VENDOR_ID_GENERIC;
13542 }
13543
13544 device_param->device_vendor_id = device_vendor_id;
13545
13546 // tuning db
13547
13548 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13549
13550 // device_version
13551
13552 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13553
13554 char *device_version = (char *) mymalloc (param_value_size);
13555
13556 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13557
13558 device_param->device_version = device_version;
13559
13560 // device_opencl_version
13561
13562 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13563
13564 char *device_opencl_version = (char *) mymalloc (param_value_size);
13565
13566 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13567
13568 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13569
13570 myfree (device_opencl_version);
13571
13572 // vector_width
13573
13574 cl_uint vector_width;
13575
13576 if (opencl_vector_width_chgd == 0)
13577 {
13578 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13579 {
13580 if (opti_type & OPTI_TYPE_USES_BITS_64)
13581 {
13582 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13583 }
13584 else
13585 {
13586 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13587 }
13588 }
13589 else
13590 {
13591 vector_width = (cl_uint) tuningdb_entry->vector_width;
13592 }
13593 }
13594 else
13595 {
13596 vector_width = opencl_vector_width;
13597 }
13598
13599 if (vector_width > 16) vector_width = 16;
13600
13601 device_param->vector_width = vector_width;
13602
13603 // max_compute_units
13604
13605 cl_uint device_processors;
13606
13607 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13608
13609 device_param->device_processors = device_processors;
13610
13611 // device_maxmem_alloc
13612 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13613
13614 cl_ulong device_maxmem_alloc;
13615
13616 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13617
13618 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13619
13620 // device_global_mem
13621
13622 cl_ulong device_global_mem;
13623
13624 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13625
13626 device_param->device_global_mem = device_global_mem;
13627
13628 // max_work_group_size
13629
13630 size_t device_maxworkgroup_size;
13631
13632 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13633
13634 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13635
13636 // max_clock_frequency
13637
13638 cl_uint device_maxclock_frequency;
13639
13640 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13641
13642 device_param->device_maxclock_frequency = device_maxclock_frequency;
13643
13644 // device_endian_little
13645
13646 cl_bool device_endian_little;
13647
13648 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13649
13650 if (device_endian_little == CL_FALSE)
13651 {
13652 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13653
13654 device_param->skipped = 1;
13655 }
13656
13657 // device_available
13658
13659 cl_bool device_available;
13660
13661 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13662
13663 if (device_available == CL_FALSE)
13664 {
13665 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13666
13667 device_param->skipped = 1;
13668 }
13669
13670 // device_compiler_available
13671
13672 cl_bool device_compiler_available;
13673
13674 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13675
13676 if (device_compiler_available == CL_FALSE)
13677 {
13678 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13679
13680 device_param->skipped = 1;
13681 }
13682
13683 // device_execution_capabilities
13684
13685 cl_device_exec_capabilities device_execution_capabilities;
13686
13687 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13688
13689 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13690 {
13691 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13692
13693 device_param->skipped = 1;
13694 }
13695
13696 // device_extensions
13697
13698 size_t device_extensions_size;
13699
13700 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13701
13702 char *device_extensions = mymalloc (device_extensions_size + 1);
13703
13704 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13705
13706 if (strstr (device_extensions, "base_atomics") == 0)
13707 {
13708 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13709
13710 device_param->skipped = 1;
13711 }
13712
13713 if (strstr (device_extensions, "byte_addressable_store") == 0)
13714 {
13715 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13716
13717 device_param->skipped = 1;
13718 }
13719
13720 myfree (device_extensions);
13721
13722 // device_local_mem_size
13723
13724 cl_ulong device_local_mem_size;
13725
13726 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13727
13728 if (device_local_mem_size < 32768)
13729 {
13730 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13731
13732 device_param->skipped = 1;
13733 }
13734
13735 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13736 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13737 // This results in both utilizing it for 50%
13738 // However, Intel has much better SIMD control over their own hardware
13739 // It makes sense to give them full control over their own hardware
13740
13741 if (device_type & CL_DEVICE_TYPE_CPU)
13742 {
13743 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13744 {
13745 if (data.force == 0)
13746 {
13747 if (algorithm_pos == 0)
13748 {
13749 log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
13750 log_info (" You can use --force to override this but do not post error reports if you do so");
13751 }
13752
13753 device_param->skipped = 1;
13754 }
13755 }
13756 }
13757
13758 // skipped
13759
13760 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13761 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13762
13763 // driver_version
13764
13765 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13766
13767 char *driver_version = (char *) mymalloc (param_value_size);
13768
13769 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13770
13771 device_param->driver_version = driver_version;
13772
13773 // device_name_chksum
13774
13775 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13776
13777 #if __x86_64__
13778 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);
13779 #else
13780 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);
13781 #endif
13782
13783 uint device_name_digest[4] = { 0 };
13784
13785 md5_64 ((uint *) device_name_chksum, device_name_digest);
13786
13787 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13788
13789 device_param->device_name_chksum = device_name_chksum;
13790
13791 // device_processor_cores
13792
13793 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
13794 {
13795 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
13796 {
13797 need_adl = 1;
13798 }
13799
13800 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
13801 {
13802 need_nvml = 1;
13803
13804 #ifdef _WIN
13805 need_nvapi = 1;
13806 #endif
13807 }
13808 }
13809
13810 // device_processor_cores
13811
13812 if (device_type & CL_DEVICE_TYPE_CPU)
13813 {
13814 cl_uint device_processor_cores = 1;
13815
13816 device_param->device_processor_cores = device_processor_cores;
13817 }
13818
13819 if (device_type & CL_DEVICE_TYPE_GPU)
13820 {
13821 if (device_vendor_id == VENDOR_ID_AMD)
13822 {
13823 cl_uint device_processor_cores = 0;
13824
13825 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13826
13827 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13828
13829 device_param->device_processor_cores = device_processor_cores;
13830 }
13831 else if (device_vendor_id == VENDOR_ID_NV)
13832 {
13833 cl_uint kernel_exec_timeout = 0;
13834
13835 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13836
13837 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13838
13839 device_param->kernel_exec_timeout = kernel_exec_timeout;
13840
13841 cl_uint device_processor_cores = 0;
13842
13843 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13844
13845 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13846
13847 device_param->device_processor_cores = device_processor_cores;
13848
13849 cl_uint sm_minor = 0;
13850 cl_uint sm_major = 0;
13851
13852 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13853 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13854
13855 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13856 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13857
13858 device_param->sm_minor = sm_minor;
13859 device_param->sm_major = sm_major;
13860 }
13861 else
13862 {
13863 cl_uint device_processor_cores = 1;
13864
13865 device_param->device_processor_cores = device_processor_cores;
13866 }
13867 }
13868
13869 // display results
13870
13871 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13872 {
13873 if (machine_readable == 0)
13874 {
13875 if (device_param->skipped == 0)
13876 {
13877 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13878 device_id + 1,
13879 device_name,
13880 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13881 (unsigned int) (device_global_mem / 1024 / 1024),
13882 (unsigned int) device_processors);
13883 }
13884 else
13885 {
13886 log_info ("Device #%u: %s, skipped",
13887 device_id + 1,
13888 device_name);
13889 }
13890 }
13891 }
13892
13893 // common driver check
13894
13895 if (device_param->skipped == 0)
13896 {
13897 if (device_type & CL_DEVICE_TYPE_GPU)
13898 {
13899 if (platform_vendor_id == VENDOR_ID_AMD)
13900 {
13901 int catalyst_check = (force == 1) ? 0 : 1;
13902
13903 int catalyst_warn = 0;
13904
13905 int catalyst_broken = 0;
13906
13907 if (catalyst_check == 1)
13908 {
13909 catalyst_warn = 1;
13910
13911 // v14.9 and higher
13912 if (atoi (device_param->driver_version) >= 1573)
13913 {
13914 catalyst_warn = 0;
13915 }
13916
13917 catalyst_check = 0;
13918 }
13919
13920 if (catalyst_broken == 1)
13921 {
13922 log_info ("");
13923 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13924 log_info ("It will pass over cracked hashes and does not report them as cracked");
13925 log_info ("You are STRONGLY encouraged not to use it");
13926 log_info ("You can use --force to override this but do not post error reports if you do so");
13927 log_info ("");
13928
13929 return (-1);
13930 }
13931
13932 if (catalyst_warn == 1)
13933 {
13934 log_info ("");
13935 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13936 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13937 log_info ("See hashcat's homepage for official supported catalyst drivers");
13938 #ifdef _WIN
13939 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13940 #endif
13941 log_info ("You can use --force to override this but do not post error reports if you do so");
13942 log_info ("");
13943
13944 return (-1);
13945 }
13946 }
13947 else if (platform_vendor_id == VENDOR_ID_NV)
13948 {
13949 if (device_param->kernel_exec_timeout != 0)
13950 {
13951 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);
13952 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13953 }
13954 }
13955 }
13956
13957 /* turns out pocl still creates segfaults (because of llvm)
13958 if (device_type & CL_DEVICE_TYPE_CPU)
13959 {
13960 if (platform_vendor_id == VENDOR_ID_AMD)
13961 {
13962 if (force == 0)
13963 {
13964 log_info ("");
13965 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13966 log_info ("You are STRONGLY encouraged not to use it");
13967 log_info ("You can use --force to override this but do not post error reports if you do so");
13968 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13969 log_info ("");
13970
13971 return (-1);
13972 }
13973 }
13974 }
13975 */
13976
13977 /**
13978 * kernel accel and loops tuning db adjustment
13979 */
13980
13981 device_param->kernel_accel_min = 1;
13982 device_param->kernel_accel_max = 1024;
13983
13984 device_param->kernel_loops_min = 1;
13985 device_param->kernel_loops_max = 1024;
13986
13987 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13988
13989 if (tuningdb_entry)
13990 {
13991 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13992 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13993
13994 if (_kernel_accel)
13995 {
13996 device_param->kernel_accel_min = _kernel_accel;
13997 device_param->kernel_accel_max = _kernel_accel;
13998 }
13999
14000 if (_kernel_loops)
14001 {
14002 if (workload_profile == 1)
14003 {
14004 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14005 }
14006 else if (workload_profile == 2)
14007 {
14008 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14009 }
14010
14011 device_param->kernel_loops_min = _kernel_loops;
14012 device_param->kernel_loops_max = _kernel_loops;
14013 }
14014 }
14015
14016 // commandline parameters overwrite tuningdb entries
14017
14018 if (kernel_accel)
14019 {
14020 device_param->kernel_accel_min = kernel_accel;
14021 device_param->kernel_accel_max = kernel_accel;
14022 }
14023
14024 if (kernel_loops)
14025 {
14026 device_param->kernel_loops_min = kernel_loops;
14027 device_param->kernel_loops_max = kernel_loops;
14028 }
14029
14030 /**
14031 * activate device
14032 */
14033
14034 devices_active++;
14035 }
14036
14037 // next please
14038
14039 devices_cnt++;
14040 }
14041 }
14042
14043 if (keyspace == 0 && devices_active == 0)
14044 {
14045 log_error ("ERROR: No devices found/left");
14046
14047 return (-1);
14048 }
14049
14050 // 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)
14051
14052 if (devices_filter != (uint) -1)
14053 {
14054 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14055
14056 if (devices_filter > devices_cnt_mask)
14057 {
14058 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14059
14060 return (-1);
14061 }
14062 }
14063
14064 data.devices_cnt = devices_cnt;
14065
14066 data.devices_active = devices_active;
14067
14068 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14069 {
14070 if (machine_readable == 0)
14071 {
14072 log_info ("");
14073 }
14074 }
14075
14076 /**
14077 * HM devices: init
14078 */
14079
14080 #ifdef HAVE_HWMON
14081 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14082 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14083 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14084
14085 if (gpu_temp_disable == 0)
14086 {
14087 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14088 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14089 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14090
14091 data.hm_adl = NULL;
14092 data.hm_nvapi = NULL;
14093 data.hm_nvml = NULL;
14094
14095 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14096 {
14097 data.hm_nvml = nvml;
14098 }
14099
14100 if (data.hm_nvml)
14101 {
14102 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14103 {
14104 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14105
14106 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14107
14108 int tmp_out = 0;
14109
14110 for (int i = 0; i < tmp_in; i++)
14111 {
14112 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14113 }
14114
14115 for (int i = 0; i < tmp_out; i++)
14116 {
14117 unsigned int speed;
14118
14119 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14120
14121 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14122
14123 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14124 }
14125 }
14126 }
14127
14128 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14129 {
14130 data.hm_nvapi = nvapi;
14131 }
14132
14133 if (data.hm_nvapi)
14134 {
14135 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14136 {
14137 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14138
14139 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14140
14141 int tmp_out = 0;
14142
14143 for (int i = 0; i < tmp_in; i++)
14144 {
14145 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14146 }
14147 }
14148 }
14149
14150 if ((need_adl == 1) && (adl_init (adl) == 0))
14151 {
14152 data.hm_adl = adl;
14153 }
14154
14155 if (data.hm_adl)
14156 {
14157 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14158 {
14159 // total number of adapters
14160
14161 int hm_adapters_num;
14162
14163 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14164
14165 // adapter info
14166
14167 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14168
14169 if (lpAdapterInfo == NULL) return (-1);
14170
14171 // get a list (of ids of) valid/usable adapters
14172
14173 int num_adl_adapters = 0;
14174
14175 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14176
14177 if (num_adl_adapters > 0)
14178 {
14179 hc_thread_mutex_lock (mux_adl);
14180
14181 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14182
14183 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14184
14185 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14186 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14187
14188 hc_thread_mutex_unlock (mux_adl);
14189 }
14190
14191 myfree (valid_adl_device_list);
14192 myfree (lpAdapterInfo);
14193 }
14194 }
14195
14196 if (data.hm_adl == NULL && data.hm_nvml == NULL)
14197 {
14198 gpu_temp_disable = 1;
14199 }
14200 }
14201
14202 /**
14203 * OpenCL devices: allocate buffer for device specific information
14204 */
14205
14206 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14207 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14208
14209 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14210
14211 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14212
14213 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14214
14215 /**
14216 * User-defined GPU temp handling
14217 */
14218
14219 if (gpu_temp_disable == 1)
14220 {
14221 gpu_temp_abort = 0;
14222 gpu_temp_retain = 0;
14223 }
14224
14225 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14226 {
14227 if (gpu_temp_abort < gpu_temp_retain)
14228 {
14229 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14230
14231 return (-1);
14232 }
14233 }
14234
14235 data.gpu_temp_disable = gpu_temp_disable;
14236 data.gpu_temp_abort = gpu_temp_abort;
14237 data.gpu_temp_retain = gpu_temp_retain;
14238 #endif
14239
14240 /**
14241 * enable custom signal handler(s)
14242 */
14243
14244 if (benchmark == 0)
14245 {
14246 hc_signal (sigHandler_default);
14247 }
14248 else
14249 {
14250 hc_signal (sigHandler_benchmark);
14251 }
14252
14253 /**
14254 * inform the user
14255 */
14256
14257 if (data.quiet == 0)
14258 {
14259 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14260
14261 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);
14262
14263 if (attack_mode == ATTACK_MODE_STRAIGHT)
14264 {
14265 log_info ("Rules: %u", kernel_rules_cnt);
14266 }
14267
14268 if (opti_type)
14269 {
14270 log_info ("Applicable Optimizers:");
14271
14272 for (uint i = 0; i < 32; i++)
14273 {
14274 const uint opti_bit = 1u << i;
14275
14276 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14277 }
14278 }
14279
14280 /**
14281 * Watchdog and Temperature balance
14282 */
14283
14284 #ifdef HAVE_HWMON
14285 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL)
14286 {
14287 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14288 }
14289
14290 if (gpu_temp_abort == 0)
14291 {
14292 log_info ("Watchdog: Temperature abort trigger disabled");
14293 }
14294 else
14295 {
14296 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14297 }
14298
14299 if (gpu_temp_retain == 0)
14300 {
14301 log_info ("Watchdog: Temperature retain trigger disabled");
14302 }
14303 else
14304 {
14305 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14306 }
14307
14308 if (data.quiet == 0) log_info ("");
14309 #endif
14310 }
14311
14312 #ifdef HAVE_HWMON
14313
14314 /**
14315 * HM devices: copy
14316 */
14317
14318 if (gpu_temp_disable == 0)
14319 {
14320 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14321 {
14322 hc_device_param_t *device_param = &data.devices_param[device_id];
14323
14324 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14325
14326 if (device_param->skipped) continue;
14327
14328 const uint platform_devices_id = device_param->platform_devices_id;
14329
14330 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14331 {
14332 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14333 data.hm_device[device_id].nvapi = 0;
14334 data.hm_device[device_id].nvml = 0;
14335 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14336 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14337 data.hm_device[device_id].fan_set_supported = hm_adapters_adl[platform_devices_id].fan_set_supported;
14338 }
14339
14340 if (device_param->device_vendor_id == VENDOR_ID_NV)
14341 {
14342 data.hm_device[device_id].adl = 0;
14343 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14344 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14345 data.hm_device[device_id].od_version = 0;
14346 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14347 data.hm_device[device_id].fan_set_supported = 0;
14348 }
14349 }
14350 }
14351
14352 /**
14353 * powertune on user request
14354 */
14355
14356 if (powertune_enable == 1)
14357 {
14358 hc_thread_mutex_lock (mux_adl);
14359
14360 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14361 {
14362 hc_device_param_t *device_param = &data.devices_param[device_id];
14363
14364 if (device_param->skipped) continue;
14365
14366 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14367 {
14368 /**
14369 * Temporary fix:
14370 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14371 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14372 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14373 * Driver / ADL bug?
14374 */
14375
14376 if (data.hm_device[device_id].od_version == 6)
14377 {
14378 int ADL_rc;
14379
14380 // check powertune capabilities first, if not available then skip device
14381
14382 int powertune_supported = 0;
14383
14384 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14385 {
14386 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14387
14388 return (-1);
14389 }
14390
14391 // first backup current value, we will restore it later
14392
14393 if (powertune_supported != 0)
14394 {
14395 // powercontrol settings
14396
14397 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14398
14399 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14400 {
14401 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14402 }
14403
14404 if (ADL_rc != ADL_OK)
14405 {
14406 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14407
14408 return (-1);
14409 }
14410
14411 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14412 {
14413 log_error ("ERROR: Failed to set new ADL PowerControl values");
14414
14415 return (-1);
14416 }
14417
14418 // clocks
14419
14420 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14421
14422 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14423
14424 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)
14425 {
14426 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14427
14428 return (-1);
14429 }
14430
14431 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14432
14433 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14434
14435 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14436 {
14437 log_error ("ERROR: Failed to get ADL device capabilities");
14438
14439 return (-1);
14440 }
14441
14442 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14443 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14444
14445 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14446 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14447
14448 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14449 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14450
14451 // warning if profile has too low max values
14452
14453 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14454 {
14455 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14456 }
14457
14458 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14459 {
14460 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14461 }
14462
14463 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14464
14465 performance_state->iNumberOfPerformanceLevels = 2;
14466
14467 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14468 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14469 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14470 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14471
14472 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)
14473 {
14474 log_info ("ERROR: Failed to set ADL performance state");
14475
14476 return (-1);
14477 }
14478
14479 local_free (performance_state);
14480 }
14481
14482 // set powertune value only
14483
14484 if (powertune_supported != 0)
14485 {
14486 // powertune set
14487 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14488
14489 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14490 {
14491 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14492
14493 return (-1);
14494 }
14495
14496 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14497 {
14498 log_error ("ERROR: Failed to set new ADL PowerControl values");
14499
14500 return (-1);
14501 }
14502 }
14503 }
14504 }
14505
14506 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14507 {
14508 // first backup current value, we will restore it later
14509
14510 unsigned int limit;
14511
14512 int powertune_supported = 0;
14513
14514 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14515 {
14516 powertune_supported = 1;
14517 }
14518
14519 // if backup worked, activate the maximum allowed
14520
14521 if (powertune_supported != 0)
14522 {
14523 unsigned int minLimit;
14524 unsigned int maxLimit;
14525
14526 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14527 {
14528 if (maxLimit > 0)
14529 {
14530 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14531 {
14532 // now we can be sure we need to reset later
14533
14534 nvml_power_limit[device_id] = limit;
14535 }
14536 }
14537 }
14538 }
14539 }
14540 }
14541
14542 hc_thread_mutex_unlock (mux_adl);
14543 }
14544
14545 #endif // HAVE_HWMON
14546
14547 #ifdef DEBUG
14548 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14549 #endif
14550
14551 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14552
14553 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14554 {
14555 /**
14556 * host buffer
14557 */
14558
14559 hc_device_param_t *device_param = &data.devices_param[device_id];
14560
14561 if (device_param->skipped) continue;
14562
14563 /**
14564 * device properties
14565 */
14566
14567 const char *device_name_chksum = device_param->device_name_chksum;
14568 const u32 device_processors = device_param->device_processors;
14569 const u32 device_processor_cores = device_param->device_processor_cores;
14570
14571 /**
14572 * create context for each device
14573 */
14574
14575 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14576
14577 /**
14578 * create command-queue
14579 */
14580
14581 // not supported with NV
14582 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14583
14584 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14585
14586 /**
14587 * kernel threads: some algorithms need a fixed kernel-threads count
14588 * because of shared memory usage or bitslice
14589 * there needs to be some upper limit, otherwise there's too much overhead
14590 */
14591
14592 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14593
14594 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14595 {
14596 kernel_threads = KERNEL_THREADS_MAX_CPU;
14597 }
14598
14599 if (hash_mode == 1500) kernel_threads = 64; // DES
14600 if (hash_mode == 3000) kernel_threads = 64; // DES
14601 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14602 if (hash_mode == 7500) kernel_threads = 64; // RC4
14603 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14604 if (hash_mode == 9700) kernel_threads = 64; // RC4
14605 if (hash_mode == 9710) kernel_threads = 64; // RC4
14606 if (hash_mode == 9800) kernel_threads = 64; // RC4
14607 if (hash_mode == 9810) kernel_threads = 64; // RC4
14608 if (hash_mode == 10400) kernel_threads = 64; // RC4
14609 if (hash_mode == 10410) kernel_threads = 64; // RC4
14610 if (hash_mode == 10500) kernel_threads = 64; // RC4
14611 if (hash_mode == 13100) kernel_threads = 64; // RC4
14612
14613 device_param->kernel_threads = kernel_threads;
14614
14615 device_param->hardware_power = device_processors * kernel_threads;
14616
14617 /**
14618 * create input buffers on device : calculate size of fixed memory buffers
14619 */
14620
14621 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14622 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14623
14624 device_param->size_root_css = size_root_css;
14625 device_param->size_markov_css = size_markov_css;
14626
14627 size_t size_results = sizeof (uint);
14628
14629 device_param->size_results = size_results;
14630
14631 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14632 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14633
14634 size_t size_plains = digests_cnt * sizeof (plain_t);
14635 size_t size_salts = salts_cnt * sizeof (salt_t);
14636 size_t size_esalts = salts_cnt * esalt_size;
14637
14638 device_param->size_plains = size_plains;
14639 device_param->size_digests = size_digests;
14640 device_param->size_shown = size_shown;
14641 device_param->size_salts = size_salts;
14642
14643 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14644 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14645 size_t size_tm = 32 * sizeof (bs_word_t);
14646
14647 // scryptV stuff
14648
14649 size_t size_scryptV = 1;
14650
14651 if ((hash_mode == 8900) || (hash_mode == 9300))
14652 {
14653 uint tmto_start = 0;
14654 uint tmto_stop = 10;
14655
14656 if (scrypt_tmto)
14657 {
14658 tmto_start = scrypt_tmto;
14659 }
14660 else
14661 {
14662 // in case the user did not specify the tmto manually
14663 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14664 // but set the lower end only in case the user has a device with too less memory
14665
14666 if (hash_mode == 8900)
14667 {
14668 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14669 {
14670 tmto_start = 1;
14671 }
14672 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14673 {
14674 tmto_start = 2;
14675 }
14676 }
14677 else if (hash_mode == 9300)
14678 {
14679 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14680 {
14681 tmto_start = 2;
14682 }
14683 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14684 {
14685 tmto_start = 2;
14686 }
14687 }
14688 }
14689
14690 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14691 {
14692 // TODO: in theory the following calculation needs to be done per salt, not global
14693 // we assume all hashes have the same scrypt settings
14694
14695 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14696
14697 size_scryptV /= 1 << tmto;
14698
14699 size_scryptV *= device_processors * device_processor_cores;
14700
14701 if (size_scryptV > device_param->device_maxmem_alloc)
14702 {
14703 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14704
14705 continue;
14706 }
14707
14708 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14709 {
14710 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14711 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14712 }
14713
14714 break;
14715 }
14716
14717 if (data.salts_buf[0].scrypt_phy == 0)
14718 {
14719 log_error ("ERROR: can't allocate enough device memory");
14720
14721 return -1;
14722 }
14723
14724 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14725 }
14726
14727 /**
14728 * some algorithms need a fixed kernel-loops count
14729 */
14730
14731 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
14732 {
14733 const u32 kernel_loops_fixed = 1024;
14734
14735 device_param->kernel_loops_min = kernel_loops_fixed;
14736 device_param->kernel_loops_max = kernel_loops_fixed;
14737 }
14738
14739 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
14740 {
14741 const u32 kernel_loops_fixed = 1024;
14742
14743 device_param->kernel_loops_min = kernel_loops_fixed;
14744 device_param->kernel_loops_max = kernel_loops_fixed;
14745 }
14746
14747 if (hash_mode == 8900)
14748 {
14749 const u32 kernel_loops_fixed = 1;
14750
14751 device_param->kernel_loops_min = kernel_loops_fixed;
14752 device_param->kernel_loops_max = kernel_loops_fixed;
14753 }
14754
14755 if (hash_mode == 9300)
14756 {
14757 const u32 kernel_loops_fixed = 1;
14758
14759 device_param->kernel_loops_min = kernel_loops_fixed;
14760 device_param->kernel_loops_max = kernel_loops_fixed;
14761 }
14762
14763 if (hash_mode == 12500)
14764 {
14765 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14766
14767 device_param->kernel_loops_min = kernel_loops_fixed;
14768 device_param->kernel_loops_max = kernel_loops_fixed;
14769 }
14770
14771 /**
14772 * some algorithms have a maximum kernel-loops count
14773 */
14774
14775 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14776 {
14777 u32 innerloop_cnt = 0;
14778
14779 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14780 {
14781 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14782 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14783 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14784 }
14785 else
14786 {
14787 innerloop_cnt = data.salts_buf[0].salt_iter;
14788 }
14789
14790 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14791 (innerloop_cnt <= device_param->kernel_loops_max))
14792 {
14793 device_param->kernel_loops_max = innerloop_cnt;
14794 }
14795 }
14796
14797 u32 kernel_accel_min = device_param->kernel_accel_min;
14798 u32 kernel_accel_max = device_param->kernel_accel_max;
14799
14800 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14801
14802 size_t size_pws = 4;
14803 size_t size_tmps = 4;
14804 size_t size_hooks = 4;
14805
14806 while (kernel_accel_max >= kernel_accel_min)
14807 {
14808 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14809
14810 // size_pws
14811
14812 size_pws = kernel_power_max * sizeof (pw_t);
14813
14814 // size_tmps
14815
14816 switch (hash_mode)
14817 {
14818 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14819 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14820 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14821 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14822 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14823 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14824 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14825 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14826 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14827 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14828 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14829 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14830 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14831 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14832 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14833 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14834 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14835 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14836 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14837 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14838 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14839 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14840 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14841 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14842 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14843 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14844 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14845 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14846 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14847 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14848 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14849 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14850 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14851 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14852 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14853 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14854 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14855 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14856 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14857 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14858 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14859 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14860 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14861 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14862 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14863 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14864 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14865 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14866 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14867 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14868 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14869 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14870 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14871 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14872 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14873 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14874 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14875 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14876 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14877 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14878 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14879 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14880 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14881 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14882 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14883 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14884 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14885 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14886 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14887 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14888 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14889 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14890 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14891 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14892 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14893 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14894 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14895 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14896 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14897 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14898 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14899 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14900 };
14901
14902 // size_hooks
14903
14904 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14905 {
14906 // none yet
14907 }
14908
14909 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14910 // if not, decrease amplifier and try again
14911
14912 int skip = 0;
14913
14914 const u64 size_total
14915 = bitmap_size
14916 + bitmap_size
14917 + bitmap_size
14918 + bitmap_size
14919 + bitmap_size
14920 + bitmap_size
14921 + bitmap_size
14922 + bitmap_size
14923 + size_bfs
14924 + size_combs
14925 + size_digests
14926 + size_esalts
14927 + size_hooks
14928 + size_markov_css
14929 + size_plains
14930 + size_pws
14931 + size_pws // not a bug
14932 + size_results
14933 + size_root_css
14934 + size_rules
14935 + size_rules_c
14936 + size_salts
14937 + size_scryptV
14938 + size_shown
14939 + size_tm
14940 + size_tmps;
14941
14942 // Don't ask me, ask AMD!
14943
14944 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14945 if (size_total > device_param->device_global_mem) skip = 1;
14946
14947 if (skip == 1)
14948 {
14949 kernel_accel_max--;
14950
14951 continue;
14952 }
14953
14954 break;
14955 }
14956
14957 /*
14958 if (kernel_accel_max == 0)
14959 {
14960 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14961
14962 return -1;
14963 }
14964 */
14965
14966 device_param->kernel_accel_min = kernel_accel_min;
14967 device_param->kernel_accel_max = kernel_accel_max;
14968
14969 /*
14970 if (kernel_accel_max < kernel_accel)
14971 {
14972 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14973
14974 device_param->kernel_accel = kernel_accel_max;
14975 }
14976 */
14977
14978 device_param->size_bfs = size_bfs;
14979 device_param->size_combs = size_combs;
14980 device_param->size_rules = size_rules;
14981 device_param->size_rules_c = size_rules_c;
14982 device_param->size_pws = size_pws;
14983 device_param->size_tmps = size_tmps;
14984 device_param->size_hooks = size_hooks;
14985
14986 /**
14987 * default building options
14988 */
14989
14990 char build_opts[1024] = { 0 };
14991
14992 // we don't have sm_* on vendors not NV but it doesn't matter
14993
14994 #if _WIN
14995 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\\OpenCL\\\" -I '%s\\OpenCL\\' -I %s\\OpenCL\\ -I\"%s\\OpenCL\\\" -I'%s\\OpenCL\\' -I%s\\OpenCL\\", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
14996 #else
14997 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s/OpenCL/\" -I '%s/OpenCL/' -I %s/OpenCL/ -I\"%s/OpenCL/\" -I'%s/OpenCL/' -I%s/OpenCL/", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
14998 #endif
14999
15000 char build_opts_new[1024] = { 0 };
15001
15002 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_TYPE=%u -D_unroll -cl-std=CL1.1", build_opts, device_param->device_vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
15003
15004 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15005
15006 /*
15007 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
15008 {
15009 // we do vectorizing much better than the auto-vectorizer
15010
15011 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
15012
15013 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15014 }
15015 */
15016
15017 #ifdef DEBUG
15018 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15019 #endif
15020
15021 /**
15022 * main kernel
15023 */
15024
15025 {
15026 /**
15027 * kernel source filename
15028 */
15029
15030 char source_file[256] = { 0 };
15031
15032 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15033
15034 struct stat sst;
15035
15036 if (stat (source_file, &sst) == -1)
15037 {
15038 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15039
15040 return -1;
15041 }
15042
15043 /**
15044 * kernel cached filename
15045 */
15046
15047 char cached_file[256] = { 0 };
15048
15049 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15050
15051 int cached = 1;
15052
15053 struct stat cst;
15054
15055 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15056 {
15057 cached = 0;
15058 }
15059
15060 /**
15061 * kernel compile or load
15062 */
15063
15064 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15065
15066 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15067
15068 if (force_jit_compilation == -1)
15069 {
15070 if (cached == 0)
15071 {
15072 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15073
15074 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15075
15076 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15077
15078 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15079
15080 #ifdef DEBUG
15081 size_t build_log_size = 0;
15082
15083 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15084
15085 if (build_log_size > 1)
15086 {
15087 char *build_log = (char *) malloc (build_log_size + 1);
15088
15089 memset (build_log, 0, build_log_size + 1);
15090
15091 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15092
15093 puts (build_log);
15094
15095 free (build_log);
15096 }
15097 #endif
15098
15099 if (rc != 0)
15100 {
15101 device_param->skipped = true;
15102
15103 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15104
15105 continue;
15106 }
15107
15108 size_t binary_size;
15109
15110 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15111
15112 u8 *binary = (u8 *) mymalloc (binary_size);
15113
15114 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15115
15116 writeProgramBin (cached_file, binary, binary_size);
15117
15118 local_free (binary);
15119 }
15120 else
15121 {
15122 #ifdef DEBUG
15123 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15124 #endif
15125
15126 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15127
15128 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15129
15130 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15131 }
15132 }
15133 else
15134 {
15135 #ifdef DEBUG
15136 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15137 #endif
15138
15139 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15140
15141 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15142
15143 char build_opts_update[1024] = { 0 };
15144
15145 if (force_jit_compilation == 1500)
15146 {
15147 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15148 }
15149 else if (force_jit_compilation == 8900)
15150 {
15151 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);
15152 }
15153 else
15154 {
15155 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15156 }
15157
15158 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15159
15160 #ifdef DEBUG
15161 size_t build_log_size = 0;
15162
15163 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15164
15165 if (build_log_size > 1)
15166 {
15167 char *build_log = (char *) malloc (build_log_size + 1);
15168
15169 memset (build_log, 0, build_log_size + 1);
15170
15171 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15172
15173 puts (build_log);
15174
15175 free (build_log);
15176 }
15177 #endif
15178
15179 if (rc != 0)
15180 {
15181 device_param->skipped = true;
15182
15183 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15184 }
15185 }
15186
15187 local_free (kernel_lengths);
15188 local_free (kernel_sources[0]);
15189 local_free (kernel_sources);
15190 }
15191
15192 /**
15193 * word generator kernel
15194 */
15195
15196 if (attack_mode != ATTACK_MODE_STRAIGHT)
15197 {
15198 /**
15199 * kernel mp source filename
15200 */
15201
15202 char source_file[256] = { 0 };
15203
15204 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15205
15206 struct stat sst;
15207
15208 if (stat (source_file, &sst) == -1)
15209 {
15210 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15211
15212 return -1;
15213 }
15214
15215 /**
15216 * kernel mp cached filename
15217 */
15218
15219 char cached_file[256] = { 0 };
15220
15221 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15222
15223 int cached = 1;
15224
15225 struct stat cst;
15226
15227 if (stat (cached_file, &cst) == -1)
15228 {
15229 cached = 0;
15230 }
15231
15232 /**
15233 * kernel compile or load
15234 */
15235
15236 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15237
15238 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15239
15240 if (cached == 0)
15241 {
15242 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15243 if (quiet == 0) log_info ("");
15244
15245 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15246
15247 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15248
15249 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15250
15251 if (rc != 0)
15252 {
15253 device_param->skipped = true;
15254
15255 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15256
15257 continue;
15258 }
15259
15260 size_t binary_size;
15261
15262 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15263
15264 u8 *binary = (u8 *) mymalloc (binary_size);
15265
15266 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15267
15268 writeProgramBin (cached_file, binary, binary_size);
15269
15270 local_free (binary);
15271 }
15272 else
15273 {
15274 #ifdef DEBUG
15275 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15276 #endif
15277
15278 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15279
15280 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15281
15282 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15283 }
15284
15285 local_free (kernel_lengths);
15286 local_free (kernel_sources[0]);
15287 local_free (kernel_sources);
15288 }
15289
15290 /**
15291 * amplifier kernel
15292 */
15293
15294 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15295 {
15296
15297 }
15298 else
15299 {
15300 /**
15301 * kernel amp source filename
15302 */
15303
15304 char source_file[256] = { 0 };
15305
15306 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15307
15308 struct stat sst;
15309
15310 if (stat (source_file, &sst) == -1)
15311 {
15312 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15313
15314 return -1;
15315 }
15316
15317 /**
15318 * kernel amp cached filename
15319 */
15320
15321 char cached_file[256] = { 0 };
15322
15323 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15324
15325 int cached = 1;
15326
15327 struct stat cst;
15328
15329 if (stat (cached_file, &cst) == -1)
15330 {
15331 cached = 0;
15332 }
15333
15334 /**
15335 * kernel compile or load
15336 */
15337
15338 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15339
15340 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15341
15342 if (cached == 0)
15343 {
15344 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15345 if (quiet == 0) log_info ("");
15346
15347 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15348
15349 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15350
15351 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15352
15353 if (rc != 0)
15354 {
15355 device_param->skipped = true;
15356
15357 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15358
15359 continue;
15360 }
15361
15362 size_t binary_size;
15363
15364 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15365
15366 u8 *binary = (u8 *) mymalloc (binary_size);
15367
15368 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15369
15370 writeProgramBin (cached_file, binary, binary_size);
15371
15372 local_free (binary);
15373 }
15374 else
15375 {
15376 #ifdef DEBUG
15377 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15378 #endif
15379
15380 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15381
15382 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15383
15384 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15385 }
15386
15387 local_free (kernel_lengths);
15388 local_free (kernel_sources[0]);
15389 local_free (kernel_sources);
15390 }
15391
15392 // some algorithm collide too fast, make that impossible
15393
15394 if (benchmark == 1)
15395 {
15396 ((uint *) digests_buf)[0] = -1;
15397 ((uint *) digests_buf)[1] = -1;
15398 ((uint *) digests_buf)[2] = -1;
15399 ((uint *) digests_buf)[3] = -1;
15400 }
15401
15402 /**
15403 * global buffers
15404 */
15405
15406 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15407 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15408 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15409 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15410 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15411 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15412 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15413 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15414 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15415 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15416 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15417 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15418 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15419 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15420 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15421 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15422 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15423 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15424
15425 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);
15426 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);
15427 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);
15428 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);
15429 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);
15430 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);
15431 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);
15432 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);
15433 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15434 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15435 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15436
15437 /**
15438 * special buffers
15439 */
15440
15441 if (attack_kern == ATTACK_KERN_STRAIGHT)
15442 {
15443 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15444 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15445
15446 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15447 }
15448 else if (attack_kern == ATTACK_KERN_COMBI)
15449 {
15450 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15451 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15452 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15453 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15454 }
15455 else if (attack_kern == ATTACK_KERN_BF)
15456 {
15457 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15458 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15459 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15460 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15461 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15462 }
15463
15464 if (size_esalts)
15465 {
15466 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15467
15468 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15469 }
15470
15471 /**
15472 * main host data
15473 */
15474
15475 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15476
15477 device_param->pws_buf = pws_buf;
15478
15479 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15480
15481 device_param->combs_buf = combs_buf;
15482
15483 void *hooks_buf = mymalloc (size_hooks);
15484
15485 device_param->hooks_buf = hooks_buf;
15486
15487 /**
15488 * kernel args
15489 */
15490
15491 device_param->kernel_params_buf32[21] = bitmap_mask;
15492 device_param->kernel_params_buf32[22] = bitmap_shift1;
15493 device_param->kernel_params_buf32[23] = bitmap_shift2;
15494 device_param->kernel_params_buf32[24] = 0; // salt_pos
15495 device_param->kernel_params_buf32[25] = 0; // loop_pos
15496 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15497 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15498 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15499 device_param->kernel_params_buf32[29] = 0; // digests_offset
15500 device_param->kernel_params_buf32[30] = 0; // combs_mode
15501 device_param->kernel_params_buf32[31] = 0; // gid_max
15502
15503 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15504 ? &device_param->d_pws_buf
15505 : &device_param->d_pws_amp_buf;
15506 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15507 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15508 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15509 device_param->kernel_params[ 4] = &device_param->d_tmps;
15510 device_param->kernel_params[ 5] = &device_param->d_hooks;
15511 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15512 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15513 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15514 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15515 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15516 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15517 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15518 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15519 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15520 device_param->kernel_params[15] = &device_param->d_digests_buf;
15521 device_param->kernel_params[16] = &device_param->d_digests_shown;
15522 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15523 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15524 device_param->kernel_params[19] = &device_param->d_result;
15525 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15526 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15527 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15528 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15529 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15530 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15531 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15532 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15533 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15534 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15535 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15536 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15537
15538 device_param->kernel_params_mp_buf64[3] = 0;
15539 device_param->kernel_params_mp_buf32[4] = 0;
15540 device_param->kernel_params_mp_buf32[5] = 0;
15541 device_param->kernel_params_mp_buf32[6] = 0;
15542 device_param->kernel_params_mp_buf32[7] = 0;
15543 device_param->kernel_params_mp_buf32[8] = 0;
15544
15545 device_param->kernel_params_mp[0] = NULL;
15546 device_param->kernel_params_mp[1] = NULL;
15547 device_param->kernel_params_mp[2] = NULL;
15548 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15549 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15550 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15551 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15552 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15553 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15554
15555 device_param->kernel_params_mp_l_buf64[3] = 0;
15556 device_param->kernel_params_mp_l_buf32[4] = 0;
15557 device_param->kernel_params_mp_l_buf32[5] = 0;
15558 device_param->kernel_params_mp_l_buf32[6] = 0;
15559 device_param->kernel_params_mp_l_buf32[7] = 0;
15560 device_param->kernel_params_mp_l_buf32[8] = 0;
15561 device_param->kernel_params_mp_l_buf32[9] = 0;
15562
15563 device_param->kernel_params_mp_l[0] = NULL;
15564 device_param->kernel_params_mp_l[1] = NULL;
15565 device_param->kernel_params_mp_l[2] = NULL;
15566 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15567 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15568 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15569 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15570 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15571 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15572 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15573
15574 device_param->kernel_params_mp_r_buf64[3] = 0;
15575 device_param->kernel_params_mp_r_buf32[4] = 0;
15576 device_param->kernel_params_mp_r_buf32[5] = 0;
15577 device_param->kernel_params_mp_r_buf32[6] = 0;
15578 device_param->kernel_params_mp_r_buf32[7] = 0;
15579 device_param->kernel_params_mp_r_buf32[8] = 0;
15580
15581 device_param->kernel_params_mp_r[0] = NULL;
15582 device_param->kernel_params_mp_r[1] = NULL;
15583 device_param->kernel_params_mp_r[2] = NULL;
15584 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15585 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15586 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15587 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15588 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15589 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15590
15591 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15592 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15593
15594 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15595 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15596 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15597 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15598 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15599 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15600 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15601
15602 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15603 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15604
15605 device_param->kernel_params_memset_buf32[1] = 0; // value
15606 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15607
15608 device_param->kernel_params_memset[0] = NULL;
15609 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15610 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15611
15612 /**
15613 * kernel name
15614 */
15615
15616 size_t kernel_wgs_tmp;
15617
15618 char kernel_name[64] = { 0 };
15619
15620 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15621 {
15622 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15623 {
15624 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15625
15626 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15627
15628 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15629
15630 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15631
15632 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15633
15634 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15635 }
15636 else
15637 {
15638 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15639
15640 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15641
15642 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15643
15644 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15645
15646 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15647
15648 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15649 }
15650
15651 if (data.attack_mode == ATTACK_MODE_BF)
15652 {
15653 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15654 {
15655 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15656
15657 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15658
15659 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);
15660 }
15661 }
15662 }
15663 else
15664 {
15665 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15666
15667 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15668
15669 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15670
15671 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15672
15673 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15674
15675 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15676
15677 if (opts_type & OPTS_TYPE_HOOK12)
15678 {
15679 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15680
15681 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15682
15683 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);
15684 }
15685
15686 if (opts_type & OPTS_TYPE_HOOK23)
15687 {
15688 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15689
15690 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15691
15692 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);
15693 }
15694 }
15695
15696 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);
15697 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);
15698 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);
15699
15700 for (uint i = 0; i <= 20; i++)
15701 {
15702 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15703 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15704 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15705
15706 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15707 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15708 }
15709
15710 for (uint i = 21; i <= 31; i++)
15711 {
15712 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15713 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15714 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15715
15716 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15717 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15718 }
15719
15720 // GPU memset
15721
15722 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15723
15724 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);
15725
15726 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15727 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15728 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15729
15730 // MP start
15731
15732 if (attack_mode == ATTACK_MODE_BF)
15733 {
15734 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15735 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15736
15737 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);
15738 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);
15739
15740 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15741 {
15742 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15743 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15744 }
15745 }
15746 else if (attack_mode == ATTACK_MODE_HYBRID1)
15747 {
15748 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15749
15750 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);
15751 }
15752 else if (attack_mode == ATTACK_MODE_HYBRID2)
15753 {
15754 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15755
15756 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);
15757 }
15758
15759 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15760 {
15761 // nothing to do
15762 }
15763 else
15764 {
15765 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15766
15767 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);
15768 }
15769
15770 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15771 {
15772 // nothing to do
15773 }
15774 else
15775 {
15776 for (uint i = 0; i < 5; i++)
15777 {
15778 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15779 }
15780
15781 for (uint i = 5; i < 7; i++)
15782 {
15783 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15784 }
15785 }
15786
15787 // maybe this has been updated by clGetKernelWorkGroupInfo()
15788 // value can only be decreased, so we don't need to reallocate buffers
15789
15790 device_param->kernel_threads = kernel_threads;
15791
15792 // zero some data buffers
15793
15794 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15795 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15796 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15797 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15798 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15799 run_kernel_bzero (device_param, device_param->d_result, size_results);
15800
15801 /**
15802 * special buffers
15803 */
15804
15805 if (attack_kern == ATTACK_KERN_STRAIGHT)
15806 {
15807 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15808 }
15809 else if (attack_kern == ATTACK_KERN_COMBI)
15810 {
15811 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15812 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15813 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15814 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15815 }
15816 else if (attack_kern == ATTACK_KERN_BF)
15817 {
15818 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15819 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15820 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15821 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15822 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15823 }
15824
15825 #if defined(HAVE_HWMON)
15826
15827 /**
15828 * Store initial fanspeed if gpu_temp_retain is enabled
15829 */
15830
15831 if (gpu_temp_disable == 0)
15832 {
15833 if (gpu_temp_retain != 0)
15834 {
15835 hc_thread_mutex_lock (mux_adl);
15836
15837 if (data.hm_device[device_id].fan_get_supported == 1)
15838 {
15839 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
15840 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
15841
15842 temp_retain_fanspeed_value[device_id] = fanspeed;
15843 temp_retain_fanpolicy_value[device_id] = fanpolicy;
15844
15845 // we also set it to tell the OS we take control over the fan and it's automatic controller
15846 // if it was set to automatic. we do not control user-defined fanspeeds.
15847
15848 if (fanpolicy == 1)
15849 {
15850 data.hm_device[device_id].fan_set_supported = 1;
15851
15852 int rc = -1;
15853
15854 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15855 {
15856 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
15857 }
15858 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15859 {
15860
15861 }
15862
15863 if (rc == 0)
15864 {
15865 data.hm_device[device_id].fan_set_supported = 1;
15866 }
15867 else
15868 {
15869 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
15870
15871 data.hm_device[device_id].fan_set_supported = 0;
15872 }
15873 }
15874 else
15875 {
15876 data.hm_device[device_id].fan_set_supported = 0;
15877 }
15878 }
15879
15880 hc_thread_mutex_unlock (mux_adl);
15881 }
15882 }
15883
15884 #endif // HAVE_HWMON
15885 }
15886
15887 if (data.quiet == 0) log_info_nn ("");
15888
15889 /**
15890 * In benchmark-mode, inform user which algorithm is checked
15891 */
15892
15893 if (benchmark == 1)
15894 {
15895 if (machine_readable == 0)
15896 {
15897 quiet = 0;
15898
15899 data.quiet = quiet;
15900
15901 char *hash_type = strhashtype (data.hash_mode); // not a bug
15902
15903 log_info ("Hashtype: %s", hash_type);
15904 log_info ("");
15905 }
15906 }
15907
15908 /**
15909 * keep track of the progress
15910 */
15911
15912 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15913 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15914 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15915
15916 /**
15917 * open filehandles
15918 */
15919
15920 #if _WIN
15921 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15922 {
15923 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15924
15925 return (-1);
15926 }
15927
15928 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15929 {
15930 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15931
15932 return (-1);
15933 }
15934
15935 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15936 {
15937 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15938
15939 return (-1);
15940 }
15941 #endif
15942
15943 /**
15944 * dictionary pad
15945 */
15946
15947 segment_size *= (1024 * 1024);
15948
15949 data.segment_size = segment_size;
15950
15951 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15952
15953 wl_data->buf = (char *) mymalloc (segment_size);
15954 wl_data->avail = segment_size;
15955 wl_data->incr = segment_size;
15956 wl_data->cnt = 0;
15957 wl_data->pos = 0;
15958
15959 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15960
15961 data.wordlist_mode = wordlist_mode;
15962
15963 cs_t *css_buf = NULL;
15964 uint css_cnt = 0;
15965 uint dictcnt = 0;
15966 uint maskcnt = 1;
15967 char **masks = NULL;
15968 char **dictfiles = NULL;
15969
15970 uint mask_from_file = 0;
15971
15972 if (attack_mode == ATTACK_MODE_STRAIGHT)
15973 {
15974 if (wordlist_mode == WL_MODE_FILE)
15975 {
15976 int wls_left = myargc - (optind + 1);
15977
15978 for (int i = 0; i < wls_left; i++)
15979 {
15980 char *l0_filename = myargv[optind + 1 + i];
15981
15982 struct stat l0_stat;
15983
15984 if (stat (l0_filename, &l0_stat) == -1)
15985 {
15986 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15987
15988 return (-1);
15989 }
15990
15991 uint is_dir = S_ISDIR (l0_stat.st_mode);
15992
15993 if (is_dir == 0)
15994 {
15995 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15996
15997 dictcnt++;
15998
15999 dictfiles[dictcnt - 1] = l0_filename;
16000 }
16001 else
16002 {
16003 // do not allow --keyspace w/ a directory
16004
16005 if (keyspace == 1)
16006 {
16007 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16008
16009 return (-1);
16010 }
16011
16012 char **dictionary_files = NULL;
16013
16014 dictionary_files = scan_directory (l0_filename);
16015
16016 if (dictionary_files != NULL)
16017 {
16018 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16019
16020 for (int d = 0; dictionary_files[d] != NULL; d++)
16021 {
16022 char *l1_filename = dictionary_files[d];
16023
16024 struct stat l1_stat;
16025
16026 if (stat (l1_filename, &l1_stat) == -1)
16027 {
16028 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16029
16030 return (-1);
16031 }
16032
16033 if (S_ISREG (l1_stat.st_mode))
16034 {
16035 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16036
16037 dictcnt++;
16038
16039 dictfiles[dictcnt - 1] = strdup (l1_filename);
16040 }
16041 }
16042 }
16043
16044 local_free (dictionary_files);
16045 }
16046 }
16047
16048 if (dictcnt < 1)
16049 {
16050 log_error ("ERROR: No usable dictionary file found.");
16051
16052 return (-1);
16053 }
16054 }
16055 else if (wordlist_mode == WL_MODE_STDIN)
16056 {
16057 dictcnt = 1;
16058 }
16059 }
16060 else if (attack_mode == ATTACK_MODE_COMBI)
16061 {
16062 // display
16063
16064 char *dictfile1 = myargv[optind + 1 + 0];
16065 char *dictfile2 = myargv[optind + 1 + 1];
16066
16067 // find the bigger dictionary and use as base
16068
16069 FILE *fp1 = NULL;
16070 FILE *fp2 = NULL;
16071
16072 struct stat tmp_stat;
16073
16074 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16075 {
16076 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16077
16078 return (-1);
16079 }
16080
16081 if (stat (dictfile1, &tmp_stat) == -1)
16082 {
16083 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16084
16085 fclose (fp1);
16086
16087 return (-1);
16088 }
16089
16090 if (S_ISDIR (tmp_stat.st_mode))
16091 {
16092 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16093
16094 fclose (fp1);
16095
16096 return (-1);
16097 }
16098
16099 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16100 {
16101 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16102
16103 fclose (fp1);
16104
16105 return (-1);
16106 }
16107
16108 if (stat (dictfile2, &tmp_stat) == -1)
16109 {
16110 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16111
16112 fclose (fp1);
16113 fclose (fp2);
16114
16115 return (-1);
16116 }
16117
16118 if (S_ISDIR (tmp_stat.st_mode))
16119 {
16120 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16121
16122 fclose (fp1);
16123 fclose (fp2);
16124
16125 return (-1);
16126 }
16127
16128 data.combs_cnt = 1;
16129
16130 data.quiet = 1;
16131
16132 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16133
16134 data.quiet = quiet;
16135
16136 if (words1_cnt == 0)
16137 {
16138 log_error ("ERROR: %s: empty file", dictfile1);
16139
16140 fclose (fp1);
16141 fclose (fp2);
16142
16143 return (-1);
16144 }
16145
16146 data.combs_cnt = 1;
16147
16148 data.quiet = 1;
16149
16150 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16151
16152 data.quiet = quiet;
16153
16154 if (words2_cnt == 0)
16155 {
16156 log_error ("ERROR: %s: empty file", dictfile2);
16157
16158 fclose (fp1);
16159 fclose (fp2);
16160
16161 return (-1);
16162 }
16163
16164 fclose (fp1);
16165 fclose (fp2);
16166
16167 data.dictfile = dictfile1;
16168 data.dictfile2 = dictfile2;
16169
16170 if (words1_cnt >= words2_cnt)
16171 {
16172 data.combs_cnt = words2_cnt;
16173 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16174
16175 dictfiles = &data.dictfile;
16176
16177 dictcnt = 1;
16178 }
16179 else
16180 {
16181 data.combs_cnt = words1_cnt;
16182 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16183
16184 dictfiles = &data.dictfile2;
16185
16186 dictcnt = 1;
16187
16188 // we also have to switch wordlist related rules!
16189
16190 char *tmpc = data.rule_buf_l;
16191
16192 data.rule_buf_l = data.rule_buf_r;
16193 data.rule_buf_r = tmpc;
16194
16195 int tmpi = data.rule_len_l;
16196
16197 data.rule_len_l = data.rule_len_r;
16198 data.rule_len_r = tmpi;
16199 }
16200 }
16201 else if (attack_mode == ATTACK_MODE_BF)
16202 {
16203 char *mask = NULL;
16204
16205 maskcnt = 0;
16206
16207 if (benchmark == 0)
16208 {
16209 mask = myargv[optind + 1];
16210
16211 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16212
16213 if ((optind + 2) <= myargc)
16214 {
16215 struct stat file_stat;
16216
16217 if (stat (mask, &file_stat) == -1)
16218 {
16219 maskcnt = 1;
16220
16221 masks[maskcnt - 1] = mystrdup (mask);
16222 }
16223 else
16224 {
16225 int wls_left = myargc - (optind + 1);
16226
16227 uint masks_avail = INCR_MASKS;
16228
16229 for (int i = 0; i < wls_left; i++)
16230 {
16231 if (i != 0)
16232 {
16233 mask = myargv[optind + 1 + i];
16234
16235 if (stat (mask, &file_stat) == -1)
16236 {
16237 log_error ("ERROR: %s: %s", mask, strerror (errno));
16238
16239 return (-1);
16240 }
16241 }
16242
16243 uint is_file = S_ISREG (file_stat.st_mode);
16244
16245 if (is_file == 1)
16246 {
16247 FILE *mask_fp;
16248
16249 if ((mask_fp = fopen (mask, "r")) == NULL)
16250 {
16251 log_error ("ERROR: %s: %s", mask, strerror (errno));
16252
16253 return (-1);
16254 }
16255
16256 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16257
16258 while (!feof (mask_fp))
16259 {
16260 memset (line_buf, 0, HCBUFSIZ);
16261
16262 int line_len = fgetl (mask_fp, line_buf);
16263
16264 if (line_len == 0) continue;
16265
16266 if (line_buf[0] == '#') continue;
16267
16268 if (masks_avail == maskcnt)
16269 {
16270 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16271
16272 masks_avail += INCR_MASKS;
16273 }
16274
16275 masks[maskcnt] = mystrdup (line_buf);
16276
16277 maskcnt++;
16278 }
16279
16280 myfree (line_buf);
16281
16282 fclose (mask_fp);
16283 }
16284 else
16285 {
16286 log_error ("ERROR: %s: unsupported file-type", mask);
16287
16288 return (-1);
16289 }
16290 }
16291
16292 mask_from_file = 1;
16293 }
16294 }
16295 else
16296 {
16297 custom_charset_1 = (char *) "?l?d?u";
16298 custom_charset_2 = (char *) "?l?d";
16299 custom_charset_3 = (char *) "?l?d*!$@_";
16300
16301 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16302 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16303 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16304
16305 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16306
16307 wordlist_mode = WL_MODE_MASK;
16308
16309 data.wordlist_mode = wordlist_mode;
16310
16311 increment = 1;
16312
16313 maskcnt = 1;
16314 }
16315 }
16316 else
16317 {
16318 /**
16319 * generate full masks and charsets
16320 */
16321
16322 masks = (char **) mymalloc (sizeof (char *));
16323
16324 switch (hash_mode)
16325 {
16326 case 1731: pw_min = 5;
16327 pw_max = 5;
16328 mask = mystrdup ("?b?b?b?b?b");
16329 break;
16330 case 12500: pw_min = 5;
16331 pw_max = 5;
16332 mask = mystrdup ("?b?b?b?b?b");
16333 break;
16334 default: pw_min = 7;
16335 pw_max = 7;
16336 mask = mystrdup ("?b?b?b?b?b?b?b");
16337 break;
16338 }
16339
16340 maskcnt = 1;
16341
16342 masks[maskcnt - 1] = mystrdup (mask);
16343
16344 wordlist_mode = WL_MODE_MASK;
16345
16346 data.wordlist_mode = wordlist_mode;
16347
16348 increment = 1;
16349 }
16350
16351 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16352
16353 if (increment)
16354 {
16355 if (increment_min > pw_min) pw_min = increment_min;
16356
16357 if (increment_max < pw_max) pw_max = increment_max;
16358 }
16359 }
16360 else if (attack_mode == ATTACK_MODE_HYBRID1)
16361 {
16362 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16363
16364 // display
16365
16366 char *mask = myargv[myargc - 1];
16367
16368 maskcnt = 0;
16369
16370 masks = (char **) mymalloc (1 * sizeof (char *));
16371
16372 // mod
16373
16374 struct stat file_stat;
16375
16376 if (stat (mask, &file_stat) == -1)
16377 {
16378 maskcnt = 1;
16379
16380 masks[maskcnt - 1] = mystrdup (mask);
16381 }
16382 else
16383 {
16384 uint is_file = S_ISREG (file_stat.st_mode);
16385
16386 if (is_file == 1)
16387 {
16388 FILE *mask_fp;
16389
16390 if ((mask_fp = fopen (mask, "r")) == NULL)
16391 {
16392 log_error ("ERROR: %s: %s", mask, strerror (errno));
16393
16394 return (-1);
16395 }
16396
16397 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16398
16399 uint masks_avail = 1;
16400
16401 while (!feof (mask_fp))
16402 {
16403 memset (line_buf, 0, HCBUFSIZ);
16404
16405 int line_len = fgetl (mask_fp, line_buf);
16406
16407 if (line_len == 0) continue;
16408
16409 if (line_buf[0] == '#') continue;
16410
16411 if (masks_avail == maskcnt)
16412 {
16413 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16414
16415 masks_avail += INCR_MASKS;
16416 }
16417
16418 masks[maskcnt] = mystrdup (line_buf);
16419
16420 maskcnt++;
16421 }
16422
16423 myfree (line_buf);
16424
16425 fclose (mask_fp);
16426
16427 mask_from_file = 1;
16428 }
16429 else
16430 {
16431 maskcnt = 1;
16432
16433 masks[maskcnt - 1] = mystrdup (mask);
16434 }
16435 }
16436
16437 // base
16438
16439 int wls_left = myargc - (optind + 2);
16440
16441 for (int i = 0; i < wls_left; i++)
16442 {
16443 char *filename = myargv[optind + 1 + i];
16444
16445 struct stat file_stat;
16446
16447 if (stat (filename, &file_stat) == -1)
16448 {
16449 log_error ("ERROR: %s: %s", filename, strerror (errno));
16450
16451 return (-1);
16452 }
16453
16454 uint is_dir = S_ISDIR (file_stat.st_mode);
16455
16456 if (is_dir == 0)
16457 {
16458 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16459
16460 dictcnt++;
16461
16462 dictfiles[dictcnt - 1] = filename;
16463 }
16464 else
16465 {
16466 // do not allow --keyspace w/ a directory
16467
16468 if (keyspace == 1)
16469 {
16470 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16471
16472 return (-1);
16473 }
16474
16475 char **dictionary_files = NULL;
16476
16477 dictionary_files = scan_directory (filename);
16478
16479 if (dictionary_files != NULL)
16480 {
16481 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16482
16483 for (int d = 0; dictionary_files[d] != NULL; d++)
16484 {
16485 char *l1_filename = dictionary_files[d];
16486
16487 struct stat l1_stat;
16488
16489 if (stat (l1_filename, &l1_stat) == -1)
16490 {
16491 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16492
16493 return (-1);
16494 }
16495
16496 if (S_ISREG (l1_stat.st_mode))
16497 {
16498 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16499
16500 dictcnt++;
16501
16502 dictfiles[dictcnt - 1] = strdup (l1_filename);
16503 }
16504 }
16505 }
16506
16507 local_free (dictionary_files);
16508 }
16509 }
16510
16511 if (dictcnt < 1)
16512 {
16513 log_error ("ERROR: No usable dictionary file found.");
16514
16515 return (-1);
16516 }
16517
16518 if (increment)
16519 {
16520 maskcnt = 0;
16521
16522 uint mask_min = increment_min; // we can't reject smaller masks here
16523 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16524
16525 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16526 {
16527 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16528
16529 if (cur_mask == NULL) break;
16530
16531 masks[maskcnt] = cur_mask;
16532
16533 maskcnt++;
16534
16535 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16536 }
16537 }
16538 }
16539 else if (attack_mode == ATTACK_MODE_HYBRID2)
16540 {
16541 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16542
16543 // display
16544
16545 char *mask = myargv[optind + 1 + 0];
16546
16547 maskcnt = 0;
16548
16549 masks = (char **) mymalloc (1 * sizeof (char *));
16550
16551 // mod
16552
16553 struct stat file_stat;
16554
16555 if (stat (mask, &file_stat) == -1)
16556 {
16557 maskcnt = 1;
16558
16559 masks[maskcnt - 1] = mystrdup (mask);
16560 }
16561 else
16562 {
16563 uint is_file = S_ISREG (file_stat.st_mode);
16564
16565 if (is_file == 1)
16566 {
16567 FILE *mask_fp;
16568
16569 if ((mask_fp = fopen (mask, "r")) == NULL)
16570 {
16571 log_error ("ERROR: %s: %s", mask, strerror (errno));
16572
16573 return (-1);
16574 }
16575
16576 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16577
16578 uint masks_avail = 1;
16579
16580 while (!feof (mask_fp))
16581 {
16582 memset (line_buf, 0, HCBUFSIZ);
16583
16584 int line_len = fgetl (mask_fp, line_buf);
16585
16586 if (line_len == 0) continue;
16587
16588 if (line_buf[0] == '#') continue;
16589
16590 if (masks_avail == maskcnt)
16591 {
16592 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16593
16594 masks_avail += INCR_MASKS;
16595 }
16596
16597 masks[maskcnt] = mystrdup (line_buf);
16598
16599 maskcnt++;
16600 }
16601
16602 myfree (line_buf);
16603
16604 fclose (mask_fp);
16605
16606 mask_from_file = 1;
16607 }
16608 else
16609 {
16610 maskcnt = 1;
16611
16612 masks[maskcnt - 1] = mystrdup (mask);
16613 }
16614 }
16615
16616 // base
16617
16618 int wls_left = myargc - (optind + 2);
16619
16620 for (int i = 0; i < wls_left; i++)
16621 {
16622 char *filename = myargv[optind + 2 + i];
16623
16624 struct stat file_stat;
16625
16626 if (stat (filename, &file_stat) == -1)
16627 {
16628 log_error ("ERROR: %s: %s", filename, strerror (errno));
16629
16630 return (-1);
16631 }
16632
16633 uint is_dir = S_ISDIR (file_stat.st_mode);
16634
16635 if (is_dir == 0)
16636 {
16637 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16638
16639 dictcnt++;
16640
16641 dictfiles[dictcnt - 1] = filename;
16642 }
16643 else
16644 {
16645 // do not allow --keyspace w/ a directory
16646
16647 if (keyspace == 1)
16648 {
16649 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16650
16651 return (-1);
16652 }
16653
16654 char **dictionary_files = NULL;
16655
16656 dictionary_files = scan_directory (filename);
16657
16658 if (dictionary_files != NULL)
16659 {
16660 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16661
16662 for (int d = 0; dictionary_files[d] != NULL; d++)
16663 {
16664 char *l1_filename = dictionary_files[d];
16665
16666 struct stat l1_stat;
16667
16668 if (stat (l1_filename, &l1_stat) == -1)
16669 {
16670 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16671
16672 return (-1);
16673 }
16674
16675 if (S_ISREG (l1_stat.st_mode))
16676 {
16677 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16678
16679 dictcnt++;
16680
16681 dictfiles[dictcnt - 1] = strdup (l1_filename);
16682 }
16683 }
16684 }
16685
16686 local_free (dictionary_files);
16687 }
16688 }
16689
16690 if (dictcnt < 1)
16691 {
16692 log_error ("ERROR: No usable dictionary file found.");
16693
16694 return (-1);
16695 }
16696
16697 if (increment)
16698 {
16699 maskcnt = 0;
16700
16701 uint mask_min = increment_min; // we can't reject smaller masks here
16702 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16703
16704 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16705 {
16706 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16707
16708 if (cur_mask == NULL) break;
16709
16710 masks[maskcnt] = cur_mask;
16711
16712 maskcnt++;
16713
16714 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16715 }
16716 }
16717 }
16718
16719 data.pw_min = pw_min;
16720 data.pw_max = pw_max;
16721
16722 /**
16723 * weak hash check
16724 */
16725
16726 if (weak_hash_threshold >= salts_cnt)
16727 {
16728 hc_device_param_t *device_param = NULL;
16729
16730 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16731 {
16732 device_param = &data.devices_param[device_id];
16733
16734 if (device_param->skipped) continue;
16735
16736 break;
16737 }
16738
16739 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16740
16741 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16742 {
16743 weak_hash_check (device_param, salt_pos);
16744 }
16745
16746 // Display hack, guarantee that there is at least one \r before real start
16747
16748 //if (data.quiet == 0) log_info ("");
16749 }
16750
16751 /**
16752 * status and monitor threads
16753 */
16754
16755 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16756
16757 hc_thread_t i_thread = 0;
16758
16759 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16760 {
16761 hc_thread_create (i_thread, thread_keypress, &benchmark);
16762 }
16763
16764 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16765
16766 uint ni_threads_cnt = 0;
16767
16768 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16769
16770 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16771
16772 ni_threads_cnt++;
16773
16774 /**
16775 * Outfile remove
16776 */
16777
16778 if (keyspace == 0)
16779 {
16780 if (outfile_check_timer != 0)
16781 {
16782 if (data.outfile_check_directory != NULL)
16783 {
16784 if ((hash_mode != 5200) &&
16785 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16786 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16787 (hash_mode != 9000))
16788 {
16789 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16790
16791 ni_threads_cnt++;
16792 }
16793 else
16794 {
16795 outfile_check_timer = 0;
16796 }
16797 }
16798 else
16799 {
16800 outfile_check_timer = 0;
16801 }
16802 }
16803 }
16804
16805 /**
16806 * Inform the user if we got some hashes remove because of the pot file remove feature
16807 */
16808
16809 if (data.quiet == 0)
16810 {
16811 if (potfile_remove_cracks > 0)
16812 {
16813 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16814 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16815 }
16816 }
16817
16818 data.outfile_check_timer = outfile_check_timer;
16819
16820 /**
16821 * main loop
16822 */
16823
16824 char **induction_dictionaries = NULL;
16825
16826 int induction_dictionaries_cnt = 0;
16827
16828 hcstat_table_t *root_table_buf = NULL;
16829 hcstat_table_t *markov_table_buf = NULL;
16830
16831 uint initial_restore_done = 0;
16832
16833 data.maskcnt = maskcnt;
16834
16835 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16836 {
16837 if (data.devices_status == STATUS_CRACKED) break;
16838
16839 data.devices_status = STATUS_INIT;
16840
16841 if (maskpos > rd->maskpos)
16842 {
16843 rd->dictpos = 0;
16844 }
16845
16846 rd->maskpos = maskpos;
16847 data.maskpos = maskpos;
16848
16849 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16850 {
16851 char *mask = masks[maskpos];
16852
16853 if (mask_from_file == 1)
16854 {
16855 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16856
16857 char *str_ptr;
16858 uint str_pos;
16859
16860 uint mask_offset = 0;
16861
16862 uint separator_cnt;
16863
16864 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16865 {
16866 str_ptr = strstr (mask + mask_offset, ",");
16867
16868 if (str_ptr == NULL) break;
16869
16870 str_pos = str_ptr - mask;
16871
16872 // escaped separator, i.e. "\,"
16873
16874 if (str_pos > 0)
16875 {
16876 if (mask[str_pos - 1] == '\\')
16877 {
16878 separator_cnt --;
16879
16880 mask_offset = str_pos + 1;
16881
16882 continue;
16883 }
16884 }
16885
16886 // reset the offset
16887
16888 mask_offset = 0;
16889
16890 mask[str_pos] = '\0';
16891
16892 switch (separator_cnt)
16893 {
16894 case 0:
16895 mp_reset_usr (mp_usr, 0);
16896
16897 custom_charset_1 = mask;
16898 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16899 break;
16900
16901 case 1:
16902 mp_reset_usr (mp_usr, 1);
16903
16904 custom_charset_2 = mask;
16905 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16906 break;
16907
16908 case 2:
16909 mp_reset_usr (mp_usr, 2);
16910
16911 custom_charset_3 = mask;
16912 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16913 break;
16914
16915 case 3:
16916 mp_reset_usr (mp_usr, 3);
16917
16918 custom_charset_4 = mask;
16919 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16920 break;
16921 }
16922
16923 mask = mask + str_pos + 1;
16924 }
16925 }
16926
16927 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16928 {
16929 if (maskpos > 0)
16930 {
16931 local_free (css_buf);
16932 local_free (data.root_css_buf);
16933 local_free (data.markov_css_buf);
16934
16935 local_free (masks[maskpos - 1]);
16936 }
16937
16938 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16939
16940 data.mask = mask;
16941 data.css_cnt = css_cnt;
16942 data.css_buf = css_buf;
16943
16944 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16945
16946 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16947
16948 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16949 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16950
16951 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16952
16953 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16954
16955 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16956 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16957
16958 data.root_css_buf = root_css_buf;
16959 data.markov_css_buf = markov_css_buf;
16960
16961 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16962
16963 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16964
16965 local_free (root_table_buf);
16966 local_free (markov_table_buf);
16967
16968 // args
16969
16970 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16971 {
16972 hc_device_param_t *device_param = &data.devices_param[device_id];
16973
16974 if (device_param->skipped) continue;
16975
16976 device_param->kernel_params_mp[0] = &device_param->d_combs;
16977 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16978 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16979
16980 device_param->kernel_params_mp_buf64[3] = 0;
16981 device_param->kernel_params_mp_buf32[4] = css_cnt;
16982 device_param->kernel_params_mp_buf32[5] = 0;
16983 device_param->kernel_params_mp_buf32[6] = 0;
16984 device_param->kernel_params_mp_buf32[7] = 0;
16985
16986 if (attack_mode == ATTACK_MODE_HYBRID1)
16987 {
16988 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16989 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16990 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16991 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16992 }
16993 else if (attack_mode == ATTACK_MODE_HYBRID2)
16994 {
16995 device_param->kernel_params_mp_buf32[5] = 0;
16996 device_param->kernel_params_mp_buf32[6] = 0;
16997 device_param->kernel_params_mp_buf32[7] = 0;
16998 }
16999
17000 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]);
17001 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]);
17002 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]);
17003
17004 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);
17005 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);
17006 }
17007 }
17008 else if (attack_mode == ATTACK_MODE_BF)
17009 {
17010 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17011
17012 if (increment)
17013 {
17014 for (uint i = 0; i < dictcnt; i++)
17015 {
17016 local_free (dictfiles[i]);
17017 }
17018
17019 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17020 {
17021 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17022
17023 if (l1_filename == NULL) break;
17024
17025 dictcnt++;
17026
17027 dictfiles[dictcnt - 1] = l1_filename;
17028 }
17029 }
17030 else
17031 {
17032 dictcnt++;
17033
17034 dictfiles[dictcnt - 1] = mask;
17035 }
17036
17037 if (dictcnt == 0)
17038 {
17039 log_error ("ERROR: Mask is too small");
17040
17041 return (-1);
17042 }
17043 }
17044 }
17045
17046 free (induction_dictionaries);
17047
17048 // induction_dictionaries_cnt = 0; // implied
17049
17050 if (attack_mode != ATTACK_MODE_BF)
17051 {
17052 if (keyspace == 0)
17053 {
17054 induction_dictionaries = scan_directory (induction_directory);
17055
17056 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17057 }
17058 }
17059
17060 if (induction_dictionaries_cnt)
17061 {
17062 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17063 }
17064
17065 /**
17066 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17067 */
17068 if (keyspace == 1)
17069 {
17070 if ((maskcnt > 1) || (dictcnt > 1))
17071 {
17072 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17073
17074 return (-1);
17075 }
17076 }
17077
17078 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17079 {
17080 char *subid = logfile_generate_subid ();
17081
17082 data.subid = subid;
17083
17084 logfile_sub_msg ("START");
17085
17086 data.devices_status = STATUS_INIT;
17087
17088 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17089 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17090 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17091
17092 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17093
17094 data.cpt_pos = 0;
17095
17096 data.cpt_start = time (NULL);
17097
17098 data.cpt_total = 0;
17099
17100 if (data.restore == 0)
17101 {
17102 rd->words_cur = skip;
17103
17104 skip = 0;
17105
17106 data.skip = 0;
17107 }
17108
17109 data.ms_paused = 0;
17110
17111 data.kernel_power_final = 0;
17112
17113 data.words_cur = rd->words_cur;
17114
17115 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17116 {
17117 hc_device_param_t *device_param = &data.devices_param[device_id];
17118
17119 if (device_param->skipped) continue;
17120
17121 device_param->speed_pos = 0;
17122
17123 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17124 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17125
17126 device_param->exec_pos = 0;
17127
17128 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17129
17130 device_param->outerloop_pos = 0;
17131 device_param->outerloop_left = 0;
17132 device_param->innerloop_pos = 0;
17133 device_param->innerloop_left = 0;
17134
17135 // some more resets:
17136
17137 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17138
17139 device_param->pws_cnt = 0;
17140
17141 device_param->words_off = 0;
17142 device_param->words_done = 0;
17143 }
17144
17145 // figure out some workload
17146
17147 if (attack_mode == ATTACK_MODE_STRAIGHT)
17148 {
17149 if (data.wordlist_mode == WL_MODE_FILE)
17150 {
17151 char *dictfile = NULL;
17152
17153 if (induction_dictionaries_cnt)
17154 {
17155 dictfile = induction_dictionaries[0];
17156 }
17157 else
17158 {
17159 dictfile = dictfiles[dictpos];
17160 }
17161
17162 data.dictfile = dictfile;
17163
17164 logfile_sub_string (dictfile);
17165
17166 for (uint i = 0; i < rp_files_cnt; i++)
17167 {
17168 logfile_sub_var_string ("rulefile", rp_files[i]);
17169 }
17170
17171 FILE *fd2 = fopen (dictfile, "rb");
17172
17173 if (fd2 == NULL)
17174 {
17175 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17176
17177 return (-1);
17178 }
17179
17180 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17181
17182 fclose (fd2);
17183
17184 if (data.words_cnt == 0)
17185 {
17186 if (data.devices_status == STATUS_CRACKED) break;
17187 if (data.devices_status == STATUS_ABORTED) break;
17188
17189 dictpos++;
17190
17191 continue;
17192 }
17193 }
17194 }
17195 else if (attack_mode == ATTACK_MODE_COMBI)
17196 {
17197 char *dictfile = data.dictfile;
17198 char *dictfile2 = data.dictfile2;
17199
17200 logfile_sub_string (dictfile);
17201 logfile_sub_string (dictfile2);
17202
17203 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17204 {
17205 FILE *fd2 = fopen (dictfile, "rb");
17206
17207 if (fd2 == NULL)
17208 {
17209 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17210
17211 return (-1);
17212 }
17213
17214 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17215
17216 fclose (fd2);
17217 }
17218 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17219 {
17220 FILE *fd2 = fopen (dictfile2, "rb");
17221
17222 if (fd2 == NULL)
17223 {
17224 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17225
17226 return (-1);
17227 }
17228
17229 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17230
17231 fclose (fd2);
17232 }
17233
17234 if (data.words_cnt == 0)
17235 {
17236 if (data.devices_status == STATUS_CRACKED) break;
17237 if (data.devices_status == STATUS_ABORTED) break;
17238
17239 dictpos++;
17240
17241 continue;
17242 }
17243 }
17244 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17245 {
17246 char *dictfile = NULL;
17247
17248 if (induction_dictionaries_cnt)
17249 {
17250 dictfile = induction_dictionaries[0];
17251 }
17252 else
17253 {
17254 dictfile = dictfiles[dictpos];
17255 }
17256
17257 data.dictfile = dictfile;
17258
17259 char *mask = data.mask;
17260
17261 logfile_sub_string (dictfile);
17262 logfile_sub_string (mask);
17263
17264 FILE *fd2 = fopen (dictfile, "rb");
17265
17266 if (fd2 == NULL)
17267 {
17268 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17269
17270 return (-1);
17271 }
17272
17273 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17274
17275 fclose (fd2);
17276
17277 if (data.words_cnt == 0)
17278 {
17279 if (data.devices_status == STATUS_CRACKED) break;
17280 if (data.devices_status == STATUS_ABORTED) break;
17281
17282 dictpos++;
17283
17284 continue;
17285 }
17286 }
17287 else if (attack_mode == ATTACK_MODE_BF)
17288 {
17289 local_free (css_buf);
17290 local_free (data.root_css_buf);
17291 local_free (data.markov_css_buf);
17292
17293 char *mask = dictfiles[dictpos];
17294
17295 logfile_sub_string (mask);
17296
17297 // base
17298
17299 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17300
17301 if (opts_type & OPTS_TYPE_PT_UNICODE)
17302 {
17303 uint css_cnt_unicode = css_cnt * 2;
17304
17305 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17306
17307 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17308 {
17309 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17310
17311 css_buf_unicode[j + 1].cs_buf[0] = 0;
17312 css_buf_unicode[j + 1].cs_len = 1;
17313 }
17314
17315 free (css_buf);
17316
17317 css_buf = css_buf_unicode;
17318 css_cnt = css_cnt_unicode;
17319 }
17320
17321 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17322
17323 uint mask_min = pw_min;
17324 uint mask_max = pw_max;
17325
17326 if (opts_type & OPTS_TYPE_PT_UNICODE)
17327 {
17328 mask_min *= 2;
17329 mask_max *= 2;
17330 }
17331
17332 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17333 {
17334 if (css_cnt < mask_min)
17335 {
17336 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17337 }
17338
17339 if (css_cnt > mask_max)
17340 {
17341 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17342 }
17343
17344 // skip to next mask
17345
17346 dictpos++;
17347
17348 rd->dictpos = dictpos;
17349
17350 logfile_sub_msg ("STOP");
17351
17352 continue;
17353 }
17354
17355 uint save_css_cnt = css_cnt;
17356
17357 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17358 {
17359 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17360 {
17361 uint salt_len = (uint) data.salts_buf[0].salt_len;
17362 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17363
17364 uint css_cnt_salt = css_cnt + salt_len;
17365
17366 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17367
17368 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17369
17370 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17371 {
17372 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17373 css_buf_salt[j].cs_len = 1;
17374 }
17375
17376 free (css_buf);
17377
17378 css_buf = css_buf_salt;
17379 css_cnt = css_cnt_salt;
17380 }
17381 }
17382
17383 data.mask = mask;
17384 data.css_cnt = css_cnt;
17385 data.css_buf = css_buf;
17386
17387 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17388
17389 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17390
17391 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17392
17393 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17394 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17395
17396 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17397
17398 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17399
17400 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17401 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17402
17403 data.root_css_buf = root_css_buf;
17404 data.markov_css_buf = markov_css_buf;
17405
17406 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17407
17408 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17409
17410 local_free (root_table_buf);
17411 local_free (markov_table_buf);
17412
17413 // copy + args
17414
17415 uint css_cnt_l = css_cnt;
17416 uint css_cnt_r;
17417
17418 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17419 {
17420 if (save_css_cnt < 6)
17421 {
17422 css_cnt_r = 1;
17423 }
17424 else if (save_css_cnt == 6)
17425 {
17426 css_cnt_r = 2;
17427 }
17428 else
17429 {
17430 if (opts_type & OPTS_TYPE_PT_UNICODE)
17431 {
17432 if (save_css_cnt == 8 || save_css_cnt == 10)
17433 {
17434 css_cnt_r = 2;
17435 }
17436 else
17437 {
17438 css_cnt_r = 4;
17439 }
17440 }
17441 else
17442 {
17443 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17444 {
17445 css_cnt_r = 3;
17446 }
17447 else
17448 {
17449 css_cnt_r = 4;
17450 }
17451 }
17452 }
17453 }
17454 else
17455 {
17456 css_cnt_r = 1;
17457
17458 /* unfinished code?
17459 int sum = css_buf[css_cnt_r - 1].cs_len;
17460
17461 for (uint i = 1; i < 4 && i < css_cnt; i++)
17462 {
17463 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17464
17465 css_cnt_r++;
17466
17467 sum *= css_buf[css_cnt_r - 1].cs_len;
17468 }
17469 */
17470 }
17471
17472 css_cnt_l -= css_cnt_r;
17473
17474 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17475
17476 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17477 {
17478 hc_device_param_t *device_param = &data.devices_param[device_id];
17479
17480 if (device_param->skipped) continue;
17481
17482 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17483 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17484 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17485
17486 device_param->kernel_params_mp_l_buf64[3] = 0;
17487 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17488 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17489 device_param->kernel_params_mp_l_buf32[6] = 0;
17490 device_param->kernel_params_mp_l_buf32[7] = 0;
17491 device_param->kernel_params_mp_l_buf32[8] = 0;
17492
17493 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17494 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17495 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17496 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17497
17498 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17499 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17500 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17501
17502 device_param->kernel_params_mp_r_buf64[3] = 0;
17503 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17504 device_param->kernel_params_mp_r_buf32[5] = 0;
17505 device_param->kernel_params_mp_r_buf32[6] = 0;
17506 device_param->kernel_params_mp_r_buf32[7] = 0;
17507
17508 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]);
17509 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]);
17510 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]);
17511
17512 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]);
17513 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]);
17514 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]);
17515
17516 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);
17517 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);
17518 }
17519 }
17520
17521 u64 words_base = data.words_cnt;
17522
17523 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17524 {
17525 if (data.kernel_rules_cnt)
17526 {
17527 words_base /= data.kernel_rules_cnt;
17528 }
17529 }
17530 else if (data.attack_kern == ATTACK_KERN_COMBI)
17531 {
17532 if (data.combs_cnt)
17533 {
17534 words_base /= data.combs_cnt;
17535 }
17536 }
17537 else if (data.attack_kern == ATTACK_KERN_BF)
17538 {
17539 if (data.bfs_cnt)
17540 {
17541 words_base /= data.bfs_cnt;
17542 }
17543 }
17544
17545 data.words_base = words_base;
17546
17547 if (keyspace == 1)
17548 {
17549 log_info ("%llu", (unsigned long long int) words_base);
17550
17551 return (0);
17552 }
17553
17554 if (data.words_cur > data.words_base)
17555 {
17556 log_error ("ERROR: restore value greater keyspace");
17557
17558 return (-1);
17559 }
17560
17561 if (data.words_cur)
17562 {
17563 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17564 {
17565 for (uint i = 0; i < data.salts_cnt; i++)
17566 {
17567 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17568 }
17569 }
17570 else if (data.attack_kern == ATTACK_KERN_COMBI)
17571 {
17572 for (uint i = 0; i < data.salts_cnt; i++)
17573 {
17574 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17575 }
17576 }
17577 else if (data.attack_kern == ATTACK_KERN_BF)
17578 {
17579 for (uint i = 0; i < data.salts_cnt; i++)
17580 {
17581 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17582 }
17583 }
17584 }
17585
17586 /*
17587 * Update loopback file
17588 */
17589
17590 if (loopback == 1)
17591 {
17592 time_t now;
17593
17594 time (&now);
17595
17596 uint random_num = get_random_num (0, 9999);
17597
17598 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17599
17600 data.loopback_file = loopback_file;
17601 }
17602
17603 /*
17604 * Update dictionary statistic
17605 */
17606
17607 if (keyspace == 0)
17608 {
17609 dictstat_fp = fopen (dictstat, "wb");
17610
17611 if (dictstat_fp)
17612 {
17613 lock_file (dictstat_fp);
17614
17615 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17616
17617 fclose (dictstat_fp);
17618 }
17619 }
17620
17621 /**
17622 * create autotune threads
17623 */
17624
17625 data.devices_status = STATUS_AUTOTUNE;
17626
17627 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17628
17629 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17630 {
17631 hc_device_param_t *device_param = &devices_param[device_id];
17632
17633 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
17634 }
17635
17636 hc_thread_wait (data.devices_cnt, c_threads);
17637
17638 /*
17639 * Inform user about possible slow speeds
17640 */
17641
17642 uint hardware_power_all = 0;
17643
17644 uint kernel_power_all = 0;
17645
17646 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17647 {
17648 hc_device_param_t *device_param = &devices_param[device_id];
17649
17650 hardware_power_all += device_param->hardware_power;
17651
17652 kernel_power_all += device_param->kernel_power;
17653 }
17654
17655 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
17656
17657 data.kernel_power_all = kernel_power_all;
17658
17659 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17660 {
17661 if (data.words_base < kernel_power_all)
17662 {
17663 if (quiet == 0)
17664 {
17665 log_info ("ATTENTION!");
17666 log_info (" The wordlist or mask you are using is too small.");
17667 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17668 log_info (" The cracking speed will drop.");
17669 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17670 log_info ("");
17671 }
17672 }
17673 }
17674
17675 /**
17676 * create cracker threads
17677 */
17678
17679 data.devices_status = STATUS_RUNNING;
17680
17681 if (initial_restore_done == 0)
17682 {
17683 if (data.restore_disable == 0) cycle_restore ();
17684
17685 initial_restore_done = 1;
17686 }
17687
17688 hc_timer_set (&data.timer_running);
17689
17690 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17691 {
17692 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17693 {
17694 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17695 if (quiet == 0) fflush (stdout);
17696 }
17697 }
17698 else if (wordlist_mode == WL_MODE_STDIN)
17699 {
17700 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17701 if (data.quiet == 0) log_info ("");
17702 }
17703
17704 time_t runtime_start;
17705
17706 time (&runtime_start);
17707
17708 data.runtime_start = runtime_start;
17709
17710 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17711 {
17712 hc_device_param_t *device_param = &devices_param[device_id];
17713
17714 if (wordlist_mode == WL_MODE_STDIN)
17715 {
17716 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17717 }
17718 else
17719 {
17720 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17721 }
17722 }
17723
17724 hc_thread_wait (data.devices_cnt, c_threads);
17725
17726 local_free (c_threads);
17727
17728 data.restore = 0;
17729
17730 // finalize task
17731
17732 logfile_sub_var_uint ("status-after-work", data.devices_status);
17733
17734 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17735
17736 if (data.devices_status == STATUS_CRACKED) break;
17737 if (data.devices_status == STATUS_ABORTED) break;
17738
17739 if (data.devices_status == STATUS_BYPASS)
17740 {
17741 data.devices_status = STATUS_RUNNING;
17742 }
17743
17744 if (induction_dictionaries_cnt)
17745 {
17746 unlink (induction_dictionaries[0]);
17747 }
17748
17749 free (induction_dictionaries);
17750
17751 if (attack_mode != ATTACK_MODE_BF)
17752 {
17753 induction_dictionaries = scan_directory (induction_directory);
17754
17755 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17756 }
17757
17758 if (benchmark == 0)
17759 {
17760 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17761 {
17762 if (quiet == 0) clear_prompt ();
17763
17764 if (quiet == 0) log_info ("");
17765
17766 if (status == 1)
17767 {
17768 status_display ();
17769 }
17770 else
17771 {
17772 if (quiet == 0) status_display ();
17773 }
17774
17775 if (quiet == 0) log_info ("");
17776 }
17777 }
17778
17779 if (attack_mode == ATTACK_MODE_BF)
17780 {
17781 dictpos++;
17782
17783 rd->dictpos = dictpos;
17784 }
17785 else
17786 {
17787 if (induction_dictionaries_cnt)
17788 {
17789 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17790 }
17791 else
17792 {
17793 dictpos++;
17794
17795 rd->dictpos = dictpos;
17796 }
17797 }
17798
17799 time_t runtime_stop;
17800
17801 time (&runtime_stop);
17802
17803 data.runtime_stop = runtime_stop;
17804
17805 logfile_sub_uint (runtime_start);
17806 logfile_sub_uint (runtime_stop);
17807
17808 logfile_sub_msg ("STOP");
17809
17810 global_free (subid);
17811 }
17812
17813 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17814
17815 if (data.devices_status == STATUS_CRACKED) break;
17816 if (data.devices_status == STATUS_ABORTED) break;
17817 if (data.devices_status == STATUS_QUIT) break;
17818
17819 if (data.devices_status == STATUS_BYPASS)
17820 {
17821 data.devices_status = STATUS_RUNNING;
17822 }
17823 }
17824
17825 // 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
17826
17827 if (attack_mode == ATTACK_MODE_STRAIGHT)
17828 {
17829 if (data.wordlist_mode == WL_MODE_FILE)
17830 {
17831 if (data.dictfile == NULL)
17832 {
17833 if (dictfiles != NULL)
17834 {
17835 data.dictfile = dictfiles[0];
17836
17837 hc_timer_set (&data.timer_running);
17838 }
17839 }
17840 }
17841 }
17842 // NOTE: combi is okay because it is already set beforehand
17843 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17844 {
17845 if (data.dictfile == NULL)
17846 {
17847 if (dictfiles != NULL)
17848 {
17849 hc_timer_set (&data.timer_running);
17850
17851 data.dictfile = dictfiles[0];
17852 }
17853 }
17854 }
17855 else if (attack_mode == ATTACK_MODE_BF)
17856 {
17857 if (data.mask == NULL)
17858 {
17859 hc_timer_set (&data.timer_running);
17860
17861 data.mask = masks[0];
17862 }
17863 }
17864
17865 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17866 {
17867 data.devices_status = STATUS_EXHAUSTED;
17868 }
17869
17870 // if cracked / aborted remove last induction dictionary
17871
17872 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17873 {
17874 struct stat induct_stat;
17875
17876 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17877 {
17878 unlink (induction_dictionaries[file_pos]);
17879 }
17880 }
17881
17882 // wait for non-interactive threads
17883
17884 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17885 {
17886 hc_thread_wait (1, &ni_threads[thread_idx]);
17887 }
17888
17889 local_free (ni_threads);
17890
17891 // wait for interactive threads
17892
17893 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17894 {
17895 hc_thread_wait (1, &i_thread);
17896 }
17897
17898 // we dont need restore file anymore
17899 if (data.restore_disable == 0)
17900 {
17901 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17902 {
17903 unlink (eff_restore_file);
17904 unlink (new_restore_file);
17905 }
17906 else
17907 {
17908 cycle_restore ();
17909 }
17910 }
17911
17912 // finally save left hashes
17913
17914 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17915 {
17916 save_hash ();
17917 }
17918
17919 /**
17920 * Clean up
17921 */
17922
17923 if (benchmark == 1)
17924 {
17925 status_benchmark ();
17926
17927 if (machine_readable == 0)
17928 {
17929 log_info ("");
17930 }
17931 }
17932 else
17933 {
17934 if (quiet == 0) clear_prompt ();
17935
17936 if (quiet == 0) log_info ("");
17937
17938 if (status == 1)
17939 {
17940 status_display ();
17941 }
17942 else
17943 {
17944 if (quiet == 0) status_display ();
17945 }
17946
17947 if (quiet == 0) log_info ("");
17948 }
17949
17950 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17951 {
17952 hc_device_param_t *device_param = &data.devices_param[device_id];
17953
17954 if (device_param->skipped) continue;
17955
17956 local_free (device_param->combs_buf);
17957
17958 local_free (device_param->hooks_buf);
17959
17960 local_free (device_param->device_name);
17961
17962 local_free (device_param->device_name_chksum);
17963
17964 local_free (device_param->device_version);
17965
17966 local_free (device_param->driver_version);
17967
17968 if (device_param->pws_buf) myfree (device_param->pws_buf);
17969 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17970 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17971 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17972 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17973 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17974 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17975 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17976 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17977 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17978 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17979 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17980 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17981 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17982 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17983 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17984 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17985 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17986 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17987 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17988 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17989 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17990 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17991 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17992 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17993 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17994 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17995 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17996 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17997
17998 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17999 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18000 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18001 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18002 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18003 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18004 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18005 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18006 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18007 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18008 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18009
18010 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18011 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18012 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18013
18014 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18015 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18016 }
18017
18018 // reset default fan speed
18019
18020 #ifdef HAVE_HWMON
18021 if (gpu_temp_disable == 0)
18022 {
18023 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
18024 {
18025 hc_thread_mutex_lock (mux_adl);
18026
18027 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18028 {
18029 hc_device_param_t *device_param = &data.devices_param[device_id];
18030
18031 if (device_param->skipped) continue;
18032
18033 if (data.hm_device[device_id].fan_set_supported == 1)
18034 {
18035 int fanspeed = temp_retain_fanspeed_value[device_id];
18036 int fanpolicy = temp_retain_fanpolicy_value[device_id];
18037
18038 if (fanpolicy == 1)
18039 {
18040 int rc = -1;
18041
18042 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18043 {
18044 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
18045 }
18046 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18047 {
18048
18049 }
18050
18051 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18052 }
18053 }
18054 }
18055
18056 hc_thread_mutex_unlock (mux_adl);
18057 }
18058 }
18059
18060 // reset power tuning
18061
18062 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18063 {
18064 hc_thread_mutex_lock (mux_adl);
18065
18066 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18067 {
18068 hc_device_param_t *device_param = &data.devices_param[device_id];
18069
18070 if (device_param->skipped) continue;
18071
18072 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18073 {
18074 if (data.hm_device[device_id].od_version == 6)
18075 {
18076 // check powertune capabilities first, if not available then skip device
18077
18078 int powertune_supported = 0;
18079
18080 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18081 {
18082 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18083
18084 return (-1);
18085 }
18086
18087 if (powertune_supported != 0)
18088 {
18089 // powercontrol settings
18090
18091 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18092 {
18093 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18094
18095 return (-1);
18096 }
18097
18098 // clocks
18099
18100 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18101
18102 performance_state->iNumberOfPerformanceLevels = 2;
18103
18104 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18105 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18106 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18107 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18108
18109 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18110 {
18111 log_info ("ERROR: Failed to restore ADL performance state");
18112
18113 return (-1);
18114 }
18115
18116 local_free (performance_state);
18117 }
18118 }
18119 }
18120
18121 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18122 {
18123 unsigned int limit = nvml_power_limit[device_id];
18124
18125 if (limit > 0)
18126 {
18127 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18128 }
18129 }
18130 }
18131
18132 hc_thread_mutex_unlock (mux_adl);
18133 }
18134
18135 if (gpu_temp_disable == 0)
18136 {
18137 if (data.hm_nvml)
18138 {
18139 hm_NVML_nvmlShutdown (data.hm_nvml);
18140
18141 nvml_close (data.hm_nvml);
18142
18143 data.hm_nvml = NULL;
18144 }
18145
18146 if (data.hm_adl)
18147 {
18148 hm_ADL_Main_Control_Destroy (data.hm_adl);
18149
18150 adl_close (data.hm_adl);
18151
18152 data.hm_adl = NULL;
18153 }
18154 }
18155 #endif // HAVE_HWMON
18156
18157 // free memory
18158
18159 local_free (masks);
18160
18161 local_free (dictstat_base);
18162
18163 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18164 {
18165 pot_t *pot_ptr = &pot[pot_pos];
18166
18167 hash_t *hash = &pot_ptr->hash;
18168
18169 local_free (hash->digest);
18170
18171 if (isSalted)
18172 {
18173 local_free (hash->salt);
18174 }
18175 }
18176
18177 local_free (pot);
18178
18179 local_free (all_kernel_rules_cnt);
18180 local_free (all_kernel_rules_buf);
18181
18182 local_free (wl_data->buf);
18183 local_free (wl_data);
18184
18185 local_free (bitmap_s1_a);
18186 local_free (bitmap_s1_b);
18187 local_free (bitmap_s1_c);
18188 local_free (bitmap_s1_d);
18189 local_free (bitmap_s2_a);
18190 local_free (bitmap_s2_b);
18191 local_free (bitmap_s2_c);
18192 local_free (bitmap_s2_d);
18193
18194 #ifdef HAVE_HWMON
18195 local_free (temp_retain_fanspeed_value);
18196 local_free (od_clock_mem_status);
18197 local_free (od_power_control_status);
18198 local_free (nvml_power_limit);
18199 #endif
18200
18201 global_free (devices_param);
18202
18203 global_free (kernel_rules_buf);
18204
18205 global_free (root_css_buf);
18206 global_free (markov_css_buf);
18207
18208 global_free (digests_buf);
18209 global_free (digests_shown);
18210 global_free (digests_shown_tmp);
18211
18212 global_free (salts_buf);
18213 global_free (salts_shown);
18214
18215 global_free (esalts_buf);
18216
18217 global_free (words_progress_done);
18218 global_free (words_progress_rejected);
18219 global_free (words_progress_restored);
18220
18221 if (pot_fp) fclose (pot_fp);
18222
18223 if (data.devices_status == STATUS_QUIT) break;
18224 }
18225
18226 // destroy others mutex
18227
18228 hc_thread_mutex_delete (mux_dispatcher);
18229 hc_thread_mutex_delete (mux_counter);
18230 hc_thread_mutex_delete (mux_display);
18231 hc_thread_mutex_delete (mux_adl);
18232
18233 // free memory
18234
18235 local_free (eff_restore_file);
18236 local_free (new_restore_file);
18237
18238 local_free (rd);
18239
18240 // tuning db
18241
18242 tuning_db_destroy (tuning_db);
18243
18244 // loopback
18245
18246 local_free (loopback_file);
18247
18248 if (loopback == 1) unlink (loopback_file);
18249
18250 // induction directory
18251
18252 if (induction_dir == NULL)
18253 {
18254 if (attack_mode != ATTACK_MODE_BF)
18255 {
18256 if (rmdir (induction_directory) == -1)
18257 {
18258 if (errno == ENOENT)
18259 {
18260 // good, we can ignore
18261 }
18262 else if (errno == ENOTEMPTY)
18263 {
18264 // good, we can ignore
18265 }
18266 else
18267 {
18268 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18269
18270 return (-1);
18271 }
18272 }
18273
18274 local_free (induction_directory);
18275 }
18276 }
18277
18278 // outfile-check directory
18279
18280 if (outfile_check_dir == NULL)
18281 {
18282 if (rmdir (outfile_check_directory) == -1)
18283 {
18284 if (errno == ENOENT)
18285 {
18286 // good, we can ignore
18287 }
18288 else if (errno == ENOTEMPTY)
18289 {
18290 // good, we can ignore
18291 }
18292 else
18293 {
18294 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18295
18296 return (-1);
18297 }
18298 }
18299
18300 local_free (outfile_check_directory);
18301 }
18302
18303 time_t proc_stop;
18304
18305 time (&proc_stop);
18306
18307 logfile_top_uint (proc_start);
18308 logfile_top_uint (proc_stop);
18309
18310 logfile_top_msg ("STOP");
18311
18312 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18313 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18314
18315 if (data.ocl) ocl_close (data.ocl);
18316
18317 if (data.devices_status == STATUS_ABORTED) return 2;
18318 if (data.devices_status == STATUS_QUIT) return 2;
18319 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18320 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18321 if (data.devices_status == STATUS_CRACKED) return 0;
18322
18323 return -1;
18324 }
Hashcat additions to support pwdhash