projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Do not automatically enable powertune in benchmark, but allow the user to enable...
[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)
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 hc_clWaitForEvents (data.ocl, 1, &event);
2472
2473 if (event_update)
2474 {
2475 cl_ulong time_start;
2476 cl_ulong time_end;
2477
2478 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2479 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2480
2481 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2482
2483 uint exec_pos = device_param->exec_pos;
2484
2485 device_param->exec_ms[exec_pos] = exec_time;
2486
2487 exec_pos++;
2488
2489 if (exec_pos == EXEC_CACHE)
2490 {
2491 exec_pos = 0;
2492 }
2493
2494 device_param->exec_pos = exec_pos;
2495 }
2496
2497 hc_clReleaseEvent (data.ocl, event);
2498
2499 hc_clFinish (data.ocl, device_param->command_queue);
2500 }
2501
2502 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2503 {
2504 uint num_elements = num;
2505
2506 switch (kern_run)
2507 {
2508 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2509 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2510 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2511 }
2512
2513 // causes problems with special threads like in bcrypt
2514 // const uint kernel_threads = device_param->kernel_threads;
2515
2516 uint kernel_threads = device_param->kernel_threads;
2517
2518 while (num_elements % kernel_threads) num_elements++;
2519
2520 cl_kernel kernel = NULL;
2521
2522 switch (kern_run)
2523 {
2524 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2525 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2526 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2527 }
2528
2529 switch (kern_run)
2530 {
2531 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2532 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2533 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2534 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2535 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2536 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2537 break;
2538 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2539 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2540 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2541 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2542 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2543 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2544 break;
2545 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2546 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2547 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2548 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2549 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2550 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2551 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2552 break;
2553 }
2554
2555 const size_t global_work_size[3] = { num_elements, 1, 1 };
2556 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2557
2558 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2559
2560 hc_clFlush (data.ocl, device_param->command_queue);
2561
2562 hc_clFinish (data.ocl, device_param->command_queue);
2563 }
2564
2565 static void run_kernel_tm (hc_device_param_t *device_param)
2566 {
2567 const uint num_elements = 1024; // fixed
2568
2569 uint kernel_threads = 32;
2570
2571 cl_kernel kernel = device_param->kernel_tm;
2572
2573 const size_t global_work_size[3] = { num_elements, 1, 1 };
2574 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2575
2576 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2577
2578 hc_clFlush (data.ocl, device_param->command_queue);
2579
2580 hc_clFinish (data.ocl, device_param->command_queue);
2581 }
2582
2583 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2584 {
2585 uint num_elements = num;
2586
2587 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2588 device_param->kernel_params_amp_buf32[6] = num_elements;
2589
2590 // causes problems with special threads like in bcrypt
2591 // const uint kernel_threads = device_param->kernel_threads;
2592
2593 uint kernel_threads = device_param->kernel_threads;
2594
2595 while (num_elements % kernel_threads) num_elements++;
2596
2597 cl_kernel kernel = device_param->kernel_amp;
2598
2599 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2600 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2601
2602 const size_t global_work_size[3] = { num_elements, 1, 1 };
2603 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2604
2605 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2606
2607 hc_clFlush (data.ocl, device_param->command_queue);
2608
2609 hc_clFinish (data.ocl, device_param->command_queue);
2610 }
2611
2612 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2613 {
2614 const u32 num16d = num / 16;
2615 const u32 num16m = num % 16;
2616
2617 if (num16d)
2618 {
2619 device_param->kernel_params_memset_buf32[1] = value;
2620 device_param->kernel_params_memset_buf32[2] = num16d;
2621
2622 uint kernel_threads = device_param->kernel_threads;
2623
2624 uint num_elements = num16d;
2625
2626 while (num_elements % kernel_threads) num_elements++;
2627
2628 cl_kernel kernel = device_param->kernel_memset;
2629
2630 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2631 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2632 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2633
2634 const size_t global_work_size[3] = { num_elements, 1, 1 };
2635 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2636
2637 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2638
2639 hc_clFlush (data.ocl, device_param->command_queue);
2640
2641 hc_clFinish (data.ocl, device_param->command_queue);
2642 }
2643
2644 if (num16m)
2645 {
2646 u32 tmp[4];
2647
2648 tmp[0] = value;
2649 tmp[1] = value;
2650 tmp[2] = value;
2651 tmp[3] = value;
2652
2653 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2654 }
2655 }
2656
2657 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2658 {
2659 run_kernel_memset (device_param, buf, 0, size);
2660
2661 /*
2662 int rc = -1;
2663
2664 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2665 {
2666 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2667
2668 const cl_uchar zero = 0;
2669
2670 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2671 }
2672
2673 if (rc != 0)
2674 {
2675 // NOTE: clEnqueueFillBuffer () always fails with -59
2676 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2677 // How's that possible, OpenCL 1.2 support is advertised??
2678 // We need to workaround...
2679
2680 #define FILLSZ 0x100000
2681
2682 char *tmp = (char *) mymalloc (FILLSZ);
2683
2684 for (size_t i = 0; i < size; i += FILLSZ)
2685 {
2686 const size_t left = size - i;
2687
2688 const size_t fillsz = MIN (FILLSZ, left);
2689
2690 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2691 }
2692
2693 myfree (tmp);
2694 }
2695 */
2696 }
2697
2698 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)
2699 {
2700 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2701 {
2702 if (attack_mode == ATTACK_MODE_BF)
2703 {
2704 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2705 {
2706 const uint size_tm = 32 * sizeof (bs_word_t);
2707
2708 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2709
2710 run_kernel_tm (device_param);
2711
2712 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);
2713 }
2714 }
2715
2716 if (highest_pw_len < 16)
2717 {
2718 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2719 }
2720 else if (highest_pw_len < 32)
2721 {
2722 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2723 }
2724 else
2725 {
2726 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2727 }
2728 }
2729 else
2730 {
2731 run_kernel_amp (device_param, pws_cnt);
2732
2733 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2734
2735 if (opts_type & OPTS_TYPE_HOOK12)
2736 {
2737 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2738 }
2739
2740 uint iter = salt_buf->salt_iter;
2741
2742 uint loop_step = device_param->kernel_loops;
2743
2744 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2745 {
2746 uint loop_left = iter - loop_pos;
2747
2748 loop_left = MIN (loop_left, loop_step);
2749
2750 device_param->kernel_params_buf32[25] = loop_pos;
2751 device_param->kernel_params_buf32[26] = loop_left;
2752
2753 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2754
2755 if (data.devices_status == STATUS_CRACKED) break;
2756 if (data.devices_status == STATUS_ABORTED) break;
2757 if (data.devices_status == STATUS_QUIT) break;
2758
2759 /**
2760 * speed
2761 */
2762
2763 const float iter_part = (float) (loop_pos + loop_left) / iter;
2764
2765 const u64 perf_sum_all = pws_cnt * iter_part;
2766
2767 double speed_ms;
2768
2769 hc_timer_get (device_param->timer_speed, speed_ms);
2770
2771 const u32 speed_pos = device_param->speed_pos;
2772
2773 device_param->speed_cnt[speed_pos] = perf_sum_all;
2774
2775 device_param->speed_ms[speed_pos] = speed_ms;
2776
2777 if (data.benchmark == 1)
2778 {
2779 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2780 }
2781 }
2782
2783 if (opts_type & OPTS_TYPE_HOOK23)
2784 {
2785 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2786
2787 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);
2788
2789 // do something with data
2790
2791 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);
2792 }
2793
2794 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2795 }
2796 }
2797
2798 static int run_rule_engine (const int rule_len, const char *rule_buf)
2799 {
2800 if (rule_len == 0)
2801 {
2802 return 0;
2803 }
2804 else if (rule_len == 1)
2805 {
2806 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2807 }
2808
2809 return 1;
2810 }
2811
2812 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2813 {
2814 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2815 {
2816 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);
2817 }
2818 else if (data.attack_kern == ATTACK_KERN_COMBI)
2819 {
2820 if (data.attack_mode == ATTACK_MODE_COMBI)
2821 {
2822 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2823 {
2824 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2825 {
2826 for (u32 i = 0; i < pws_cnt; i++)
2827 {
2828 const u32 pw_len = device_param->pws_buf[i].pw_len;
2829
2830 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2831
2832 ptr[pw_len] = 0x01;
2833 }
2834 }
2835 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2836 {
2837 for (u32 i = 0; i < pws_cnt; i++)
2838 {
2839 const u32 pw_len = device_param->pws_buf[i].pw_len;
2840
2841 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2842
2843 ptr[pw_len] = 0x80;
2844 }
2845 }
2846 }
2847 }
2848 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
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 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);
2875 }
2876 else if (data.attack_kern == ATTACK_KERN_BF)
2877 {
2878 const u64 off = device_param->words_off;
2879
2880 device_param->kernel_params_mp_l_buf64[3] = off;
2881
2882 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2883 }
2884 }
2885
2886 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2887 {
2888 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2889
2890 device_param->kernel_params_buf32[25] = 0;
2891 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2892 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2893
2894 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2895 {
2896 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true);
2897 }
2898 else
2899 {
2900 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true);
2901 }
2902
2903 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2904
2905 return exec_ms_prev;
2906 }
2907
2908 static void autotune (hc_device_param_t *device_param)
2909 {
2910 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2911
2912 const u32 kernel_accel_min = device_param->kernel_accel_min;
2913 const u32 kernel_accel_max = device_param->kernel_accel_max;
2914
2915 const u32 kernel_loops_min = device_param->kernel_loops_min;
2916 const u32 kernel_loops_max = device_param->kernel_loops_max;
2917
2918 u32 kernel_accel = kernel_accel_min;
2919 u32 kernel_loops = kernel_loops_min;
2920
2921 // in this case the user specified a fixed -u and -n on the commandline
2922 // no way to tune anything
2923 // but we need to run a few caching rounds
2924
2925 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2926 {
2927 try_run (device_param, kernel_accel, kernel_loops);
2928 try_run (device_param, kernel_accel, kernel_loops);
2929 try_run (device_param, kernel_accel, kernel_loops);
2930 try_run (device_param, kernel_accel, kernel_loops);
2931
2932 device_param->kernel_accel = kernel_accel;
2933 device_param->kernel_loops = kernel_loops;
2934
2935 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2936
2937 device_param->kernel_power = kernel_power;
2938
2939 return;
2940 }
2941
2942 // from here it's clear we are allowed to autotune
2943 // so let's init some fake words
2944
2945 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2946
2947 if (data.attack_kern == ATTACK_KERN_BF)
2948 {
2949 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2950 }
2951 else
2952 {
2953 for (u32 i = 0; i < kernel_power_max; i++)
2954 {
2955 device_param->pws_buf[i].i[0] = i;
2956 device_param->pws_buf[i].i[1] = 0x01234567;
2957 device_param->pws_buf[i].pw_len = 7 + (i & 7);
2958 }
2959
2960 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);
2961 }
2962
2963 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2964 {
2965 if (data.kernel_rules_cnt > 1)
2966 {
2967 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);
2968 }
2969 }
2970 else
2971 {
2972 run_kernel_amp (device_param, kernel_power_max);
2973 }
2974
2975 #define VERIFIER_CNT 1
2976
2977 // first find out highest kernel-loops that stays below target_ms
2978
2979 if (kernel_loops_min < kernel_loops_max)
2980 {
2981 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2982 {
2983 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2984
2985 for (int i = 0; i < VERIFIER_CNT; i++)
2986 {
2987 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
2988
2989 exec_ms = MIN (exec_ms, exec_ms_v);
2990 }
2991
2992 if (exec_ms < target_ms) break;
2993 }
2994 }
2995
2996 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2997
2998 #define STEPS_CNT 10
2999
3000 if (kernel_accel_min < kernel_accel_max)
3001 {
3002 for (int i = 0; i < STEPS_CNT; i++)
3003 {
3004 const u32 kernel_accel_try = 1 << i;
3005
3006 if (kernel_accel_try < kernel_accel_min) continue;
3007 if (kernel_accel_try > kernel_accel_max) break;
3008
3009 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3010
3011 for (int i = 0; i < VERIFIER_CNT; i++)
3012 {
3013 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3014
3015 exec_ms = MIN (exec_ms, exec_ms_v);
3016 }
3017
3018 if (exec_ms > target_ms) break;
3019
3020 kernel_accel = kernel_accel_try;
3021 }
3022 }
3023
3024 // at this point we want to know the actual runtime for the following reason:
3025 // we need a reference for the balancing loop following up, and this
3026 // the balancing loop can have an effect that the creates a new opportunity, for example:
3027 // if the target is 95 ms and the current runtime is 48ms the above loop
3028 // stopped the execution because the previous exec_ms was > 95ms
3029 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3030 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3031
3032 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3033
3034 for (int i = 0; i < VERIFIER_CNT; i++)
3035 {
3036 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3037
3038 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3039 }
3040
3041 u32 diff = kernel_loops - kernel_accel;
3042
3043 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3044 {
3045 u32 kernel_accel_orig = kernel_accel;
3046 u32 kernel_loops_orig = kernel_loops;
3047
3048 for (u32 f = 1; f < 1024; f++)
3049 {
3050 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3051 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3052
3053 if (kernel_accel_try > kernel_accel_max) break;
3054 if (kernel_loops_try < kernel_loops_min) break;
3055
3056 u32 diff_new = kernel_loops_try - kernel_accel_try;
3057
3058 if (diff_new > diff) break;
3059
3060 diff_new = diff;
3061
3062 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3063
3064 for (int i = 0; i < VERIFIER_CNT; i++)
3065 {
3066 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3067
3068 exec_ms = MIN (exec_ms, exec_ms_v);
3069 }
3070
3071 if (exec_ms < exec_ms_pre_final)
3072 {
3073 exec_ms_pre_final = exec_ms;
3074
3075 kernel_accel = kernel_accel_try;
3076 kernel_loops = kernel_loops_try;
3077 }
3078 }
3079 }
3080
3081 const double exec_left = target_ms / exec_ms_pre_final;
3082
3083 const double accel_left = kernel_accel_max / kernel_accel;
3084
3085 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3086
3087 if (exec_accel_min >= 1.0)
3088 {
3089 // this is safe to not overflow kernel_accel_max because of accel_left
3090
3091 kernel_accel = (double) kernel_accel * exec_accel_min;
3092 }
3093
3094 // reset them fake words
3095
3096 /*
3097 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3098
3099 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);
3100 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);
3101 */
3102
3103 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3104
3105 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3106 {
3107 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3108 }
3109
3110 // reset timer
3111
3112 device_param->exec_pos = 0;
3113
3114 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3115
3116 // store
3117
3118 device_param->kernel_accel = kernel_accel;
3119 device_param->kernel_loops = kernel_loops;
3120
3121 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3122
3123 device_param->kernel_power = kernel_power;
3124
3125 #ifdef DEBUG
3126
3127 if (data.quiet == 0)
3128 {
3129 clear_prompt ();
3130
3131 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3132 "Device #%u: autotuned kernel-loops to %u\n",
3133 device_param->device_id + 1, kernel_accel,
3134 device_param->device_id + 1, kernel_loops);
3135
3136 fprintf (stdout, "%s", PROMPT);
3137
3138 fflush (stdout);
3139 }
3140
3141 #endif
3142 }
3143
3144 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3145 {
3146 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3147
3148 // init speed timer
3149
3150 uint speed_pos = device_param->speed_pos;
3151
3152 #ifdef _POSIX
3153 if (device_param->timer_speed.tv_sec == 0)
3154 {
3155 hc_timer_set (&device_param->timer_speed);
3156 }
3157 #endif
3158
3159 #ifdef _WIN
3160 if (device_param->timer_speed.QuadPart == 0)
3161 {
3162 hc_timer_set (&device_param->timer_speed);
3163 }
3164 #endif
3165
3166 // find higest password length, this is for optimization stuff
3167
3168 uint highest_pw_len = 0;
3169
3170 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3171 {
3172 }
3173 else if (data.attack_kern == ATTACK_KERN_COMBI)
3174 {
3175 }
3176 else if (data.attack_kern == ATTACK_KERN_BF)
3177 {
3178 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3179 + device_param->kernel_params_mp_l_buf32[5];
3180 }
3181
3182 // iteration type
3183
3184 uint innerloop_step = 0;
3185 uint innerloop_cnt = 0;
3186
3187 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3188 else innerloop_step = 1;
3189
3190 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3191 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3192 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3193
3194 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3195
3196 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3197 {
3198 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3199
3200 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3201
3202 if (data.devices_status == STATUS_CRACKED) break;
3203 if (data.devices_status == STATUS_ABORTED) break;
3204 if (data.devices_status == STATUS_QUIT) break;
3205 if (data.devices_status == STATUS_BYPASS) break;
3206
3207 salt_t *salt_buf = &data.salts_buf[salt_pos];
3208
3209 device_param->kernel_params_buf32[24] = salt_pos;
3210 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3211 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3212
3213 FILE *combs_fp = device_param->combs_fp;
3214
3215 if (data.attack_mode == ATTACK_MODE_COMBI)
3216 {
3217 rewind (combs_fp);
3218 }
3219
3220 // innerloops
3221
3222 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3223 {
3224 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3225
3226 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3227
3228 if (data.devices_status == STATUS_CRACKED) break;
3229 if (data.devices_status == STATUS_ABORTED) break;
3230 if (data.devices_status == STATUS_QUIT) break;
3231 if (data.devices_status == STATUS_BYPASS) break;
3232
3233 uint innerloop_left = innerloop_cnt - innerloop_pos;
3234
3235 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3236
3237 device_param->innerloop_pos = innerloop_pos;
3238 device_param->innerloop_left = innerloop_left;
3239
3240 device_param->kernel_params_buf32[27] = innerloop_left;
3241
3242 // i think we can get rid of this
3243 if (innerloop_left == 0)
3244 {
3245 puts ("bug, how should this happen????\n");
3246
3247 continue;
3248 }
3249
3250 if (data.salts_shown[salt_pos] == 1)
3251 {
3252 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3253
3254 continue;
3255 }
3256
3257 // initialize amplifiers
3258
3259 if (data.attack_mode == ATTACK_MODE_COMBI)
3260 {
3261 uint i = 0;
3262
3263 while (i < innerloop_left)
3264 {
3265 if (feof (combs_fp)) break;
3266
3267 int line_len = fgetl (combs_fp, line_buf);
3268
3269 if (line_len >= PW_MAX1) continue;
3270
3271 line_len = convert_from_hex (line_buf, line_len);
3272
3273 char *line_buf_new = line_buf;
3274
3275 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3276 {
3277 char rule_buf_out[BLOCK_SIZE] = { 0 };
3278
3279 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3280
3281 if (rule_len_out < 0)
3282 {
3283 data.words_progress_rejected[salt_pos] += pws_cnt;
3284
3285 continue;
3286 }
3287
3288 line_len = rule_len_out;
3289
3290 line_buf_new = rule_buf_out;
3291 }
3292
3293 line_len = MIN (line_len, PW_DICTMAX);
3294
3295 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3296
3297 memcpy (ptr, line_buf_new, line_len);
3298
3299 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3300
3301 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3302 {
3303 uppercase (ptr, line_len);
3304 }
3305
3306 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3307 {
3308 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3309 {
3310 ptr[line_len] = 0x80;
3311 }
3312
3313 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3314 {
3315 ptr[line_len] = 0x01;
3316 }
3317 }
3318
3319 device_param->combs_buf[i].pw_len = line_len;
3320
3321 i++;
3322 }
3323
3324 for (uint j = i; j < innerloop_left; j++)
3325 {
3326 device_param->combs_buf[j].i[0] = 0;
3327 device_param->combs_buf[j].i[1] = 0;
3328 device_param->combs_buf[j].i[2] = 0;
3329 device_param->combs_buf[j].i[3] = 0;
3330 device_param->combs_buf[j].i[4] = 0;
3331 device_param->combs_buf[j].i[5] = 0;
3332 device_param->combs_buf[j].i[6] = 0;
3333 device_param->combs_buf[j].i[7] = 0;
3334
3335 device_param->combs_buf[j].pw_len = 0;
3336 }
3337
3338 innerloop_left = i;
3339 }
3340 else if (data.attack_mode == ATTACK_MODE_BF)
3341 {
3342 u64 off = innerloop_pos;
3343
3344 device_param->kernel_params_mp_r_buf64[3] = off;
3345
3346 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3347 }
3348 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3349 {
3350 u64 off = innerloop_pos;
3351
3352 device_param->kernel_params_mp_buf64[3] = off;
3353
3354 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3355 }
3356 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3357 {
3358 u64 off = innerloop_pos;
3359
3360 device_param->kernel_params_mp_buf64[3] = off;
3361
3362 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3363 }
3364
3365 // copy amplifiers
3366
3367 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3368 {
3369 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);
3370 }
3371 else if (data.attack_mode == ATTACK_MODE_COMBI)
3372 {
3373 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);
3374 }
3375 else if (data.attack_mode == ATTACK_MODE_BF)
3376 {
3377 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);
3378 }
3379 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3380 {
3381 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);
3382 }
3383 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3384 {
3385 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);
3386 }
3387
3388 if (data.benchmark == 1)
3389 {
3390 hc_timer_set (&device_param->timer_speed);
3391 }
3392
3393 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3394
3395 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3396
3397 if (data.devices_status == STATUS_CRACKED) break;
3398 if (data.devices_status == STATUS_ABORTED) break;
3399 if (data.devices_status == STATUS_QUIT) break;
3400
3401 /**
3402 * result
3403 */
3404
3405 if (data.benchmark == 0)
3406 {
3407 check_cracked (device_param, salt_pos);
3408 }
3409
3410 /**
3411 * progress
3412 */
3413
3414 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3415
3416 hc_thread_mutex_lock (mux_counter);
3417
3418 data.words_progress_done[salt_pos] += perf_sum_all;
3419
3420 hc_thread_mutex_unlock (mux_counter);
3421
3422 /**
3423 * speed
3424 */
3425
3426 double speed_ms;
3427
3428 hc_timer_get (device_param->timer_speed, speed_ms);
3429
3430 hc_timer_set (&device_param->timer_speed);
3431
3432 // current speed
3433
3434 //hc_thread_mutex_lock (mux_display);
3435
3436 device_param->speed_cnt[speed_pos] = perf_sum_all;
3437
3438 device_param->speed_ms[speed_pos] = speed_ms;
3439
3440 //hc_thread_mutex_unlock (mux_display);
3441
3442 speed_pos++;
3443
3444 if (speed_pos == SPEED_CACHE)
3445 {
3446 speed_pos = 0;
3447 }
3448
3449 /**
3450 * benchmark
3451 */
3452
3453 if (data.benchmark == 1) break;
3454 }
3455 }
3456
3457 device_param->speed_pos = speed_pos;
3458
3459 myfree (line_buf);
3460 }
3461
3462 static void load_segment (wl_data_t *wl_data, FILE *fd)
3463 {
3464 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3465
3466 wl_data->pos = 0;
3467
3468 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3469
3470 wl_data->buf[wl_data->cnt] = 0;
3471
3472 if (wl_data->cnt == 0) return;
3473
3474 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3475
3476 while (!feof (fd))
3477 {
3478 if (wl_data->cnt == wl_data->avail)
3479 {
3480 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3481
3482 wl_data->avail += wl_data->incr;
3483 }
3484
3485 const int c = fgetc (fd);
3486
3487 if (c == EOF) break;
3488
3489 wl_data->buf[wl_data->cnt] = (char) c;
3490
3491 wl_data->cnt++;
3492
3493 if (c == '\n') break;
3494 }
3495
3496 // ensure stream ends with a newline
3497
3498 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3499 {
3500 wl_data->cnt++;
3501
3502 wl_data->buf[wl_data->cnt - 1] = '\n';
3503 }
3504
3505 return;
3506 }
3507
3508 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3509 {
3510 char *ptr = buf;
3511
3512 for (u32 i = 0; i < sz; i++, ptr++)
3513 {
3514 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3515
3516 if (i == 7)
3517 {
3518 *off = i;
3519 *len = i;
3520
3521 return;
3522 }
3523
3524 if (*ptr != '\n') continue;
3525
3526 *off = i + 1;
3527
3528 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3529
3530 *len = i;
3531
3532 return;
3533 }
3534
3535 *off = sz;
3536 *len = sz;
3537 }
3538
3539 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3540 {
3541 char *ptr = buf;
3542
3543 for (u32 i = 0; i < sz; i++, ptr++)
3544 {
3545 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3546
3547 if (*ptr != '\n') continue;
3548
3549 *off = i + 1;
3550
3551 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3552
3553 *len = i;
3554
3555 return;
3556 }
3557
3558 *off = sz;
3559 *len = sz;
3560 }
3561
3562 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3563 {
3564 char *ptr = buf;
3565
3566 for (u32 i = 0; i < sz; i++, ptr++)
3567 {
3568 if (*ptr != '\n') continue;
3569
3570 *off = i + 1;
3571
3572 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3573
3574 *len = i;
3575
3576 return;
3577 }
3578
3579 *off = sz;
3580 *len = sz;
3581 }
3582
3583 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3584 {
3585 while (wl_data->pos < wl_data->cnt)
3586 {
3587 uint off;
3588 uint len;
3589
3590 char *ptr = wl_data->buf + wl_data->pos;
3591
3592 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3593
3594 wl_data->pos += off;
3595
3596 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3597 {
3598 char rule_buf_out[BLOCK_SIZE] = { 0 };
3599
3600 int rule_len_out = -1;
3601
3602 if (len < BLOCK_SIZE)
3603 {
3604 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3605 }
3606
3607 if (rule_len_out < 0)
3608 {
3609 continue;
3610 }
3611
3612 if (rule_len_out > PW_MAX)
3613 {
3614 continue;
3615 }
3616 }
3617 else
3618 {
3619 if (len > PW_MAX)
3620 {
3621 continue;
3622 }
3623 }
3624
3625 *out_buf = ptr;
3626 *out_len = len;
3627
3628 return;
3629 }
3630
3631 if (feof (fd))
3632 {
3633 fprintf (stderr, "BUG feof()!!\n");
3634
3635 return;
3636 }
3637
3638 load_segment (wl_data, fd);
3639
3640 get_next_word (wl_data, fd, out_buf, out_len);
3641 }
3642
3643 #ifdef _POSIX
3644 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3645 #endif
3646
3647 #ifdef _WIN
3648 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3649 #endif
3650 {
3651 hc_signal (NULL);
3652
3653 dictstat_t d;
3654
3655 d.cnt = 0;
3656
3657 #ifdef _POSIX
3658 fstat (fileno (fd), &d.stat);
3659 #endif
3660
3661 #ifdef _WIN
3662 _fstat64 (fileno (fd), &d.stat);
3663 #endif
3664
3665 d.stat.st_mode = 0;
3666 d.stat.st_nlink = 0;
3667 d.stat.st_uid = 0;
3668 d.stat.st_gid = 0;
3669 d.stat.st_rdev = 0;
3670 d.stat.st_atime = 0;
3671
3672 #ifdef _POSIX
3673 d.stat.st_blksize = 0;
3674 d.stat.st_blocks = 0;
3675 #endif
3676
3677 if (d.stat.st_size == 0) return 0;
3678
3679 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3680
3681 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3682 {
3683 if (d_cache)
3684 {
3685 u64 cnt = d_cache->cnt;
3686
3687 u64 keyspace = cnt;
3688
3689 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3690 {
3691 keyspace *= data.kernel_rules_cnt;
3692 }
3693 else if (data.attack_kern == ATTACK_KERN_COMBI)
3694 {
3695 keyspace *= data.combs_cnt;
3696 }
3697
3698 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);
3699 if (data.quiet == 0) log_info ("");
3700
3701 hc_signal (sigHandler_default);
3702
3703 return (keyspace);
3704 }
3705 }
3706
3707 time_t now = 0;
3708 time_t prev = 0;
3709
3710 u64 comp = 0;
3711 u64 cnt = 0;
3712 u64 cnt2 = 0;
3713
3714 while (!feof (fd))
3715 {
3716 load_segment (wl_data, fd);
3717
3718 comp += wl_data->cnt;
3719
3720 u32 i = 0;
3721
3722 while (i < wl_data->cnt)
3723 {
3724 u32 len;
3725 u32 off;
3726
3727 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3728
3729 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3730 {
3731 char rule_buf_out[BLOCK_SIZE] = { 0 };
3732
3733 int rule_len_out = -1;
3734
3735 if (len < BLOCK_SIZE)
3736 {
3737 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3738 }
3739
3740 if (rule_len_out < 0)
3741 {
3742 len = PW_MAX1;
3743 }
3744 else
3745 {
3746 len = rule_len_out;
3747 }
3748 }
3749
3750 if (len < PW_MAX1)
3751 {
3752 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3753 {
3754 cnt += data.kernel_rules_cnt;
3755 }
3756 else if (data.attack_kern == ATTACK_KERN_COMBI)
3757 {
3758 cnt += data.combs_cnt;
3759 }
3760
3761 d.cnt++;
3762 }
3763
3764 i += off;
3765
3766 cnt2++;
3767 }
3768
3769 time (&now);
3770
3771 if ((now - prev) == 0) continue;
3772
3773 float percent = (float) comp / (float) d.stat.st_size;
3774
3775 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);
3776
3777 time (&prev);
3778 }
3779
3780 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);
3781 if (data.quiet == 0) log_info ("");
3782
3783 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3784
3785 hc_signal (sigHandler_default);
3786
3787 return (cnt);
3788 }
3789
3790 static void *thread_monitor (void *p)
3791 {
3792 uint runtime_check = 0;
3793 uint remove_check = 0;
3794 uint status_check = 0;
3795 uint restore_check = 0;
3796
3797 uint restore_left = data.restore_timer;
3798 uint remove_left = data.remove_timer;
3799 uint status_left = data.status_timer;
3800
3801 #ifdef HAVE_HWMON
3802 uint hwmon_check = 0;
3803
3804 int slowdown_warnings = 0;
3805
3806 // these variables are mainly used for fan control
3807
3808 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3809
3810 // temperature controller "loopback" values
3811
3812 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3813 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3814
3815 int temp_threshold = 1; // degrees celcius
3816
3817 int fan_speed_min = 15; // in percentage
3818 int fan_speed_max = 100;
3819
3820 time_t last_temp_check_time;
3821 #endif // HAVE_HWMON
3822
3823 uint sleep_time = 1;
3824
3825 if (data.runtime)
3826 {
3827 runtime_check = 1;
3828 }
3829
3830 if (data.restore_timer)
3831 {
3832 restore_check = 1;
3833 }
3834
3835 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3836 {
3837 remove_check = 1;
3838 }
3839
3840 if (data.status == 1)
3841 {
3842 status_check = 1;
3843 }
3844
3845 #ifdef HAVE_HWMON
3846 if (data.gpu_temp_disable == 0)
3847 {
3848 time (&last_temp_check_time);
3849
3850 hwmon_check = 1;
3851 }
3852 #endif
3853
3854 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3855 {
3856 #ifdef HAVE_HWMON
3857 if (hwmon_check == 0)
3858 #endif
3859 return (p);
3860 }
3861
3862 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3863 {
3864 hc_sleep (sleep_time);
3865
3866 if (data.devices_status != STATUS_RUNNING) continue;
3867
3868 #ifdef HAVE_HWMON
3869
3870 if (hwmon_check == 1)
3871 {
3872 hc_thread_mutex_lock (mux_adl);
3873
3874 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3875 {
3876 hc_device_param_t *device_param = &data.devices_param[device_id];
3877
3878 if (device_param->skipped) continue;
3879
3880 if (device_param->device_vendor_id == VENDOR_ID_NV)
3881 {
3882 if (data.hm_nvapi)
3883 {
3884 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
3885 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
3886
3887 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
3888 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
3889
3890 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
3891
3892 perfPolicies_status.info_value = perfPolicies_info.info_value;
3893
3894 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
3895
3896 if (perfPolicies_status.throttle & 2)
3897 {
3898 if (slowdown_warnings < 3)
3899 {
3900 if (data.quiet == 0) clear_prompt ();
3901
3902 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
3903
3904 if (slowdown_warnings == 2)
3905 {
3906 log_info ("");
3907 }
3908
3909 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
3910 if (data.quiet == 0) fflush (stdout);
3911
3912 slowdown_warnings++;
3913 }
3914 }
3915 else
3916 {
3917 slowdown_warnings = 0;
3918 }
3919 }
3920 }
3921 }
3922
3923 hc_thread_mutex_unlock (mux_adl);
3924 }
3925
3926 if (hwmon_check == 1)
3927 {
3928 hc_thread_mutex_lock (mux_adl);
3929
3930 time_t temp_check_time;
3931
3932 time (&temp_check_time);
3933
3934 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3935
3936 if (Ta == 0) Ta = 1;
3937
3938 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3939 {
3940 hc_device_param_t *device_param = &data.devices_param[device_id];
3941
3942 if (device_param->skipped) continue;
3943
3944 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3945
3946 const int temperature = hm_get_temperature_with_device_id (device_id);
3947
3948 if (temperature > (int) data.gpu_temp_abort)
3949 {
3950 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3951
3952 if (data.devices_status != STATUS_QUIT) myabort ();
3953
3954 break;
3955 }
3956
3957 const int gpu_temp_retain = data.gpu_temp_retain;
3958
3959 if (gpu_temp_retain)
3960 {
3961 if (data.hm_device[device_id].fan_set_supported == 1)
3962 {
3963 int temp_cur = temperature;
3964
3965 int temp_diff_new = gpu_temp_retain - temp_cur;
3966
3967 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3968
3969 // calculate Ta value (time difference in seconds between the last check and this check)
3970
3971 last_temp_check_time = temp_check_time;
3972
3973 float Kp = 1.8;
3974 float Ki = 0.005;
3975 float Kd = 6;
3976
3977 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3978
3979 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);
3980
3981 if (abs (fan_diff_required) >= temp_threshold)
3982 {
3983 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3984
3985 int fan_speed_level = fan_speed_cur;
3986
3987 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3988
3989 int fan_speed_new = fan_speed_level - fan_diff_required;
3990
3991 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3992 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3993
3994 if (fan_speed_new != fan_speed_cur)
3995 {
3996 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3997 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3998
3999 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4000 {
4001 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4002 {
4003 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4004 }
4005 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4006 {
4007
4008 }
4009
4010 fan_speed_chgd[device_id] = 1;
4011 }
4012
4013 temp_diff_old[device_id] = temp_diff_new;
4014 }
4015 }
4016 }
4017 }
4018 }
4019
4020 hc_thread_mutex_unlock (mux_adl);
4021 }
4022 #endif // HAVE_HWMON
4023
4024 if (restore_check == 1)
4025 {
4026 restore_left--;
4027
4028 if (restore_left == 0)
4029 {
4030 if (data.restore_disable == 0) cycle_restore ();
4031
4032 restore_left = data.restore_timer;
4033 }
4034 }
4035
4036 if ((runtime_check == 1) && (data.runtime_start > 0))
4037 {
4038 time_t runtime_cur;
4039
4040 time (&runtime_cur);
4041
4042 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4043
4044 if (runtime_left <= 0)
4045 {
4046 if (data.benchmark == 0)
4047 {
4048 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4049 }
4050
4051 if (data.devices_status != STATUS_QUIT) myabort ();
4052 }
4053 }
4054
4055 if (remove_check == 1)
4056 {
4057 remove_left--;
4058
4059 if (remove_left == 0)
4060 {
4061 if (data.digests_saved != data.digests_done)
4062 {
4063 data.digests_saved = data.digests_done;
4064
4065 save_hash ();
4066 }
4067
4068 remove_left = data.remove_timer;
4069 }
4070 }
4071
4072 if (status_check == 1)
4073 {
4074 status_left--;
4075
4076 if (status_left == 0)
4077 {
4078 //hc_thread_mutex_lock (mux_display);
4079
4080 if (data.quiet == 0) clear_prompt ();
4081
4082 if (data.quiet == 0) log_info ("");
4083
4084 status_display ();
4085
4086 if (data.quiet == 0) log_info ("");
4087
4088 //hc_thread_mutex_unlock (mux_display);
4089
4090 status_left = data.status_timer;
4091 }
4092 }
4093 }
4094
4095 #ifdef HAVE_HWMON
4096 myfree (fan_speed_chgd);
4097
4098 myfree (temp_diff_old);
4099 myfree (temp_diff_sum);
4100 #endif
4101
4102 p = NULL;
4103
4104 return (p);
4105 }
4106
4107 static void *thread_outfile_remove (void *p)
4108 {
4109 // some hash-dependent constants
4110 char *outfile_dir = data.outfile_check_directory;
4111 uint dgst_size = data.dgst_size;
4112 uint isSalted = data.isSalted;
4113 uint esalt_size = data.esalt_size;
4114 uint hash_mode = data.hash_mode;
4115
4116 uint outfile_check_timer = data.outfile_check_timer;
4117
4118 char separator = data.separator;
4119
4120 // some hash-dependent functions
4121 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4122 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4123
4124 // buffers
4125 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4126
4127 hash_buf.digest = mymalloc (dgst_size);
4128
4129 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4130
4131 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4132
4133 uint digest_buf[64] = { 0 };
4134
4135 outfile_data_t *out_info = NULL;
4136
4137 char **out_files = NULL;
4138
4139 time_t folder_mtime = 0;
4140
4141 int out_cnt = 0;
4142
4143 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4144
4145 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4146 {
4147 hc_sleep (1);
4148
4149 if (data.devices_status != STATUS_RUNNING) continue;
4150
4151 check_left--;
4152
4153 if (check_left == 0)
4154 {
4155 struct stat outfile_check_stat;
4156
4157 if (stat (outfile_dir, &outfile_check_stat) == 0)
4158 {
4159 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4160
4161 if (is_dir == 1)
4162 {
4163 if (outfile_check_stat.st_mtime > folder_mtime)
4164 {
4165 char **out_files_new = scan_directory (outfile_dir);
4166
4167 int out_cnt_new = count_dictionaries (out_files_new);
4168
4169 outfile_data_t *out_info_new = NULL;
4170
4171 if (out_cnt_new > 0)
4172 {
4173 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4174
4175 for (int i = 0; i < out_cnt_new; i++)
4176 {
4177 out_info_new[i].file_name = out_files_new[i];
4178
4179 // check if there are files that we have seen/checked before (and not changed)
4180
4181 for (int j = 0; j < out_cnt; j++)
4182 {
4183 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4184 {
4185 struct stat outfile_stat;
4186
4187 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4188 {
4189 if (outfile_stat.st_ctime == out_info[j].ctime)
4190 {
4191 out_info_new[i].ctime = out_info[j].ctime;
4192 out_info_new[i].seek = out_info[j].seek;
4193 }
4194 }
4195 }
4196 }
4197 }
4198 }
4199
4200 local_free (out_info);
4201 local_free (out_files);
4202
4203 out_files = out_files_new;
4204 out_cnt = out_cnt_new;
4205 out_info = out_info_new;
4206
4207 folder_mtime = outfile_check_stat.st_mtime;
4208 }
4209
4210 for (int j = 0; j < out_cnt; j++)
4211 {
4212 FILE *fp = fopen (out_info[j].file_name, "rb");
4213
4214 if (fp != NULL)
4215 {
4216 //hc_thread_mutex_lock (mux_display);
4217
4218 #ifdef _POSIX
4219 struct stat outfile_stat;
4220
4221 fstat (fileno (fp), &outfile_stat);
4222 #endif
4223
4224 #ifdef _WIN
4225 struct stat64 outfile_stat;
4226
4227 _fstat64 (fileno (fp), &outfile_stat);
4228 #endif
4229
4230 if (outfile_stat.st_ctime > out_info[j].ctime)
4231 {
4232 out_info[j].ctime = outfile_stat.st_ctime;
4233 out_info[j].seek = 0;
4234 }
4235
4236 fseek (fp, out_info[j].seek, SEEK_SET);
4237
4238 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4239
4240 while (!feof (fp))
4241 {
4242 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4243
4244 if (ptr == NULL) break;
4245
4246 int line_len = strlen (line_buf);
4247
4248 if (line_len <= 0) continue;
4249
4250 int iter = MAX_CUT_TRIES;
4251
4252 for (uint i = line_len - 1; i && iter; i--, line_len--)
4253 {
4254 if (line_buf[i] != separator) continue;
4255
4256 int parser_status = PARSER_OK;
4257
4258 if ((hash_mode != 2500) && (hash_mode != 6800))
4259 {
4260 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4261 }
4262
4263 uint found = 0;
4264
4265 if (parser_status == PARSER_OK)
4266 {
4267 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4268 {
4269 if (data.salts_shown[salt_pos] == 1) continue;
4270
4271 salt_t *salt_buf = &data.salts_buf[salt_pos];
4272
4273 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4274 {
4275 uint idx = salt_buf->digests_offset + digest_pos;
4276
4277 if (data.digests_shown[idx] == 1) continue;
4278
4279 uint cracked = 0;
4280
4281 if (hash_mode == 6800)
4282 {
4283 if (i == salt_buf->salt_len)
4284 {
4285 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4286 }
4287 }
4288 else if (hash_mode == 2500)
4289 {
4290 // BSSID : MAC1 : MAC2 (:plain)
4291 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4292 {
4293 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4294
4295 if (!cracked) continue;
4296
4297 // now compare MAC1 and MAC2 too, since we have this additional info
4298 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4299 char *mac2_pos = mac1_pos + 12 + 1;
4300
4301 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4302 wpa_t *wpa = &wpas[salt_pos];
4303
4304 // compare hex string(s) vs binary MAC address(es)
4305
4306 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4307 {
4308 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4309 {
4310 cracked = 0;
4311
4312 break;
4313 }
4314 }
4315
4316 // early skip ;)
4317 if (!cracked) continue;
4318
4319 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4320 {
4321 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4322 {
4323 cracked = 0;
4324
4325 break;
4326 }
4327 }
4328 }
4329 }
4330 else
4331 {
4332 char *digests_buf_ptr = (char *) data.digests_buf;
4333
4334 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4335
4336 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4337 }
4338
4339 if (cracked == 1)
4340 {
4341 found = 1;
4342
4343 data.digests_shown[idx] = 1;
4344
4345 data.digests_done++;
4346
4347 salt_buf->digests_done++;
4348
4349 if (salt_buf->digests_done == salt_buf->digests_cnt)
4350 {
4351 data.salts_shown[salt_pos] = 1;
4352
4353 data.salts_done++;
4354
4355 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4356 }
4357 }
4358 }
4359
4360 if (data.devices_status == STATUS_CRACKED) break;
4361 }
4362 }
4363
4364 if (found) break;
4365
4366 if (data.devices_status == STATUS_CRACKED) break;
4367
4368 iter--;
4369 }
4370
4371 if (data.devices_status == STATUS_CRACKED) break;
4372 }
4373
4374 myfree (line_buf);
4375
4376 out_info[j].seek = ftell (fp);
4377
4378 //hc_thread_mutex_unlock (mux_display);
4379
4380 fclose (fp);
4381 }
4382 }
4383 }
4384 }
4385
4386 check_left = outfile_check_timer;
4387 }
4388 }
4389
4390 if (esalt_size) local_free (hash_buf.esalt);
4391
4392 if (isSalted) local_free (hash_buf.salt);
4393
4394 local_free (hash_buf.digest);
4395
4396 local_free (out_info);
4397
4398 local_free (out_files);
4399
4400 p = NULL;
4401
4402 return (p);
4403 }
4404
4405 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4406 {
4407 //if (device_param->pws_cnt < device_param->kernel_power)
4408 //{
4409 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4410
4411 u8 *ptr = (u8 *) pw->i;
4412
4413 memcpy (ptr, pw_buf, pw_len);
4414
4415 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4416
4417 pw->pw_len = pw_len;
4418
4419 device_param->pws_cnt++;
4420 //}
4421 //else
4422 //{
4423 // fprintf (stderr, "BUG pw_add()!!\n");
4424 //
4425 // return;
4426 //}
4427 }
4428
4429 static void set_kernel_power_final (const u64 kernel_power_final)
4430 {
4431 if (data.quiet == 0)
4432 {
4433 clear_prompt ();
4434
4435 //log_info ("");
4436
4437 log_info ("INFO: approaching final keyspace, workload adjusted");
4438 log_info ("");
4439
4440 fprintf (stdout, "%s", PROMPT);
4441
4442 fflush (stdout);
4443 }
4444
4445 data.kernel_power_final = kernel_power_final;
4446 }
4447
4448 static u32 get_power (hc_device_param_t *device_param)
4449 {
4450 const u64 kernel_power_final = data.kernel_power_final;
4451
4452 if (kernel_power_final)
4453 {
4454 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4455
4456 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4457
4458 // work should be at least the hardware power available without any accelerator
4459
4460 const u64 work = MAX (words_left_device, device_param->hardware_power);
4461
4462 return work;
4463 }
4464
4465 return device_param->kernel_power;
4466 }
4467
4468 static uint get_work (hc_device_param_t *device_param, const u64 max)
4469 {
4470 hc_thread_mutex_lock (mux_dispatcher);
4471
4472 const u64 words_cur = data.words_cur;
4473 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4474
4475 device_param->words_off = words_cur;
4476
4477 const u64 kernel_power_all = data.kernel_power_all;
4478
4479 const u64 words_left = words_base - words_cur;
4480
4481 if (words_left < kernel_power_all)
4482 {
4483 if (data.kernel_power_final == 0)
4484 {
4485 set_kernel_power_final (words_left);
4486 }
4487 }
4488
4489 const u32 kernel_power = get_power (device_param);
4490
4491 uint work = MIN (words_left, kernel_power);
4492
4493 work = MIN (work, max);
4494
4495 data.words_cur += work;
4496
4497 hc_thread_mutex_unlock (mux_dispatcher);
4498
4499 return work;
4500 }
4501
4502 static void *thread_autotune (void *p)
4503 {
4504 hc_device_param_t *device_param = (hc_device_param_t *) p;
4505
4506 if (device_param->skipped) return NULL;
4507
4508 autotune (device_param);
4509
4510 return NULL;
4511 }
4512
4513 static void *thread_calc_stdin (void *p)
4514 {
4515 hc_device_param_t *device_param = (hc_device_param_t *) p;
4516
4517 if (device_param->skipped) return NULL;
4518
4519 char *buf = (char *) mymalloc (HCBUFSIZ);
4520
4521 const uint attack_kern = data.attack_kern;
4522
4523 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4524 {
4525 hc_thread_mutex_lock (mux_dispatcher);
4526
4527 if (feof (stdin) != 0)
4528 {
4529 hc_thread_mutex_unlock (mux_dispatcher);
4530
4531 break;
4532 }
4533
4534 uint words_cur = 0;
4535
4536 while (words_cur < device_param->kernel_power)
4537 {
4538 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4539
4540 if (line_buf == NULL) break;
4541
4542 uint line_len = in_superchop (line_buf);
4543
4544 line_len = convert_from_hex (line_buf, line_len);
4545
4546 // post-process rule engine
4547
4548 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4549 {
4550 char rule_buf_out[BLOCK_SIZE] = { 0 };
4551
4552 int rule_len_out = -1;
4553
4554 if (line_len < BLOCK_SIZE)
4555 {
4556 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4557 }
4558
4559 if (rule_len_out < 0) continue;
4560
4561 line_buf = rule_buf_out;
4562 line_len = rule_len_out;
4563 }
4564
4565 if (line_len > PW_MAX)
4566 {
4567 continue;
4568 }
4569
4570 // hmm that's always the case, or?
4571
4572 if (attack_kern == ATTACK_KERN_STRAIGHT)
4573 {
4574 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4575 {
4576 hc_thread_mutex_lock (mux_counter);
4577
4578 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4579 {
4580 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4581 }
4582
4583 hc_thread_mutex_unlock (mux_counter);
4584
4585 continue;
4586 }
4587 }
4588
4589 pw_add (device_param, (u8 *) line_buf, line_len);
4590
4591 words_cur++;
4592
4593 if (data.devices_status == STATUS_CRACKED) break;
4594 if (data.devices_status == STATUS_ABORTED) break;
4595 if (data.devices_status == STATUS_QUIT) break;
4596 if (data.devices_status == STATUS_BYPASS) break;
4597 }
4598
4599 hc_thread_mutex_unlock (mux_dispatcher);
4600
4601 if (data.devices_status == STATUS_CRACKED) break;
4602 if (data.devices_status == STATUS_ABORTED) break;
4603 if (data.devices_status == STATUS_QUIT) break;
4604 if (data.devices_status == STATUS_BYPASS) break;
4605
4606 // flush
4607
4608 const uint pws_cnt = device_param->pws_cnt;
4609
4610 if (pws_cnt)
4611 {
4612 run_copy (device_param, pws_cnt);
4613
4614 run_cracker (device_param, pws_cnt);
4615
4616 device_param->pws_cnt = 0;
4617
4618 /*
4619 still required?
4620 if (attack_kern == ATTACK_KERN_STRAIGHT)
4621 {
4622 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4623 }
4624 else if (attack_kern == ATTACK_KERN_COMBI)
4625 {
4626 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4627 }
4628 */
4629 }
4630 }
4631
4632 device_param->kernel_accel = 0;
4633 device_param->kernel_loops = 0;
4634
4635 myfree (buf);
4636
4637 return NULL;
4638 }
4639
4640 static void *thread_calc (void *p)
4641 {
4642 hc_device_param_t *device_param = (hc_device_param_t *) p;
4643
4644 if (device_param->skipped) return NULL;
4645
4646 const uint attack_mode = data.attack_mode;
4647 const uint attack_kern = data.attack_kern;
4648
4649 if (attack_mode == ATTACK_MODE_BF)
4650 {
4651 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4652 {
4653 const uint work = get_work (device_param, -1);
4654
4655 if (work == 0) break;
4656
4657 const u64 words_off = device_param->words_off;
4658 const u64 words_fin = words_off + work;
4659
4660 const uint pws_cnt = work;
4661
4662 device_param->pws_cnt = pws_cnt;
4663
4664 if (pws_cnt)
4665 {
4666 run_copy (device_param, pws_cnt);
4667
4668 run_cracker (device_param, pws_cnt);
4669
4670 device_param->pws_cnt = 0;
4671
4672 /*
4673 still required?
4674 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4675 */
4676 }
4677
4678 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4679
4680 if (data.devices_status == STATUS_CRACKED) break;
4681 if (data.devices_status == STATUS_ABORTED) break;
4682 if (data.devices_status == STATUS_QUIT) break;
4683 if (data.devices_status == STATUS_BYPASS) break;
4684
4685 if (data.benchmark == 1) break;
4686
4687 device_param->words_done = words_fin;
4688 }
4689 }
4690 else
4691 {
4692 const uint segment_size = data.segment_size;
4693
4694 char *dictfile = data.dictfile;
4695
4696 if (attack_mode == ATTACK_MODE_COMBI)
4697 {
4698 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4699 {
4700 dictfile = data.dictfile2;
4701 }
4702 }
4703
4704 FILE *fd = fopen (dictfile, "rb");
4705
4706 if (fd == NULL)
4707 {
4708 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4709
4710 return NULL;
4711 }
4712
4713 if (attack_mode == ATTACK_MODE_COMBI)
4714 {
4715 const uint combs_mode = data.combs_mode;
4716
4717 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4718 {
4719 const char *dictfilec = data.dictfile2;
4720
4721 FILE *combs_fp = fopen (dictfilec, "rb");
4722
4723 if (combs_fp == NULL)
4724 {
4725 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4726
4727 fclose (fd);
4728
4729 return NULL;
4730 }
4731
4732 device_param->combs_fp = combs_fp;
4733 }
4734 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4735 {
4736 const char *dictfilec = data.dictfile;
4737
4738 FILE *combs_fp = fopen (dictfilec, "rb");
4739
4740 if (combs_fp == NULL)
4741 {
4742 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4743
4744 fclose (fd);
4745
4746 return NULL;
4747 }
4748
4749 device_param->combs_fp = combs_fp;
4750 }
4751 }
4752
4753 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4754
4755 wl_data->buf = (char *) mymalloc (segment_size);
4756 wl_data->avail = segment_size;
4757 wl_data->incr = segment_size;
4758 wl_data->cnt = 0;
4759 wl_data->pos = 0;
4760
4761 u64 words_cur = 0;
4762
4763 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4764 {
4765 u64 words_off = 0;
4766 u64 words_fin = 0;
4767
4768 u64 max = -1;
4769
4770 while (max)
4771 {
4772 const uint work = get_work (device_param, max);
4773
4774 if (work == 0) break;
4775
4776 max = 0;
4777
4778 words_off = device_param->words_off;
4779 words_fin = words_off + work;
4780
4781 char *line_buf;
4782 uint line_len;
4783
4784 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4785
4786 for ( ; words_cur < words_fin; words_cur++)
4787 {
4788 get_next_word (wl_data, fd, &line_buf, &line_len);
4789
4790 line_len = convert_from_hex (line_buf, line_len);
4791
4792 // post-process rule engine
4793
4794 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4795 {
4796 char rule_buf_out[BLOCK_SIZE] = { 0 };
4797
4798 int rule_len_out = -1;
4799
4800 if (line_len < BLOCK_SIZE)
4801 {
4802 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4803 }
4804
4805 if (rule_len_out < 0) continue;
4806
4807 line_buf = rule_buf_out;
4808 line_len = rule_len_out;
4809 }
4810
4811 if (attack_kern == ATTACK_KERN_STRAIGHT)
4812 {
4813 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4814 {
4815 max++;
4816
4817 hc_thread_mutex_lock (mux_counter);
4818
4819 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4820 {
4821 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4822 }
4823
4824 hc_thread_mutex_unlock (mux_counter);
4825
4826 continue;
4827 }
4828 }
4829 else if (attack_kern == ATTACK_KERN_COMBI)
4830 {
4831 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4832 // since we still need to combine the plains
4833
4834 if (line_len > data.pw_max)
4835 {
4836 max++;
4837
4838 hc_thread_mutex_lock (mux_counter);
4839
4840 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4841 {
4842 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4843 }
4844
4845 hc_thread_mutex_unlock (mux_counter);
4846
4847 continue;
4848 }
4849 }
4850
4851 pw_add (device_param, (u8 *) line_buf, line_len);
4852
4853 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4854
4855 if (data.devices_status == STATUS_CRACKED) break;
4856 if (data.devices_status == STATUS_ABORTED) break;
4857 if (data.devices_status == STATUS_QUIT) break;
4858 if (data.devices_status == STATUS_BYPASS) break;
4859 }
4860
4861 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4862
4863 if (data.devices_status == STATUS_CRACKED) break;
4864 if (data.devices_status == STATUS_ABORTED) break;
4865 if (data.devices_status == STATUS_QUIT) break;
4866 if (data.devices_status == STATUS_BYPASS) break;
4867 }
4868
4869 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4870
4871 if (data.devices_status == STATUS_CRACKED) break;
4872 if (data.devices_status == STATUS_ABORTED) break;
4873 if (data.devices_status == STATUS_QUIT) break;
4874 if (data.devices_status == STATUS_BYPASS) break;
4875
4876 //
4877 // flush
4878 //
4879
4880 const uint pws_cnt = device_param->pws_cnt;
4881
4882 if (pws_cnt)
4883 {
4884 run_copy (device_param, pws_cnt);
4885
4886 run_cracker (device_param, pws_cnt);
4887
4888 device_param->pws_cnt = 0;
4889
4890 /*
4891 still required?
4892 if (attack_kern == ATTACK_KERN_STRAIGHT)
4893 {
4894 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4895 }
4896 else if (attack_kern == ATTACK_KERN_COMBI)
4897 {
4898 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4899 }
4900 */
4901 }
4902
4903 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4904
4905 if (data.devices_status == STATUS_CRACKED) break;
4906 if (data.devices_status == STATUS_ABORTED) break;
4907 if (data.devices_status == STATUS_QUIT) break;
4908 if (data.devices_status == STATUS_BYPASS) break;
4909
4910 if (words_fin == 0) break;
4911
4912 device_param->words_done = words_fin;
4913 }
4914
4915 if (attack_mode == ATTACK_MODE_COMBI)
4916 {
4917 fclose (device_param->combs_fp);
4918 }
4919
4920 free (wl_data->buf);
4921 free (wl_data);
4922
4923 fclose (fd);
4924 }
4925
4926 device_param->kernel_accel = 0;
4927 device_param->kernel_loops = 0;
4928
4929 return NULL;
4930 }
4931
4932 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4933 {
4934 if (!device_param)
4935 {
4936 log_error ("ERROR: %s : Invalid argument", __func__);
4937
4938 exit (-1);
4939 }
4940
4941 salt_t *salt_buf = &data.salts_buf[salt_pos];
4942
4943 device_param->kernel_params_buf32[24] = salt_pos;
4944 device_param->kernel_params_buf32[27] = 1;
4945 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4946 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4947 device_param->kernel_params_buf32[30] = 0;
4948 device_param->kernel_params_buf32[31] = 1;
4949
4950 char *dictfile_old = data.dictfile;
4951
4952 const char *weak_hash_check = "weak-hash-check";
4953
4954 data.dictfile = (char *) weak_hash_check;
4955
4956 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4957
4958 data.kernel_rules_buf[0].cmds[0] = 0;
4959
4960 /**
4961 * run the kernel
4962 */
4963
4964 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4965 {
4966 run_kernel (KERN_RUN_1, device_param, 1, false);
4967 }
4968 else
4969 {
4970 run_kernel (KERN_RUN_1, device_param, 1, false);
4971
4972 uint loop_step = 16;
4973
4974 const uint iter = salt_buf->salt_iter;
4975
4976 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4977 {
4978 uint loop_left = iter - loop_pos;
4979
4980 loop_left = MIN (loop_left, loop_step);
4981
4982 device_param->kernel_params_buf32[25] = loop_pos;
4983 device_param->kernel_params_buf32[26] = loop_left;
4984
4985 run_kernel (KERN_RUN_2, device_param, 1, false);
4986 }
4987
4988 run_kernel (KERN_RUN_3, device_param, 1, false);
4989 }
4990
4991 /**
4992 * result
4993 */
4994
4995 check_cracked (device_param, salt_pos);
4996
4997 /**
4998 * cleanup
4999 */
5000
5001 device_param->kernel_params_buf32[24] = 0;
5002 device_param->kernel_params_buf32[25] = 0;
5003 device_param->kernel_params_buf32[26] = 0;
5004 device_param->kernel_params_buf32[27] = 0;
5005 device_param->kernel_params_buf32[28] = 0;
5006 device_param->kernel_params_buf32[29] = 0;
5007 device_param->kernel_params_buf32[30] = 0;
5008 device_param->kernel_params_buf32[31] = 0;
5009
5010 data.dictfile = dictfile_old;
5011
5012 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5013 }
5014
5015 // hlfmt hashcat
5016
5017 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5018 {
5019 if (data.username == 0)
5020 {
5021 *hashbuf_pos = line_buf;
5022 *hashbuf_len = line_len;
5023 }
5024 else
5025 {
5026 char *pos = line_buf;
5027 int len = line_len;
5028
5029 for (int i = 0; i < line_len; i++, pos++, len--)
5030 {
5031 if (line_buf[i] == data.separator)
5032 {
5033 pos++;
5034
5035 len--;
5036
5037 break;
5038 }
5039 }
5040
5041 *hashbuf_pos = pos;
5042 *hashbuf_len = len;
5043 }
5044 }
5045
5046 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5047 {
5048 char *pos = NULL;
5049 int len = 0;
5050
5051 int sep_cnt = 0;
5052
5053 for (int i = 0; i < line_len; i++)
5054 {
5055 if (line_buf[i] == data.separator)
5056 {
5057 sep_cnt++;
5058
5059 continue;
5060 }
5061
5062 if (sep_cnt == 0)
5063 {
5064 if (pos == NULL) pos = line_buf + i;
5065
5066 len++;
5067 }
5068 }
5069
5070 *userbuf_pos = pos;
5071 *userbuf_len = len;
5072 }
5073
5074 // hlfmt pwdump
5075
5076 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5077 {
5078 int sep_cnt = 0;
5079
5080 int sep2_len = 0;
5081 int sep3_len = 0;
5082
5083 for (int i = 0; i < line_len; i++)
5084 {
5085 if (line_buf[i] == ':')
5086 {
5087 sep_cnt++;
5088
5089 continue;
5090 }
5091
5092 if (sep_cnt == 2) sep2_len++;
5093 if (sep_cnt == 3) sep3_len++;
5094 }
5095
5096 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5097
5098 return 0;
5099 }
5100
5101 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5102 {
5103 char *pos = NULL;
5104 int len = 0;
5105
5106 int sep_cnt = 0;
5107
5108 for (int i = 0; i < line_len; i++)
5109 {
5110 if (line_buf[i] == ':')
5111 {
5112 sep_cnt++;
5113
5114 continue;
5115 }
5116
5117 if (data.hash_mode == 1000)
5118 {
5119 if (sep_cnt == 3)
5120 {
5121 if (pos == NULL) pos = line_buf + i;
5122
5123 len++;
5124 }
5125 }
5126 else if (data.hash_mode == 3000)
5127 {
5128 if (sep_cnt == 2)
5129 {
5130 if (pos == NULL) pos = line_buf + i;
5131
5132 len++;
5133 }
5134 }
5135 }
5136
5137 *hashbuf_pos = pos;
5138 *hashbuf_len = len;
5139 }
5140
5141 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5142 {
5143 char *pos = NULL;
5144 int len = 0;
5145
5146 int sep_cnt = 0;
5147
5148 for (int i = 0; i < line_len; i++)
5149 {
5150 if (line_buf[i] == ':')
5151 {
5152 sep_cnt++;
5153
5154 continue;
5155 }
5156
5157 if (sep_cnt == 0)
5158 {
5159 if (pos == NULL) pos = line_buf + i;
5160
5161 len++;
5162 }
5163 }
5164
5165 *userbuf_pos = pos;
5166 *userbuf_len = len;
5167 }
5168
5169 // hlfmt passwd
5170
5171 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5172 {
5173 int sep_cnt = 0;
5174
5175 char sep5_first = 0;
5176 char sep6_first = 0;
5177
5178 for (int i = 0; i < line_len; i++)
5179 {
5180 if (line_buf[i] == ':')
5181 {
5182 sep_cnt++;
5183
5184 continue;
5185 }
5186
5187 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5188 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5189 }
5190
5191 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5192
5193 return 0;
5194 }
5195
5196 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5197 {
5198 char *pos = NULL;
5199 int len = 0;
5200
5201 int sep_cnt = 0;
5202
5203 for (int i = 0; i < line_len; i++)
5204 {
5205 if (line_buf[i] == ':')
5206 {
5207 sep_cnt++;
5208
5209 continue;
5210 }
5211
5212 if (sep_cnt == 1)
5213 {
5214 if (pos == NULL) pos = line_buf + i;
5215
5216 len++;
5217 }
5218 }
5219
5220 *hashbuf_pos = pos;
5221 *hashbuf_len = len;
5222 }
5223
5224 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5225 {
5226 char *pos = NULL;
5227 int len = 0;
5228
5229 int sep_cnt = 0;
5230
5231 for (int i = 0; i < line_len; i++)
5232 {
5233 if (line_buf[i] == ':')
5234 {
5235 sep_cnt++;
5236
5237 continue;
5238 }
5239
5240 if (sep_cnt == 0)
5241 {
5242 if (pos == NULL) pos = line_buf + i;
5243
5244 len++;
5245 }
5246 }
5247
5248 *userbuf_pos = pos;
5249 *userbuf_len = len;
5250 }
5251
5252 // hlfmt shadow
5253
5254 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5255 {
5256 int sep_cnt = 0;
5257
5258 for (int i = 0; i < line_len; i++)
5259 {
5260 if (line_buf[i] == ':') sep_cnt++;
5261 }
5262
5263 if (sep_cnt == 8) return 1;
5264
5265 return 0;
5266 }
5267
5268 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5269 {
5270 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5271 }
5272
5273 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5274 {
5275 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5276 }
5277
5278 // hlfmt main
5279
5280 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5281 {
5282 switch (hashfile_format)
5283 {
5284 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5285 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5286 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5287 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5288 }
5289 }
5290
5291 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5292 {
5293 switch (hashfile_format)
5294 {
5295 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5296 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5297 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5298 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5299 }
5300 }
5301
5302 char *strhlfmt (const uint hashfile_format)
5303 {
5304 switch (hashfile_format)
5305 {
5306 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5307 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5308 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5309 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5310 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5311 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5312 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5313 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5314 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5315 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5316 }
5317
5318 return ((char *) "Unknown");
5319 }
5320
5321 static uint hlfmt_detect (FILE *fp, uint max_check)
5322 {
5323 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5324
5325 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5326 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5327
5328 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5329
5330 uint num_check = 0;
5331
5332 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5333
5334 while (!feof (fp))
5335 {
5336 int line_len = fgetl (fp, line_buf);
5337
5338 if (line_len == 0) continue;
5339
5340 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5341 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5342 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5343
5344 if (num_check == max_check) break;
5345
5346 num_check++;
5347 }
5348
5349 myfree (line_buf);
5350
5351 uint hashlist_format = HLFMT_HASHCAT;
5352
5353 for (int i = 1; i < HLFMTS_CNT; i++)
5354 {
5355 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5356
5357 hashlist_format = i;
5358 }
5359
5360 free (formats_cnt);
5361
5362 return hashlist_format;
5363 }
5364
5365 /**
5366 * some further helper function
5367 */
5368
5369 // wrapper around mymalloc for ADL
5370
5371 #if defined(HAVE_HWMON)
5372 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5373 {
5374 return mymalloc (iSize);
5375 }
5376 #endif
5377
5378 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)
5379 {
5380 u64 collisions = 0;
5381
5382 const uint dgst_pos0 = data.dgst_pos0;
5383 const uint dgst_pos1 = data.dgst_pos1;
5384 const uint dgst_pos2 = data.dgst_pos2;
5385 const uint dgst_pos3 = data.dgst_pos3;
5386
5387 memset (bitmap_a, 0, bitmap_size);
5388 memset (bitmap_b, 0, bitmap_size);
5389 memset (bitmap_c, 0, bitmap_size);
5390 memset (bitmap_d, 0, bitmap_size);
5391
5392 for (uint i = 0; i < digests_cnt; i++)
5393 {
5394 uint *digest_ptr = (uint *) digests_buf_ptr;
5395
5396 digests_buf_ptr += dgst_size;
5397
5398 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5399 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5400 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5401 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5402
5403 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5404 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5405 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5406 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5407
5408 if (bitmap_a[idx0] & val0) collisions++;
5409 if (bitmap_b[idx1] & val1) collisions++;
5410 if (bitmap_c[idx2] & val2) collisions++;
5411 if (bitmap_d[idx3] & val3) collisions++;
5412
5413 bitmap_a[idx0] |= val0;
5414 bitmap_b[idx1] |= val1;
5415 bitmap_c[idx2] |= val2;
5416 bitmap_d[idx3] |= val3;
5417
5418 if (collisions >= collisions_max) return 0x7fffffff;
5419 }
5420
5421 return collisions;
5422 }
5423
5424 /**
5425 * main
5426 */
5427
5428 #ifdef _WIN
5429 void SetConsoleWindowSize (const int x)
5430 {
5431 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5432
5433 if (h == INVALID_HANDLE_VALUE) return;
5434
5435 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5436
5437 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5438
5439 SMALL_RECT *sr = &bufferInfo.srWindow;
5440
5441 sr->Right = MAX (sr->Right, x - 1);
5442
5443 COORD co;
5444
5445 co.X = sr->Right + 1;
5446 co.Y = 9999;
5447
5448 if (!SetConsoleScreenBufferSize (h, co)) return;
5449
5450 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5451 }
5452 #endif
5453
5454 #ifdef _POSIX
5455 int (*clock_gettime_orig) (clockid_t clk_id, struct timespec *tp);
5456
5457 int clock_gettime (clockid_t clk_id, struct timespec *tp)
5458 {
5459 int r = clock_gettime_orig (clk_id, tp);
5460
5461 usleep (NVIDIA_100PERCENTCPU_WORKAROUND);
5462
5463 return r;
5464 }
5465 #endif
5466
5467 int main (int argc, char **argv)
5468 {
5469 #ifdef _POSIX
5470 clock_gettime_orig = dlsym (RTLD_NEXT, "clock_gettime");
5471 #endif
5472
5473 #ifdef _WIN
5474 SetConsoleWindowSize (132);
5475 #endif
5476
5477 /**
5478 * To help users a bit
5479 */
5480
5481 char *compute = getenv ("COMPUTE");
5482
5483 if (compute)
5484 {
5485 static char display[100];
5486
5487 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5488
5489 putenv (display);
5490 }
5491 else
5492 {
5493 if (getenv ("DISPLAY") == NULL)
5494 putenv ((char *) "DISPLAY=:0");
5495 }
5496
5497 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5498 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5499
5500 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5501 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5502
5503 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5504 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5505
5506 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5507 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5508
5509 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5510 putenv ((char *) "POCL_KERNEL_CACHE=0");
5511
5512 umask (077);
5513
5514 /**
5515 * Real init
5516 */
5517
5518 memset (&data, 0, sizeof (hc_global_data_t));
5519
5520 time_t proc_start;
5521
5522 time (&proc_start);
5523
5524 data.proc_start = proc_start;
5525
5526 int myargc = argc;
5527 char **myargv = argv;
5528
5529 hc_thread_mutex_init (mux_dispatcher);
5530 hc_thread_mutex_init (mux_counter);
5531 hc_thread_mutex_init (mux_display);
5532 hc_thread_mutex_init (mux_adl);
5533
5534 /**
5535 * commandline parameters
5536 */
5537
5538 uint usage = USAGE;
5539 uint version = VERSION;
5540 uint quiet = QUIET;
5541 uint benchmark = BENCHMARK;
5542 uint show = SHOW;
5543 uint left = LEFT;
5544 uint username = USERNAME;
5545 uint remove = REMOVE;
5546 uint remove_timer = REMOVE_TIMER;
5547 u64 skip = SKIP;
5548 u64 limit = LIMIT;
5549 uint keyspace = KEYSPACE;
5550 uint potfile_disable = POTFILE_DISABLE;
5551 char *potfile_path = NULL;
5552 uint debug_mode = DEBUG_MODE;
5553 char *debug_file = NULL;
5554 char *induction_dir = NULL;
5555 char *outfile_check_dir = NULL;
5556 uint force = FORCE;
5557 uint runtime = RUNTIME;
5558 uint hash_mode = HASH_MODE;
5559 uint attack_mode = ATTACK_MODE;
5560 uint markov_disable = MARKOV_DISABLE;
5561 uint markov_classic = MARKOV_CLASSIC;
5562 uint markov_threshold = MARKOV_THRESHOLD;
5563 char *markov_hcstat = NULL;
5564 char *outfile = NULL;
5565 uint outfile_format = OUTFILE_FORMAT;
5566 uint outfile_autohex = OUTFILE_AUTOHEX;
5567 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5568 uint restore = RESTORE;
5569 uint restore_timer = RESTORE_TIMER;
5570 uint restore_disable = RESTORE_DISABLE;
5571 uint status = STATUS;
5572 uint status_timer = STATUS_TIMER;
5573 uint machine_readable = MACHINE_READABLE;
5574 uint loopback = LOOPBACK;
5575 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5576 char *session = NULL;
5577 uint hex_charset = HEX_CHARSET;
5578 uint hex_salt = HEX_SALT;
5579 uint hex_wordlist = HEX_WORDLIST;
5580 uint rp_gen = RP_GEN;
5581 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5582 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5583 uint rp_gen_seed = RP_GEN_SEED;
5584 char *rule_buf_l = (char *) RULE_BUF_L;
5585 char *rule_buf_r = (char *) RULE_BUF_R;
5586 uint increment = INCREMENT;
5587 uint increment_min = INCREMENT_MIN;
5588 uint increment_max = INCREMENT_MAX;
5589 char *cpu_affinity = NULL;
5590 OCL_PTR *ocl = NULL;
5591 char *opencl_devices = NULL;
5592 char *opencl_platforms = NULL;
5593 char *opencl_device_types = NULL;
5594 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5595 char *truecrypt_keyfiles = NULL;
5596 char *veracrypt_keyfiles = NULL;
5597 uint veracrypt_pim = 0;
5598 uint workload_profile = WORKLOAD_PROFILE;
5599 uint kernel_accel = KERNEL_ACCEL;
5600 uint kernel_loops = KERNEL_LOOPS;
5601 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5602 #ifdef HAVE_HWMON
5603 uint gpu_temp_abort = GPU_TEMP_ABORT;
5604 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5605 uint powertune_enable = POWERTUNE_ENABLE;
5606 #endif
5607 uint logfile_disable = LOGFILE_DISABLE;
5608 uint segment_size = SEGMENT_SIZE;
5609 uint scrypt_tmto = SCRYPT_TMTO;
5610 char separator = SEPARATOR;
5611 uint bitmap_min = BITMAP_MIN;
5612 uint bitmap_max = BITMAP_MAX;
5613 char *custom_charset_1 = NULL;
5614 char *custom_charset_2 = NULL;
5615 char *custom_charset_3 = NULL;
5616 char *custom_charset_4 = NULL;
5617
5618 #define IDX_HELP 'h'
5619 #define IDX_VERSION 'V'
5620 #define IDX_VERSION_LOWER 'v'
5621 #define IDX_QUIET 0xff02
5622 #define IDX_SHOW 0xff03
5623 #define IDX_LEFT 0xff04
5624 #define IDX_REMOVE 0xff05
5625 #define IDX_REMOVE_TIMER 0xff37
5626 #define IDX_SKIP 's'
5627 #define IDX_LIMIT 'l'
5628 #define IDX_KEYSPACE 0xff35
5629 #define IDX_POTFILE_DISABLE 0xff06
5630 #define IDX_POTFILE_PATH 0xffe0
5631 #define IDX_DEBUG_MODE 0xff43
5632 #define IDX_DEBUG_FILE 0xff44
5633 #define IDX_INDUCTION_DIR 0xff46
5634 #define IDX_OUTFILE_CHECK_DIR 0xff47
5635 #define IDX_USERNAME 0xff07
5636 #define IDX_FORCE 0xff08
5637 #define IDX_RUNTIME 0xff09
5638 #define IDX_BENCHMARK 'b'
5639 #define IDX_HASH_MODE 'm'
5640 #define IDX_ATTACK_MODE 'a'
5641 #define IDX_RP_FILE 'r'
5642 #define IDX_RP_GEN 'g'
5643 #define IDX_RP_GEN_FUNC_MIN 0xff10
5644 #define IDX_RP_GEN_FUNC_MAX 0xff11
5645 #define IDX_RP_GEN_SEED 0xff34
5646 #define IDX_RULE_BUF_L 'j'
5647 #define IDX_RULE_BUF_R 'k'
5648 #define IDX_INCREMENT 'i'
5649 #define IDX_INCREMENT_MIN 0xff12
5650 #define IDX_INCREMENT_MAX 0xff13
5651 #define IDX_OUTFILE 'o'
5652 #define IDX_OUTFILE_FORMAT 0xff14
5653 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5654 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5655 #define IDX_RESTORE 0xff15
5656 #define IDX_RESTORE_DISABLE 0xff27
5657 #define IDX_STATUS 0xff17
5658 #define IDX_STATUS_TIMER 0xff18
5659 #define IDX_MACHINE_READABLE 0xff50
5660 #define IDX_LOOPBACK 0xff38
5661 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5662 #define IDX_SESSION 0xff19
5663 #define IDX_HEX_CHARSET 0xff20
5664 #define IDX_HEX_SALT 0xff21
5665 #define IDX_HEX_WORDLIST 0xff40
5666 #define IDX_MARKOV_DISABLE 0xff22
5667 #define IDX_MARKOV_CLASSIC 0xff23
5668 #define IDX_MARKOV_THRESHOLD 't'
5669 #define IDX_MARKOV_HCSTAT 0xff24
5670 #define IDX_CPU_AFFINITY 0xff25
5671 #define IDX_OPENCL_DEVICES 'd'
5672 #define IDX_OPENCL_PLATFORMS 0xff72
5673 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5674 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5675 #define IDX_WORKLOAD_PROFILE 'w'
5676 #define IDX_KERNEL_ACCEL 'n'
5677 #define IDX_KERNEL_LOOPS 'u'
5678 #define IDX_GPU_TEMP_DISABLE 0xff29
5679 #define IDX_GPU_TEMP_ABORT 0xff30
5680 #define IDX_GPU_TEMP_RETAIN 0xff31
5681 #define IDX_POWERTUNE_ENABLE 0xff41
5682 #define IDX_LOGFILE_DISABLE 0xff51
5683 #define IDX_TRUECRYPT_KEYFILES 0xff52
5684 #define IDX_VERACRYPT_KEYFILES 0xff53
5685 #define IDX_VERACRYPT_PIM 0xff54
5686 #define IDX_SCRYPT_TMTO 0xff61
5687 #define IDX_SEGMENT_SIZE 'c'
5688 #define IDX_SEPARATOR 'p'
5689 #define IDX_BITMAP_MIN 0xff70
5690 #define IDX_BITMAP_MAX 0xff71
5691 #define IDX_CUSTOM_CHARSET_1 '1'
5692 #define IDX_CUSTOM_CHARSET_2 '2'
5693 #define IDX_CUSTOM_CHARSET_3 '3'
5694 #define IDX_CUSTOM_CHARSET_4 '4'
5695
5696 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5697
5698 struct option long_options[] =
5699 {
5700 {"help", no_argument, 0, IDX_HELP},
5701 {"version", no_argument, 0, IDX_VERSION},
5702 {"quiet", no_argument, 0, IDX_QUIET},
5703 {"show", no_argument, 0, IDX_SHOW},
5704 {"left", no_argument, 0, IDX_LEFT},
5705 {"username", no_argument, 0, IDX_USERNAME},
5706 {"remove", no_argument, 0, IDX_REMOVE},
5707 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5708 {"skip", required_argument, 0, IDX_SKIP},
5709 {"limit", required_argument, 0, IDX_LIMIT},
5710 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5711 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5712 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5713 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5714 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5715 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5716 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5717 {"force", no_argument, 0, IDX_FORCE},
5718 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5719 {"restore", no_argument, 0, IDX_RESTORE},
5720 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5721 {"status", no_argument, 0, IDX_STATUS},
5722 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5723 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5724 {"loopback", no_argument, 0, IDX_LOOPBACK},
5725 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5726 {"session", required_argument, 0, IDX_SESSION},
5727 {"runtime", required_argument, 0, IDX_RUNTIME},
5728 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5729 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5730 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5731 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5732 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5733 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5734 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5735 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5736 {"rules-file", required_argument, 0, IDX_RP_FILE},
5737 {"outfile", required_argument, 0, IDX_OUTFILE},
5738 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5739 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5740 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5741 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5742 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5743 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5744 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5745 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5746 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5747 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5748 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5749 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5750 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5751 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5752 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5753 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5754 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5755 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5756 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5757 #ifdef HAVE_HWMON
5758 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5759 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5760 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5761 #endif // HAVE_HWMON
5762 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5763 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5764 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5765 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5766 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5767 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5768 {"seperator", required_argument, 0, IDX_SEPARATOR},
5769 {"separator", required_argument, 0, IDX_SEPARATOR},
5770 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5771 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5772 {"increment", no_argument, 0, IDX_INCREMENT},
5773 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5774 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5775 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5776 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5777 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5778 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5779 {0, 0, 0, 0}
5780 };
5781
5782 uint rp_files_cnt = 0;
5783
5784 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5785
5786 int option_index = 0;
5787 int c = -1;
5788
5789 optind = 1;
5790 optopt = 0;
5791
5792 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5793 {
5794 switch (c)
5795 {
5796 case IDX_HELP: usage = 1; break;
5797 case IDX_VERSION:
5798 case IDX_VERSION_LOWER: version = 1; break;
5799 case IDX_RESTORE: restore = 1; break;
5800 case IDX_SESSION: session = optarg; break;
5801 case IDX_SHOW: show = 1; break;
5802 case IDX_LEFT: left = 1; break;
5803 case '?': return (-1);
5804 }
5805 }
5806
5807 if (optopt != 0)
5808 {
5809 log_error ("ERROR: Invalid argument specified");
5810
5811 return (-1);
5812 }
5813
5814 /**
5815 * exit functions
5816 */
5817
5818 if (version)
5819 {
5820 log_info ("%s", VERSION_TAG);
5821
5822 return (0);
5823 }
5824
5825 if (usage)
5826 {
5827 usage_big_print (PROGNAME);
5828
5829 return (0);
5830 }
5831
5832 /**
5833 * session needs to be set, always!
5834 */
5835
5836 if (session == NULL) session = (char *) PROGNAME;
5837
5838 /**
5839 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5840 */
5841
5842 char *exec_path = get_exec_path ();
5843
5844 #ifdef LINUX
5845
5846 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5847 char *resolved_exec_path = realpath (exec_path, NULL);
5848
5849 char *install_dir = get_install_dir (resolved_exec_path);
5850 char *profile_dir = NULL;
5851 char *session_dir = NULL;
5852 char *shared_dir = NULL;
5853
5854 if (strcmp (install_dir, resolved_install_folder) == 0)
5855 {
5856 struct passwd *pw = getpwuid (getuid ());
5857
5858 const char *homedir = pw->pw_dir;
5859
5860 profile_dir = get_profile_dir (homedir);
5861 session_dir = get_session_dir (profile_dir);
5862 shared_dir = strdup (SHARED_FOLDER);
5863
5864 mkdir (profile_dir, 0700);
5865 mkdir (session_dir, 0700);
5866 }
5867 else
5868 {
5869 profile_dir = install_dir;
5870 session_dir = install_dir;
5871 shared_dir = install_dir;
5872 }
5873
5874 myfree (resolved_install_folder);
5875 myfree (resolved_exec_path);
5876
5877 #else
5878
5879 char *install_dir = get_install_dir (exec_path);
5880 char *profile_dir = install_dir;
5881 char *session_dir = install_dir;
5882 char *shared_dir = install_dir;
5883
5884 #endif
5885
5886 data.install_dir = install_dir;
5887 data.profile_dir = profile_dir;
5888 data.session_dir = session_dir;
5889 data.shared_dir = shared_dir;
5890
5891 myfree (exec_path);
5892
5893 /**
5894 * kernel cache, we need to make sure folder exist
5895 */
5896
5897 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5898
5899 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5900
5901 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5902
5903 mkdir (kernels_folder, 0700);
5904
5905 myfree (kernels_folder);
5906
5907 /**
5908 * session
5909 */
5910
5911 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5912
5913 data.session = session;
5914
5915 char *eff_restore_file = (char *) mymalloc (session_size);
5916 char *new_restore_file = (char *) mymalloc (session_size);
5917
5918 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5919 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5920
5921 data.eff_restore_file = eff_restore_file;
5922 data.new_restore_file = new_restore_file;
5923
5924 if (((show == 1) || (left == 1)) && (restore == 1))
5925 {
5926 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5927 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5928
5929 return (-1);
5930 }
5931
5932 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5933 if ((show == 1) || (left == 1))
5934 {
5935 restore_disable = 1;
5936
5937 restore = 0;
5938 }
5939
5940 data.restore_disable = restore_disable;
5941
5942 restore_data_t *rd = init_restore (argc, argv);
5943
5944 data.rd = rd;
5945
5946 /**
5947 * restore file
5948 */
5949
5950 if (restore == 1)
5951 {
5952 read_restore (eff_restore_file, rd);
5953
5954 if (rd->version_bin < RESTORE_MIN)
5955 {
5956 log_error ("ERROR: Incompatible restore-file version");
5957
5958 return (-1);
5959 }
5960
5961 myargc = rd->argc;
5962 myargv = rd->argv;
5963
5964 #ifdef _POSIX
5965 rd->pid = getpid ();
5966 #elif _WIN
5967 rd->pid = GetCurrentProcessId ();
5968 #endif
5969 }
5970
5971 uint hash_mode_chgd = 0;
5972 uint runtime_chgd = 0;
5973 uint kernel_loops_chgd = 0;
5974 uint kernel_accel_chgd = 0;
5975 uint attack_mode_chgd = 0;
5976 uint outfile_format_chgd = 0;
5977 uint rp_gen_seed_chgd = 0;
5978 uint remove_timer_chgd = 0;
5979 uint increment_min_chgd = 0;
5980 uint increment_max_chgd = 0;
5981 uint workload_profile_chgd = 0;
5982 uint opencl_vector_width_chgd = 0;
5983
5984 optind = 1;
5985 optopt = 0;
5986 option_index = 0;
5987
5988 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5989 {
5990 switch (c)
5991 {
5992 //case IDX_HELP: usage = 1; break;
5993 //case IDX_VERSION: version = 1; break;
5994 //case IDX_RESTORE: restore = 1; break;
5995 case IDX_QUIET: quiet = 1; break;
5996 //case IDX_SHOW: show = 1; break;
5997 case IDX_SHOW: break;
5998 //case IDX_LEFT: left = 1; break;
5999 case IDX_LEFT: break;
6000 case IDX_USERNAME: username = 1; break;
6001 case IDX_REMOVE: remove = 1; break;
6002 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6003 remove_timer_chgd = 1; break;
6004 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6005 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6006 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6007 case IDX_DEBUG_FILE: debug_file = optarg; break;
6008 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6009 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6010 case IDX_FORCE: force = 1; break;
6011 case IDX_SKIP: skip = atoll (optarg); break;
6012 case IDX_LIMIT: limit = atoll (optarg); break;
6013 case IDX_KEYSPACE: keyspace = 1; break;
6014 case IDX_BENCHMARK: benchmark = 1; break;
6015 case IDX_RESTORE: break;
6016 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6017 case IDX_STATUS: status = 1; break;
6018 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6019 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6020 case IDX_LOOPBACK: loopback = 1; break;
6021 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6022 //case IDX_SESSION: session = optarg; break;
6023 case IDX_SESSION: break;
6024 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6025 hash_mode_chgd = 1; break;
6026 case IDX_RUNTIME: runtime = atoi (optarg);
6027 runtime_chgd = 1; break;
6028 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6029 attack_mode_chgd = 1; break;
6030 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6031 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6032 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6033 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6034 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6035 rp_gen_seed_chgd = 1; break;
6036 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6037 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6038 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6039 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6040 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6041 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6042 case IDX_OUTFILE: outfile = optarg; break;
6043 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6044 outfile_format_chgd = 1; break;
6045 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6046 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6047 case IDX_HEX_CHARSET: hex_charset = 1; break;
6048 case IDX_HEX_SALT: hex_salt = 1; break;
6049 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6050 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6051 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6052 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6053 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6054 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6055 opencl_vector_width_chgd = 1; break;
6056 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6057 workload_profile_chgd = 1; break;
6058 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6059 kernel_accel_chgd = 1; break;
6060 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6061 kernel_loops_chgd = 1; break;
6062 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6063 #ifdef HAVE_HWMON
6064 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6065 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6066 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6067 #endif // HAVE_HWMON
6068 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6069 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6070 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6071 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6072 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6073 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6074 case IDX_SEPARATOR: separator = optarg[0]; break;
6075 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6076 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6077 case IDX_INCREMENT: increment = 1; break;
6078 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6079 increment_min_chgd = 1; break;
6080 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6081 increment_max_chgd = 1; break;
6082 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6083 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6084 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6085 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6086
6087 default:
6088 log_error ("ERROR: Invalid argument specified");
6089 return (-1);
6090 }
6091 }
6092
6093 if (optopt != 0)
6094 {
6095 log_error ("ERROR: Invalid argument specified");
6096
6097 return (-1);
6098 }
6099
6100 /**
6101 * Inform user things getting started,
6102 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6103 * - we do not need to check algorithm_pos
6104 */
6105
6106 if (quiet == 0)
6107 {
6108 if (benchmark == 1)
6109 {
6110 if (machine_readable == 0)
6111 {
6112 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6113 log_info ("");
6114 log_info ("Note: Reported benchmark cracking speed = real cracking speed");
6115 log_info ("To verify, run hashcat like this: only_one_hash.txt -a 3 -w 3 ?b?b?b?b?b?b?b");
6116 log_info ("");
6117 }
6118 else
6119 {
6120 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6121 }
6122 }
6123 else if (restore == 1)
6124 {
6125 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6126 log_info ("");
6127 }
6128 else
6129 {
6130 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6131 log_info ("");
6132 }
6133 }
6134
6135 /**
6136 * sanity check
6137 */
6138
6139 if (attack_mode > 7)
6140 {
6141 log_error ("ERROR: Invalid attack-mode specified");
6142
6143 return (-1);
6144 }
6145
6146 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6147 {
6148 log_error ("ERROR: Invalid runtime specified");
6149
6150 return (-1);
6151 }
6152
6153 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6154 {
6155 log_error ("ERROR: Invalid hash-type specified");
6156
6157 return (-1);
6158 }
6159
6160 // renamed hash modes
6161
6162 if (hash_mode_chgd)
6163 {
6164 int n = -1;
6165
6166 switch (hash_mode)
6167 {
6168 case 123: n = 124;
6169 break;
6170 }
6171
6172 if (n >= 0)
6173 {
6174 log_error ("Old -m specified, use -m %d instead", n);
6175
6176 return (-1);
6177 }
6178 }
6179
6180 if (username == 1)
6181 {
6182 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6183 {
6184 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6185
6186 return (-1);
6187 }
6188 }
6189
6190 if (outfile_format > 16)
6191 {
6192 log_error ("ERROR: Invalid outfile-format specified");
6193
6194 return (-1);
6195 }
6196
6197 if (left == 1)
6198 {
6199 if (outfile_format_chgd == 1)
6200 {
6201 if (outfile_format > 1)
6202 {
6203 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6204
6205 return (-1);
6206 }
6207 }
6208 else
6209 {
6210 outfile_format = OUTFILE_FMT_HASH;
6211 }
6212 }
6213
6214 if (show == 1)
6215 {
6216 if (outfile_format_chgd == 1)
6217 {
6218 if ((outfile_format > 7) && (outfile_format < 16))
6219 {
6220 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6221
6222 return (-1);
6223 }
6224 }
6225 }
6226
6227 if (increment_min < INCREMENT_MIN)
6228 {
6229 log_error ("ERROR: Invalid increment-min specified");
6230
6231 return (-1);
6232 }
6233
6234 if (increment_max > INCREMENT_MAX)
6235 {
6236 log_error ("ERROR: Invalid increment-max specified");
6237
6238 return (-1);
6239 }
6240
6241 if (increment_min > increment_max)
6242 {
6243 log_error ("ERROR: Invalid increment-min specified");
6244
6245 return (-1);
6246 }
6247
6248 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6249 {
6250 log_error ("ERROR: increment is not allowed in attack-mode 0");
6251
6252 return (-1);
6253 }
6254
6255 if ((increment == 0) && (increment_min_chgd == 1))
6256 {
6257 log_error ("ERROR: increment-min is only supported together with increment switch");
6258
6259 return (-1);
6260 }
6261
6262 if ((increment == 0) && (increment_max_chgd == 1))
6263 {
6264 log_error ("ERROR: increment-max is only supported together with increment switch");
6265
6266 return (-1);
6267 }
6268
6269 if (rp_files_cnt && rp_gen)
6270 {
6271 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6272
6273 return (-1);
6274 }
6275
6276 if (rp_files_cnt || rp_gen)
6277 {
6278 if (attack_mode != ATTACK_MODE_STRAIGHT)
6279 {
6280 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6281
6282 return (-1);
6283 }
6284 }
6285
6286 if (rp_gen_func_min > rp_gen_func_max)
6287 {
6288 log_error ("ERROR: Invalid rp-gen-func-min specified");
6289
6290 return (-1);
6291 }
6292
6293 if (kernel_accel_chgd == 1)
6294 {
6295 if (force == 0)
6296 {
6297 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6298 log_info ("Please consider using the option -w instead");
6299 log_info ("You can use --force to override this but do not post error reports if you do so");
6300 log_info ("");
6301
6302 return (-1);
6303 }
6304
6305 if (kernel_accel < 1)
6306 {
6307 log_error ("ERROR: Invalid kernel-accel specified");
6308
6309 return (-1);
6310 }
6311
6312 if (kernel_accel > 1024)
6313 {
6314 log_error ("ERROR: Invalid kernel-accel specified");
6315
6316 return (-1);
6317 }
6318 }
6319
6320 if (kernel_loops_chgd == 1)
6321 {
6322 if (force == 0)
6323 {
6324 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6325 log_info ("Please consider using the option -w instead");
6326 log_info ("You can use --force to override this but do not post error reports if you do so");
6327 log_info ("");
6328
6329 return (-1);
6330 }
6331
6332 if (kernel_loops < 1)
6333 {
6334 log_error ("ERROR: Invalid kernel-loops specified");
6335
6336 return (-1);
6337 }
6338
6339 if (kernel_loops > 1024)
6340 {
6341 log_error ("ERROR: Invalid kernel-loops specified");
6342
6343 return (-1);
6344 }
6345 }
6346
6347 if ((workload_profile < 1) || (workload_profile > 4))
6348 {
6349 log_error ("ERROR: workload-profile %i not available", workload_profile);
6350
6351 return (-1);
6352 }
6353
6354 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6355 {
6356 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6357
6358 return (-1);
6359 }
6360
6361 if (show == 1 || left == 1)
6362 {
6363 attack_mode = ATTACK_MODE_NONE;
6364
6365 if (remove == 1)
6366 {
6367 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6368
6369 return (-1);
6370 }
6371
6372 if (potfile_disable == 1)
6373 {
6374 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6375
6376 return (-1);
6377 }
6378 }
6379
6380 uint attack_kern = ATTACK_KERN_NONE;
6381
6382 switch (attack_mode)
6383 {
6384 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6385 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6386 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6387 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6388 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6389 }
6390
6391 if (benchmark == 0)
6392 {
6393 if (keyspace == 1)
6394 {
6395 int num_additional_params = 1;
6396
6397 if (attack_kern == ATTACK_KERN_COMBI)
6398 {
6399 num_additional_params = 2;
6400 }
6401
6402 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6403
6404 if (keyspace_wordlist_specified == 0) optind--;
6405 }
6406
6407 if (attack_kern == ATTACK_KERN_NONE)
6408 {
6409 if ((optind + 1) != myargc)
6410 {
6411 usage_mini_print (myargv[0]);
6412
6413 return (-1);
6414 }
6415 }
6416 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6417 {
6418 if ((optind + 1) > myargc)
6419 {
6420 usage_mini_print (myargv[0]);
6421
6422 return (-1);
6423 }
6424 }
6425 else if (attack_kern == ATTACK_KERN_COMBI)
6426 {
6427 if ((optind + 3) != myargc)
6428 {
6429 usage_mini_print (myargv[0]);
6430
6431 return (-1);
6432 }
6433 }
6434 else if (attack_kern == ATTACK_KERN_BF)
6435 {
6436 if ((optind + 1) > myargc)
6437 {
6438 usage_mini_print (myargv[0]);
6439
6440 return (-1);
6441 }
6442 }
6443 else
6444 {
6445 usage_mini_print (myargv[0]);
6446
6447 return (-1);
6448 }
6449 }
6450 else
6451 {
6452 if (myargv[optind] != 0)
6453 {
6454 log_error ("ERROR: Invalid argument for benchmark mode specified");
6455
6456 return (-1);
6457 }
6458
6459 if (attack_mode_chgd == 1)
6460 {
6461 if (attack_mode != ATTACK_MODE_BF)
6462 {
6463 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6464
6465 return (-1);
6466 }
6467 }
6468 }
6469
6470 if (skip != 0 && limit != 0)
6471 {
6472 limit += skip;
6473 }
6474
6475 if (keyspace == 1)
6476 {
6477 if (show == 1)
6478 {
6479 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6480
6481 return (-1);
6482 }
6483 else if (left == 1)
6484 {
6485 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6486
6487 return (-1);
6488 }
6489
6490 potfile_disable = 1;
6491
6492 restore_disable = 1;
6493
6494 restore = 0;
6495
6496 weak_hash_threshold = 0;
6497
6498 quiet = 1;
6499 }
6500
6501 if (remove_timer_chgd == 1)
6502 {
6503 if (remove == 0)
6504 {
6505 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6506
6507 return (-1);
6508 }
6509
6510 if (remove_timer < 1)
6511 {
6512 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6513
6514 return (-1);
6515 }
6516 }
6517
6518 if (loopback == 1)
6519 {
6520 if (attack_mode == ATTACK_MODE_STRAIGHT)
6521 {
6522 if ((rp_files_cnt == 0) && (rp_gen == 0))
6523 {
6524 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6525
6526 return (-1);
6527 }
6528 }
6529 else
6530 {
6531 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6532
6533 return (-1);
6534 }
6535 }
6536
6537 if (debug_mode > 0)
6538 {
6539 if (attack_mode != ATTACK_MODE_STRAIGHT)
6540 {
6541 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6542
6543 return (-1);
6544 }
6545
6546 if ((rp_files_cnt == 0) && (rp_gen == 0))
6547 {
6548 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6549
6550 return (-1);
6551 }
6552 }
6553
6554 if (debug_mode > 4)
6555 {
6556 log_error ("ERROR: Invalid debug-mode specified");
6557
6558 return (-1);
6559 }
6560
6561 if (debug_file != NULL)
6562 {
6563 if (debug_mode < 1)
6564 {
6565 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6566
6567 return (-1);
6568 }
6569 }
6570
6571 if (induction_dir != NULL)
6572 {
6573 if (attack_mode == ATTACK_MODE_BF)
6574 {
6575 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6576
6577 return (-1);
6578 }
6579 }
6580
6581 if (attack_mode != ATTACK_MODE_STRAIGHT)
6582 {
6583 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6584 {
6585 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6586
6587 return (-1);
6588 }
6589
6590 weak_hash_threshold = 0;
6591 }
6592
6593 /**
6594 * induction directory
6595 */
6596
6597 char *induction_directory = NULL;
6598
6599 if (attack_mode != ATTACK_MODE_BF)
6600 {
6601 if (induction_dir == NULL)
6602 {
6603 induction_directory = (char *) mymalloc (session_size);
6604
6605 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6606
6607 // create induction folder if it does not already exist
6608
6609 if (keyspace == 0)
6610 {
6611 if (rmdir (induction_directory) == -1)
6612 {
6613 if (errno == ENOENT)
6614 {
6615 // good, we can ignore
6616 }
6617 else if (errno == ENOTEMPTY)
6618 {
6619 char *induction_directory_mv = (char *) mymalloc (session_size);
6620
6621 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6622
6623 if (rename (induction_directory, induction_directory_mv) != 0)
6624 {
6625 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6626
6627 return (-1);
6628 }
6629 }
6630 else
6631 {
6632 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6633
6634 return (-1);
6635 }
6636 }
6637
6638 if (mkdir (induction_directory, 0700) == -1)
6639 {
6640 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6641
6642 return (-1);
6643 }
6644 }
6645 }
6646 else
6647 {
6648 induction_directory = induction_dir;
6649 }
6650 }
6651
6652 data.induction_directory = induction_directory;
6653
6654 /**
6655 * loopback
6656 */
6657
6658 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6659
6660 char *loopback_file = (char *) mymalloc (loopback_size);
6661
6662 /**
6663 * tuning db
6664 */
6665
6666 char tuning_db_file[256] = { 0 };
6667
6668 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6669
6670 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6671
6672 /**
6673 * outfile-check directory
6674 */
6675
6676 char *outfile_check_directory = NULL;
6677
6678 if (outfile_check_dir == NULL)
6679 {
6680 outfile_check_directory = (char *) mymalloc (session_size);
6681
6682 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6683 }
6684 else
6685 {
6686 outfile_check_directory = outfile_check_dir;
6687 }
6688
6689 data.outfile_check_directory = outfile_check_directory;
6690
6691 if (keyspace == 0)
6692 {
6693 struct stat outfile_check_stat;
6694
6695 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6696 {
6697 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6698
6699 if (is_dir == 0)
6700 {
6701 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6702
6703 return (-1);
6704 }
6705 }
6706 else if (outfile_check_dir == NULL)
6707 {
6708 if (mkdir (outfile_check_directory, 0700) == -1)
6709 {
6710 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6711
6712 return (-1);
6713 }
6714 }
6715 }
6716
6717 /**
6718 * special other stuff
6719 */
6720
6721 if (hash_mode == 9710)
6722 {
6723 outfile_format = 5;
6724 outfile_format_chgd = 1;
6725 }
6726
6727 if (hash_mode == 9810)
6728 {
6729 outfile_format = 5;
6730 outfile_format_chgd = 1;
6731 }
6732
6733 if (hash_mode == 10410)
6734 {
6735 outfile_format = 5;
6736 outfile_format_chgd = 1;
6737 }
6738
6739 /**
6740 * store stuff
6741 */
6742
6743 data.hash_mode = hash_mode;
6744 data.restore = restore;
6745 data.restore_timer = restore_timer;
6746 data.restore_disable = restore_disable;
6747 data.status = status;
6748 data.status_timer = status_timer;
6749 data.machine_readable = machine_readable;
6750 data.loopback = loopback;
6751 data.runtime = runtime;
6752 data.remove = remove;
6753 data.remove_timer = remove_timer;
6754 data.debug_mode = debug_mode;
6755 data.debug_file = debug_file;
6756 data.username = username;
6757 data.quiet = quiet;
6758 data.outfile = outfile;
6759 data.outfile_format = outfile_format;
6760 data.outfile_autohex = outfile_autohex;
6761 data.hex_charset = hex_charset;
6762 data.hex_salt = hex_salt;
6763 data.hex_wordlist = hex_wordlist;
6764 data.separator = separator;
6765 data.rp_files = rp_files;
6766 data.rp_files_cnt = rp_files_cnt;
6767 data.rp_gen = rp_gen;
6768 data.rp_gen_seed = rp_gen_seed;
6769 data.force = force;
6770 data.benchmark = benchmark;
6771 data.skip = skip;
6772 data.limit = limit;
6773 #ifdef HAVE_HWMON
6774 data.powertune_enable = powertune_enable;
6775 #endif
6776 data.logfile_disable = logfile_disable;
6777 data.truecrypt_keyfiles = truecrypt_keyfiles;
6778 data.veracrypt_keyfiles = veracrypt_keyfiles;
6779 data.veracrypt_pim = veracrypt_pim;
6780 data.scrypt_tmto = scrypt_tmto;
6781 data.workload_profile = workload_profile;
6782
6783 /**
6784 * cpu affinity
6785 */
6786
6787 if (cpu_affinity)
6788 {
6789 set_cpu_affinity (cpu_affinity);
6790 }
6791
6792 if (rp_gen_seed_chgd == 0)
6793 {
6794 srand (proc_start);
6795 }
6796 else
6797 {
6798 srand (rp_gen_seed);
6799 }
6800
6801 /**
6802 * logfile init
6803 */
6804
6805 if (logfile_disable == 0)
6806 {
6807 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6808
6809 char *logfile = (char *) mymalloc (logfile_size);
6810
6811 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6812
6813 data.logfile = logfile;
6814
6815 char *topid = logfile_generate_topid ();
6816
6817 data.topid = topid;
6818 }
6819
6820 // logfile_append() checks for logfile_disable internally to make it easier from here
6821
6822 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6823 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6824 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6825 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6826 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6827 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6828 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6829 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6830 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6831 #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));
6832
6833 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6834 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6835 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6836 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6837 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6838 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6839 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6840 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6841
6842 logfile_top_msg ("START");
6843
6844 logfile_top_uint (attack_mode);
6845 logfile_top_uint (attack_kern);
6846 logfile_top_uint (benchmark);
6847 logfile_top_uint (bitmap_min);
6848 logfile_top_uint (bitmap_max);
6849 logfile_top_uint (debug_mode);
6850 logfile_top_uint (force);
6851 logfile_top_uint (kernel_accel);
6852 logfile_top_uint (kernel_loops);
6853 logfile_top_uint (gpu_temp_disable);
6854 #ifdef HAVE_HWMON
6855 logfile_top_uint (gpu_temp_abort);
6856 logfile_top_uint (gpu_temp_retain);
6857 #endif
6858 logfile_top_uint (hash_mode);
6859 logfile_top_uint (hex_charset);
6860 logfile_top_uint (hex_salt);
6861 logfile_top_uint (hex_wordlist);
6862 logfile_top_uint (increment);
6863 logfile_top_uint (increment_max);
6864 logfile_top_uint (increment_min);
6865 logfile_top_uint (keyspace);
6866 logfile_top_uint (left);
6867 logfile_top_uint (logfile_disable);
6868 logfile_top_uint (loopback);
6869 logfile_top_uint (markov_classic);
6870 logfile_top_uint (markov_disable);
6871 logfile_top_uint (markov_threshold);
6872 logfile_top_uint (outfile_autohex);
6873 logfile_top_uint (outfile_check_timer);
6874 logfile_top_uint (outfile_format);
6875 logfile_top_uint (potfile_disable);
6876 logfile_top_string (potfile_path);
6877 #if defined(HAVE_HWMON)
6878 logfile_top_uint (powertune_enable);
6879 #endif
6880 logfile_top_uint (scrypt_tmto);
6881 logfile_top_uint (quiet);
6882 logfile_top_uint (remove);
6883 logfile_top_uint (remove_timer);
6884 logfile_top_uint (restore);
6885 logfile_top_uint (restore_disable);
6886 logfile_top_uint (restore_timer);
6887 logfile_top_uint (rp_gen);
6888 logfile_top_uint (rp_gen_func_max);
6889 logfile_top_uint (rp_gen_func_min);
6890 logfile_top_uint (rp_gen_seed);
6891 logfile_top_uint (runtime);
6892 logfile_top_uint (segment_size);
6893 logfile_top_uint (show);
6894 logfile_top_uint (status);
6895 logfile_top_uint (machine_readable);
6896 logfile_top_uint (status_timer);
6897 logfile_top_uint (usage);
6898 logfile_top_uint (username);
6899 logfile_top_uint (version);
6900 logfile_top_uint (weak_hash_threshold);
6901 logfile_top_uint (workload_profile);
6902 logfile_top_uint64 (limit);
6903 logfile_top_uint64 (skip);
6904 logfile_top_char (separator);
6905 logfile_top_string (cpu_affinity);
6906 logfile_top_string (custom_charset_1);
6907 logfile_top_string (custom_charset_2);
6908 logfile_top_string (custom_charset_3);
6909 logfile_top_string (custom_charset_4);
6910 logfile_top_string (debug_file);
6911 logfile_top_string (opencl_devices);
6912 logfile_top_string (opencl_platforms);
6913 logfile_top_string (opencl_device_types);
6914 logfile_top_uint (opencl_vector_width);
6915 logfile_top_string (induction_dir);
6916 logfile_top_string (markov_hcstat);
6917 logfile_top_string (outfile);
6918 logfile_top_string (outfile_check_dir);
6919 logfile_top_string (rule_buf_l);
6920 logfile_top_string (rule_buf_r);
6921 logfile_top_string (session);
6922 logfile_top_string (truecrypt_keyfiles);
6923 logfile_top_string (veracrypt_keyfiles);
6924 logfile_top_uint (veracrypt_pim);
6925
6926 /**
6927 * Init OpenCL library loader
6928 */
6929
6930 if (keyspace == 0)
6931 {
6932 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6933
6934 ocl_init (ocl);
6935
6936 data.ocl = ocl;
6937 }
6938
6939 /**
6940 * OpenCL platform selection
6941 */
6942
6943 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6944
6945 /**
6946 * OpenCL device selection
6947 */
6948
6949 u32 devices_filter = setup_devices_filter (opencl_devices);
6950
6951 /**
6952 * OpenCL device type selection
6953 */
6954
6955 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6956
6957 /**
6958 * benchmark
6959 */
6960
6961 if (benchmark == 1)
6962 {
6963 /**
6964 * disable useless stuff for benchmark
6965 */
6966
6967 status_timer = 0;
6968 restore_timer = 0;
6969 restore_disable = 1;
6970 potfile_disable = 1;
6971 weak_hash_threshold = 0;
6972 gpu_temp_disable = 1;
6973
6974 #ifdef HAVE_HWMON
6975 if (powertune_enable == 1)
6976 {
6977 gpu_temp_disable = 0;
6978 }
6979 #endif
6980
6981 data.status_timer = status_timer;
6982 data.restore_timer = restore_timer;
6983 data.restore_disable = restore_disable;
6984
6985 /**
6986 * force attack mode to be bruteforce
6987 */
6988
6989 attack_mode = ATTACK_MODE_BF;
6990 attack_kern = ATTACK_KERN_BF;
6991
6992 if (workload_profile_chgd == 0)
6993 {
6994 workload_profile = 3;
6995
6996 data.workload_profile = workload_profile;
6997 }
6998 }
6999
7000 /**
7001 * config
7002 */
7003
7004 uint hash_type = 0;
7005 uint salt_type = 0;
7006 uint attack_exec = 0;
7007 uint opts_type = 0;
7008 uint kern_type = 0;
7009 uint dgst_size = 0;
7010 uint esalt_size = 0;
7011 uint opti_type = 0;
7012 uint dgst_pos0 = -1;
7013 uint dgst_pos1 = -1;
7014 uint dgst_pos2 = -1;
7015 uint dgst_pos3 = -1;
7016
7017 int (*parse_func) (char *, uint, hash_t *);
7018 int (*sort_by_digest) (const void *, const void *);
7019
7020 uint algorithm_pos = 0;
7021 uint algorithm_max = 1;
7022
7023 uint *algorithms = default_benchmark_algorithms;
7024
7025 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7026
7027 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7028 {
7029 /*
7030 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7031 * the following algos are skipped entirely
7032 */
7033
7034 if (algorithm_pos > 0)
7035 {
7036 local_free (rd);
7037
7038 rd = init_restore (argc, argv);
7039
7040 data.rd = rd;
7041 }
7042
7043 /**
7044 * update hash_mode in case of multihash benchmark
7045 */
7046
7047 if (benchmark == 1)
7048 {
7049 if (hash_mode_chgd == 0)
7050 {
7051 hash_mode = algorithms[algorithm_pos];
7052
7053 data.hash_mode = hash_mode;
7054 }
7055
7056 quiet = 1;
7057
7058 data.quiet = quiet;
7059 }
7060
7061 switch (hash_mode)
7062 {
7063 case 0: hash_type = HASH_TYPE_MD5;
7064 salt_type = SALT_TYPE_NONE;
7065 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7066 opts_type = OPTS_TYPE_PT_GENERATE_LE
7067 | OPTS_TYPE_PT_ADD80
7068 | OPTS_TYPE_PT_ADDBITS14;
7069 kern_type = KERN_TYPE_MD5;
7070 dgst_size = DGST_SIZE_4_4;
7071 parse_func = md5_parse_hash;
7072 sort_by_digest = sort_by_digest_4_4;
7073 opti_type = OPTI_TYPE_ZERO_BYTE
7074 | OPTI_TYPE_PRECOMPUTE_INIT
7075 | OPTI_TYPE_PRECOMPUTE_MERKLE
7076 | OPTI_TYPE_MEET_IN_MIDDLE
7077 | OPTI_TYPE_EARLY_SKIP
7078 | OPTI_TYPE_NOT_ITERATED
7079 | OPTI_TYPE_NOT_SALTED
7080 | OPTI_TYPE_RAW_HASH;
7081 dgst_pos0 = 0;
7082 dgst_pos1 = 3;
7083 dgst_pos2 = 2;
7084 dgst_pos3 = 1;
7085 break;
7086
7087 case 10: hash_type = HASH_TYPE_MD5;
7088 salt_type = SALT_TYPE_INTERN;
7089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7090 opts_type = OPTS_TYPE_PT_GENERATE_LE
7091 | OPTS_TYPE_ST_ADD80
7092 | OPTS_TYPE_ST_ADDBITS14;
7093 kern_type = KERN_TYPE_MD5_PWSLT;
7094 dgst_size = DGST_SIZE_4_4;
7095 parse_func = md5s_parse_hash;
7096 sort_by_digest = sort_by_digest_4_4;
7097 opti_type = OPTI_TYPE_ZERO_BYTE
7098 | OPTI_TYPE_PRECOMPUTE_INIT
7099 | OPTI_TYPE_PRECOMPUTE_MERKLE
7100 | OPTI_TYPE_MEET_IN_MIDDLE
7101 | OPTI_TYPE_EARLY_SKIP
7102 | OPTI_TYPE_NOT_ITERATED
7103 | OPTI_TYPE_APPENDED_SALT
7104 | OPTI_TYPE_RAW_HASH;
7105 dgst_pos0 = 0;
7106 dgst_pos1 = 3;
7107 dgst_pos2 = 2;
7108 dgst_pos3 = 1;
7109 break;
7110
7111 case 11: hash_type = HASH_TYPE_MD5;
7112 salt_type = SALT_TYPE_INTERN;
7113 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7114 opts_type = OPTS_TYPE_PT_GENERATE_LE
7115 | OPTS_TYPE_ST_ADD80
7116 | OPTS_TYPE_ST_ADDBITS14;
7117 kern_type = KERN_TYPE_MD5_PWSLT;
7118 dgst_size = DGST_SIZE_4_4;
7119 parse_func = joomla_parse_hash;
7120 sort_by_digest = sort_by_digest_4_4;
7121 opti_type = OPTI_TYPE_ZERO_BYTE
7122 | OPTI_TYPE_PRECOMPUTE_INIT
7123 | OPTI_TYPE_PRECOMPUTE_MERKLE
7124 | OPTI_TYPE_MEET_IN_MIDDLE
7125 | OPTI_TYPE_EARLY_SKIP
7126 | OPTI_TYPE_NOT_ITERATED
7127 | OPTI_TYPE_APPENDED_SALT
7128 | OPTI_TYPE_RAW_HASH;
7129 dgst_pos0 = 0;
7130 dgst_pos1 = 3;
7131 dgst_pos2 = 2;
7132 dgst_pos3 = 1;
7133 break;
7134
7135 case 12: hash_type = HASH_TYPE_MD5;
7136 salt_type = SALT_TYPE_INTERN;
7137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7138 opts_type = OPTS_TYPE_PT_GENERATE_LE
7139 | OPTS_TYPE_ST_ADD80
7140 | OPTS_TYPE_ST_ADDBITS14;
7141 kern_type = KERN_TYPE_MD5_PWSLT;
7142 dgst_size = DGST_SIZE_4_4;
7143 parse_func = postgresql_parse_hash;
7144 sort_by_digest = sort_by_digest_4_4;
7145 opti_type = OPTI_TYPE_ZERO_BYTE
7146 | OPTI_TYPE_PRECOMPUTE_INIT
7147 | OPTI_TYPE_PRECOMPUTE_MERKLE
7148 | OPTI_TYPE_MEET_IN_MIDDLE
7149 | OPTI_TYPE_EARLY_SKIP
7150 | OPTI_TYPE_NOT_ITERATED
7151 | OPTI_TYPE_APPENDED_SALT
7152 | OPTI_TYPE_RAW_HASH;
7153 dgst_pos0 = 0;
7154 dgst_pos1 = 3;
7155 dgst_pos2 = 2;
7156 dgst_pos3 = 1;
7157 break;
7158
7159 case 20: hash_type = HASH_TYPE_MD5;
7160 salt_type = SALT_TYPE_INTERN;
7161 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7162 opts_type = OPTS_TYPE_PT_GENERATE_LE
7163 | OPTS_TYPE_PT_ADD80
7164 | OPTS_TYPE_PT_ADDBITS14;
7165 kern_type = KERN_TYPE_MD5_SLTPW;
7166 dgst_size = DGST_SIZE_4_4;
7167 parse_func = md5s_parse_hash;
7168 sort_by_digest = sort_by_digest_4_4;
7169 opti_type = OPTI_TYPE_ZERO_BYTE
7170 | OPTI_TYPE_PRECOMPUTE_INIT
7171 | OPTI_TYPE_PRECOMPUTE_MERKLE
7172 | OPTI_TYPE_EARLY_SKIP
7173 | OPTI_TYPE_NOT_ITERATED
7174 | OPTI_TYPE_PREPENDED_SALT
7175 | OPTI_TYPE_RAW_HASH;
7176 dgst_pos0 = 0;
7177 dgst_pos1 = 3;
7178 dgst_pos2 = 2;
7179 dgst_pos3 = 1;
7180 break;
7181
7182 case 21: hash_type = HASH_TYPE_MD5;
7183 salt_type = SALT_TYPE_INTERN;
7184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7185 opts_type = OPTS_TYPE_PT_GENERATE_LE
7186 | OPTS_TYPE_PT_ADD80
7187 | OPTS_TYPE_PT_ADDBITS14;
7188 kern_type = KERN_TYPE_MD5_SLTPW;
7189 dgst_size = DGST_SIZE_4_4;
7190 parse_func = osc_parse_hash;
7191 sort_by_digest = sort_by_digest_4_4;
7192 opti_type = OPTI_TYPE_ZERO_BYTE
7193 | OPTI_TYPE_PRECOMPUTE_INIT
7194 | OPTI_TYPE_PRECOMPUTE_MERKLE
7195 | OPTI_TYPE_EARLY_SKIP
7196 | OPTI_TYPE_NOT_ITERATED
7197 | OPTI_TYPE_PREPENDED_SALT
7198 | OPTI_TYPE_RAW_HASH;
7199 dgst_pos0 = 0;
7200 dgst_pos1 = 3;
7201 dgst_pos2 = 2;
7202 dgst_pos3 = 1;
7203 break;
7204
7205 case 22: hash_type = HASH_TYPE_MD5;
7206 salt_type = SALT_TYPE_EMBEDDED;
7207 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7208 opts_type = OPTS_TYPE_PT_GENERATE_LE
7209 | OPTS_TYPE_PT_ADD80
7210 | OPTS_TYPE_PT_ADDBITS14;
7211 kern_type = KERN_TYPE_MD5_SLTPW;
7212 dgst_size = DGST_SIZE_4_4;
7213 parse_func = netscreen_parse_hash;
7214 sort_by_digest = sort_by_digest_4_4;
7215 opti_type = OPTI_TYPE_ZERO_BYTE
7216 | OPTI_TYPE_PRECOMPUTE_INIT
7217 | OPTI_TYPE_PRECOMPUTE_MERKLE
7218 | OPTI_TYPE_EARLY_SKIP
7219 | OPTI_TYPE_NOT_ITERATED
7220 | OPTI_TYPE_PREPENDED_SALT
7221 | OPTI_TYPE_RAW_HASH;
7222 dgst_pos0 = 0;
7223 dgst_pos1 = 3;
7224 dgst_pos2 = 2;
7225 dgst_pos3 = 1;
7226 break;
7227
7228 case 23: hash_type = HASH_TYPE_MD5;
7229 salt_type = SALT_TYPE_EMBEDDED;
7230 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7231 opts_type = OPTS_TYPE_PT_GENERATE_LE
7232 | OPTS_TYPE_PT_ADD80
7233 | OPTS_TYPE_PT_ADDBITS14;
7234 kern_type = KERN_TYPE_MD5_SLTPW;
7235 dgst_size = DGST_SIZE_4_4;
7236 parse_func = skype_parse_hash;
7237 sort_by_digest = sort_by_digest_4_4;
7238 opti_type = OPTI_TYPE_ZERO_BYTE
7239 | OPTI_TYPE_PRECOMPUTE_INIT
7240 | OPTI_TYPE_PRECOMPUTE_MERKLE
7241 | OPTI_TYPE_EARLY_SKIP
7242 | OPTI_TYPE_NOT_ITERATED
7243 | OPTI_TYPE_PREPENDED_SALT
7244 | OPTI_TYPE_RAW_HASH;
7245 dgst_pos0 = 0;
7246 dgst_pos1 = 3;
7247 dgst_pos2 = 2;
7248 dgst_pos3 = 1;
7249 break;
7250
7251 case 30: hash_type = HASH_TYPE_MD5;
7252 salt_type = SALT_TYPE_INTERN;
7253 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7254 opts_type = OPTS_TYPE_PT_GENERATE_LE
7255 | OPTS_TYPE_PT_UNICODE
7256 | OPTS_TYPE_ST_ADD80
7257 | OPTS_TYPE_ST_ADDBITS14;
7258 kern_type = KERN_TYPE_MD5_PWUSLT;
7259 dgst_size = DGST_SIZE_4_4;
7260 parse_func = md5s_parse_hash;
7261 sort_by_digest = sort_by_digest_4_4;
7262 opti_type = OPTI_TYPE_ZERO_BYTE
7263 | OPTI_TYPE_PRECOMPUTE_INIT
7264 | OPTI_TYPE_PRECOMPUTE_MERKLE
7265 | OPTI_TYPE_MEET_IN_MIDDLE
7266 | OPTI_TYPE_EARLY_SKIP
7267 | OPTI_TYPE_NOT_ITERATED
7268 | OPTI_TYPE_APPENDED_SALT
7269 | OPTI_TYPE_RAW_HASH;
7270 dgst_pos0 = 0;
7271 dgst_pos1 = 3;
7272 dgst_pos2 = 2;
7273 dgst_pos3 = 1;
7274 break;
7275
7276 case 40: hash_type = HASH_TYPE_MD5;
7277 salt_type = SALT_TYPE_INTERN;
7278 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7279 opts_type = OPTS_TYPE_PT_GENERATE_LE
7280 | OPTS_TYPE_PT_ADD80
7281 | OPTS_TYPE_PT_ADDBITS14
7282 | OPTS_TYPE_PT_UNICODE;
7283 kern_type = KERN_TYPE_MD5_SLTPWU;
7284 dgst_size = DGST_SIZE_4_4;
7285 parse_func = md5s_parse_hash;
7286 sort_by_digest = sort_by_digest_4_4;
7287 opti_type = OPTI_TYPE_ZERO_BYTE
7288 | OPTI_TYPE_PRECOMPUTE_INIT
7289 | OPTI_TYPE_PRECOMPUTE_MERKLE
7290 | OPTI_TYPE_EARLY_SKIP
7291 | OPTI_TYPE_NOT_ITERATED
7292 | OPTI_TYPE_PREPENDED_SALT
7293 | OPTI_TYPE_RAW_HASH;
7294 dgst_pos0 = 0;
7295 dgst_pos1 = 3;
7296 dgst_pos2 = 2;
7297 dgst_pos3 = 1;
7298 break;
7299
7300 case 50: hash_type = HASH_TYPE_MD5;
7301 salt_type = SALT_TYPE_INTERN;
7302 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7303 opts_type = OPTS_TYPE_PT_GENERATE_LE
7304 | OPTS_TYPE_ST_ADD80
7305 | OPTS_TYPE_ST_ADDBITS14;
7306 kern_type = KERN_TYPE_HMACMD5_PW;
7307 dgst_size = DGST_SIZE_4_4;
7308 parse_func = hmacmd5_parse_hash;
7309 sort_by_digest = sort_by_digest_4_4;
7310 opti_type = OPTI_TYPE_ZERO_BYTE
7311 | OPTI_TYPE_NOT_ITERATED;
7312 dgst_pos0 = 0;
7313 dgst_pos1 = 3;
7314 dgst_pos2 = 2;
7315 dgst_pos3 = 1;
7316 break;
7317
7318 case 60: hash_type = HASH_TYPE_MD5;
7319 salt_type = SALT_TYPE_INTERN;
7320 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7321 opts_type = OPTS_TYPE_PT_GENERATE_LE
7322 | OPTS_TYPE_PT_ADD80
7323 | OPTS_TYPE_PT_ADDBITS14;
7324 kern_type = KERN_TYPE_HMACMD5_SLT;
7325 dgst_size = DGST_SIZE_4_4;
7326 parse_func = hmacmd5_parse_hash;
7327 sort_by_digest = sort_by_digest_4_4;
7328 opti_type = OPTI_TYPE_ZERO_BYTE
7329 | OPTI_TYPE_NOT_ITERATED;
7330 dgst_pos0 = 0;
7331 dgst_pos1 = 3;
7332 dgst_pos2 = 2;
7333 dgst_pos3 = 1;
7334 break;
7335
7336 case 100: hash_type = HASH_TYPE_SHA1;
7337 salt_type = SALT_TYPE_NONE;
7338 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7339 opts_type = OPTS_TYPE_PT_GENERATE_BE
7340 | OPTS_TYPE_PT_ADD80
7341 | OPTS_TYPE_PT_ADDBITS15;
7342 kern_type = KERN_TYPE_SHA1;
7343 dgst_size = DGST_SIZE_4_5;
7344 parse_func = sha1_parse_hash;
7345 sort_by_digest = sort_by_digest_4_5;
7346 opti_type = OPTI_TYPE_ZERO_BYTE
7347 | OPTI_TYPE_PRECOMPUTE_INIT
7348 | OPTI_TYPE_PRECOMPUTE_MERKLE
7349 | OPTI_TYPE_EARLY_SKIP
7350 | OPTI_TYPE_NOT_ITERATED
7351 | OPTI_TYPE_NOT_SALTED
7352 | OPTI_TYPE_RAW_HASH;
7353 dgst_pos0 = 3;
7354 dgst_pos1 = 4;
7355 dgst_pos2 = 2;
7356 dgst_pos3 = 1;
7357 break;
7358
7359 case 101: hash_type = HASH_TYPE_SHA1;
7360 salt_type = SALT_TYPE_NONE;
7361 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7362 opts_type = OPTS_TYPE_PT_GENERATE_BE
7363 | OPTS_TYPE_PT_ADD80
7364 | OPTS_TYPE_PT_ADDBITS15;
7365 kern_type = KERN_TYPE_SHA1;
7366 dgst_size = DGST_SIZE_4_5;
7367 parse_func = sha1b64_parse_hash;
7368 sort_by_digest = sort_by_digest_4_5;
7369 opti_type = OPTI_TYPE_ZERO_BYTE
7370 | OPTI_TYPE_PRECOMPUTE_INIT
7371 | OPTI_TYPE_PRECOMPUTE_MERKLE
7372 | OPTI_TYPE_EARLY_SKIP
7373 | OPTI_TYPE_NOT_ITERATED
7374 | OPTI_TYPE_NOT_SALTED
7375 | OPTI_TYPE_RAW_HASH;
7376 dgst_pos0 = 3;
7377 dgst_pos1 = 4;
7378 dgst_pos2 = 2;
7379 dgst_pos3 = 1;
7380 break;
7381
7382 case 110: hash_type = HASH_TYPE_SHA1;
7383 salt_type = SALT_TYPE_INTERN;
7384 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7385 opts_type = OPTS_TYPE_PT_GENERATE_BE
7386 | OPTS_TYPE_ST_ADD80
7387 | OPTS_TYPE_ST_ADDBITS15;
7388 kern_type = KERN_TYPE_SHA1_PWSLT;
7389 dgst_size = DGST_SIZE_4_5;
7390 parse_func = sha1s_parse_hash;
7391 sort_by_digest = sort_by_digest_4_5;
7392 opti_type = OPTI_TYPE_ZERO_BYTE
7393 | OPTI_TYPE_PRECOMPUTE_INIT
7394 | OPTI_TYPE_PRECOMPUTE_MERKLE
7395 | OPTI_TYPE_EARLY_SKIP
7396 | OPTI_TYPE_NOT_ITERATED
7397 | OPTI_TYPE_APPENDED_SALT
7398 | OPTI_TYPE_RAW_HASH;
7399 dgst_pos0 = 3;
7400 dgst_pos1 = 4;
7401 dgst_pos2 = 2;
7402 dgst_pos3 = 1;
7403 break;
7404
7405 case 111: hash_type = HASH_TYPE_SHA1;
7406 salt_type = SALT_TYPE_EMBEDDED;
7407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7408 opts_type = OPTS_TYPE_PT_GENERATE_BE
7409 | OPTS_TYPE_ST_ADD80
7410 | OPTS_TYPE_ST_ADDBITS15;
7411 kern_type = KERN_TYPE_SHA1_PWSLT;
7412 dgst_size = DGST_SIZE_4_5;
7413 parse_func = sha1b64s_parse_hash;
7414 sort_by_digest = sort_by_digest_4_5;
7415 opti_type = OPTI_TYPE_ZERO_BYTE
7416 | OPTI_TYPE_PRECOMPUTE_INIT
7417 | OPTI_TYPE_PRECOMPUTE_MERKLE
7418 | OPTI_TYPE_EARLY_SKIP
7419 | OPTI_TYPE_NOT_ITERATED
7420 | OPTI_TYPE_APPENDED_SALT
7421 | OPTI_TYPE_RAW_HASH;
7422 dgst_pos0 = 3;
7423 dgst_pos1 = 4;
7424 dgst_pos2 = 2;
7425 dgst_pos3 = 1;
7426 break;
7427
7428 case 112: hash_type = HASH_TYPE_SHA1;
7429 salt_type = SALT_TYPE_INTERN;
7430 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7431 opts_type = OPTS_TYPE_PT_GENERATE_BE
7432 | OPTS_TYPE_ST_ADD80
7433 | OPTS_TYPE_ST_ADDBITS15
7434 | OPTS_TYPE_ST_HEX;
7435 kern_type = KERN_TYPE_SHA1_PWSLT;
7436 dgst_size = DGST_SIZE_4_5;
7437 parse_func = oracles_parse_hash;
7438 sort_by_digest = sort_by_digest_4_5;
7439 opti_type = OPTI_TYPE_ZERO_BYTE
7440 | OPTI_TYPE_PRECOMPUTE_INIT
7441 | OPTI_TYPE_PRECOMPUTE_MERKLE
7442 | OPTI_TYPE_EARLY_SKIP
7443 | OPTI_TYPE_NOT_ITERATED
7444 | OPTI_TYPE_APPENDED_SALT
7445 | OPTI_TYPE_RAW_HASH;
7446 dgst_pos0 = 3;
7447 dgst_pos1 = 4;
7448 dgst_pos2 = 2;
7449 dgst_pos3 = 1;
7450 break;
7451
7452 case 120: hash_type = HASH_TYPE_SHA1;
7453 salt_type = SALT_TYPE_INTERN;
7454 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7455 opts_type = OPTS_TYPE_PT_GENERATE_BE
7456 | OPTS_TYPE_PT_ADD80
7457 | OPTS_TYPE_PT_ADDBITS15;
7458 kern_type = KERN_TYPE_SHA1_SLTPW;
7459 dgst_size = DGST_SIZE_4_5;
7460 parse_func = sha1s_parse_hash;
7461 sort_by_digest = sort_by_digest_4_5;
7462 opti_type = OPTI_TYPE_ZERO_BYTE
7463 | OPTI_TYPE_PRECOMPUTE_INIT
7464 | OPTI_TYPE_PRECOMPUTE_MERKLE
7465 | OPTI_TYPE_EARLY_SKIP
7466 | OPTI_TYPE_NOT_ITERATED
7467 | OPTI_TYPE_PREPENDED_SALT
7468 | OPTI_TYPE_RAW_HASH;
7469 dgst_pos0 = 3;
7470 dgst_pos1 = 4;
7471 dgst_pos2 = 2;
7472 dgst_pos3 = 1;
7473 break;
7474
7475 case 121: hash_type = HASH_TYPE_SHA1;
7476 salt_type = SALT_TYPE_INTERN;
7477 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7478 opts_type = OPTS_TYPE_PT_GENERATE_BE
7479 | OPTS_TYPE_PT_ADD80
7480 | OPTS_TYPE_PT_ADDBITS15
7481 | OPTS_TYPE_ST_LOWER;
7482 kern_type = KERN_TYPE_SHA1_SLTPW;
7483 dgst_size = DGST_SIZE_4_5;
7484 parse_func = smf_parse_hash;
7485 sort_by_digest = sort_by_digest_4_5;
7486 opti_type = OPTI_TYPE_ZERO_BYTE
7487 | OPTI_TYPE_PRECOMPUTE_INIT
7488 | OPTI_TYPE_PRECOMPUTE_MERKLE
7489 | OPTI_TYPE_EARLY_SKIP
7490 | OPTI_TYPE_NOT_ITERATED
7491 | OPTI_TYPE_PREPENDED_SALT
7492 | OPTI_TYPE_RAW_HASH;
7493 dgst_pos0 = 3;
7494 dgst_pos1 = 4;
7495 dgst_pos2 = 2;
7496 dgst_pos3 = 1;
7497 break;
7498
7499 case 122: hash_type = HASH_TYPE_SHA1;
7500 salt_type = SALT_TYPE_EMBEDDED;
7501 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7502 opts_type = OPTS_TYPE_PT_GENERATE_BE
7503 | OPTS_TYPE_PT_ADD80
7504 | OPTS_TYPE_PT_ADDBITS15
7505 | OPTS_TYPE_ST_HEX;
7506 kern_type = KERN_TYPE_SHA1_SLTPW;
7507 dgst_size = DGST_SIZE_4_5;
7508 parse_func = osx1_parse_hash;
7509 sort_by_digest = sort_by_digest_4_5;
7510 opti_type = OPTI_TYPE_ZERO_BYTE
7511 | OPTI_TYPE_PRECOMPUTE_INIT
7512 | OPTI_TYPE_PRECOMPUTE_MERKLE
7513 | OPTI_TYPE_EARLY_SKIP
7514 | OPTI_TYPE_NOT_ITERATED
7515 | OPTI_TYPE_PREPENDED_SALT
7516 | OPTI_TYPE_RAW_HASH;
7517 dgst_pos0 = 3;
7518 dgst_pos1 = 4;
7519 dgst_pos2 = 2;
7520 dgst_pos3 = 1;
7521 break;
7522
7523 case 124: hash_type = HASH_TYPE_SHA1;
7524 salt_type = SALT_TYPE_EMBEDDED;
7525 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7526 opts_type = OPTS_TYPE_PT_GENERATE_BE
7527 | OPTS_TYPE_PT_ADD80
7528 | OPTS_TYPE_PT_ADDBITS15;
7529 kern_type = KERN_TYPE_SHA1_SLTPW;
7530 dgst_size = DGST_SIZE_4_5;
7531 parse_func = djangosha1_parse_hash;
7532 sort_by_digest = sort_by_digest_4_5;
7533 opti_type = OPTI_TYPE_ZERO_BYTE
7534 | OPTI_TYPE_PRECOMPUTE_INIT
7535 | OPTI_TYPE_PRECOMPUTE_MERKLE
7536 | OPTI_TYPE_EARLY_SKIP
7537 | OPTI_TYPE_NOT_ITERATED
7538 | OPTI_TYPE_PREPENDED_SALT
7539 | OPTI_TYPE_RAW_HASH;
7540 dgst_pos0 = 3;
7541 dgst_pos1 = 4;
7542 dgst_pos2 = 2;
7543 dgst_pos3 = 1;
7544 break;
7545
7546 case 125: hash_type = HASH_TYPE_SHA1;
7547 salt_type = SALT_TYPE_EMBEDDED;
7548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7549 opts_type = OPTS_TYPE_PT_GENERATE_BE
7550 | OPTS_TYPE_PT_ADD80
7551 | OPTS_TYPE_PT_ADDBITS15
7552 | OPTS_TYPE_ST_HEX;
7553 kern_type = KERN_TYPE_SHA1_SLTPW;
7554 dgst_size = DGST_SIZE_4_5;
7555 parse_func = arubaos_parse_hash;
7556 sort_by_digest = sort_by_digest_4_5;
7557 opti_type = OPTI_TYPE_ZERO_BYTE
7558 | OPTI_TYPE_PRECOMPUTE_INIT
7559 | OPTI_TYPE_PRECOMPUTE_MERKLE
7560 | OPTI_TYPE_EARLY_SKIP
7561 | OPTI_TYPE_NOT_ITERATED
7562 | OPTI_TYPE_PREPENDED_SALT
7563 | OPTI_TYPE_RAW_HASH;
7564 dgst_pos0 = 3;
7565 dgst_pos1 = 4;
7566 dgst_pos2 = 2;
7567 dgst_pos3 = 1;
7568 break;
7569
7570 case 130: hash_type = HASH_TYPE_SHA1;
7571 salt_type = SALT_TYPE_INTERN;
7572 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7573 opts_type = OPTS_TYPE_PT_GENERATE_BE
7574 | OPTS_TYPE_PT_UNICODE
7575 | OPTS_TYPE_ST_ADD80
7576 | OPTS_TYPE_ST_ADDBITS15;
7577 kern_type = KERN_TYPE_SHA1_PWUSLT;
7578 dgst_size = DGST_SIZE_4_5;
7579 parse_func = sha1s_parse_hash;
7580 sort_by_digest = sort_by_digest_4_5;
7581 opti_type = OPTI_TYPE_ZERO_BYTE
7582 | OPTI_TYPE_PRECOMPUTE_INIT
7583 | OPTI_TYPE_PRECOMPUTE_MERKLE
7584 | OPTI_TYPE_EARLY_SKIP
7585 | OPTI_TYPE_NOT_ITERATED
7586 | OPTI_TYPE_APPENDED_SALT
7587 | OPTI_TYPE_RAW_HASH;
7588 dgst_pos0 = 3;
7589 dgst_pos1 = 4;
7590 dgst_pos2 = 2;
7591 dgst_pos3 = 1;
7592 break;
7593
7594 case 131: hash_type = HASH_TYPE_SHA1;
7595 salt_type = SALT_TYPE_EMBEDDED;
7596 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7597 opts_type = OPTS_TYPE_PT_GENERATE_BE
7598 | OPTS_TYPE_PT_UNICODE
7599 | OPTS_TYPE_PT_UPPER
7600 | OPTS_TYPE_ST_ADD80
7601 | OPTS_TYPE_ST_ADDBITS15
7602 | OPTS_TYPE_ST_HEX;
7603 kern_type = KERN_TYPE_SHA1_PWUSLT;
7604 dgst_size = DGST_SIZE_4_5;
7605 parse_func = mssql2000_parse_hash;
7606 sort_by_digest = sort_by_digest_4_5;
7607 opti_type = OPTI_TYPE_ZERO_BYTE
7608 | OPTI_TYPE_PRECOMPUTE_INIT
7609 | OPTI_TYPE_PRECOMPUTE_MERKLE
7610 | OPTI_TYPE_EARLY_SKIP
7611 | OPTI_TYPE_NOT_ITERATED
7612 | OPTI_TYPE_APPENDED_SALT
7613 | OPTI_TYPE_RAW_HASH;
7614 dgst_pos0 = 3;
7615 dgst_pos1 = 4;
7616 dgst_pos2 = 2;
7617 dgst_pos3 = 1;
7618 break;
7619
7620 case 132: hash_type = HASH_TYPE_SHA1;
7621 salt_type = SALT_TYPE_EMBEDDED;
7622 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7623 opts_type = OPTS_TYPE_PT_GENERATE_BE
7624 | OPTS_TYPE_PT_UNICODE
7625 | OPTS_TYPE_ST_ADD80
7626 | OPTS_TYPE_ST_ADDBITS15
7627 | OPTS_TYPE_ST_HEX;
7628 kern_type = KERN_TYPE_SHA1_PWUSLT;
7629 dgst_size = DGST_SIZE_4_5;
7630 parse_func = mssql2005_parse_hash;
7631 sort_by_digest = sort_by_digest_4_5;
7632 opti_type = OPTI_TYPE_ZERO_BYTE
7633 | OPTI_TYPE_PRECOMPUTE_INIT
7634 | OPTI_TYPE_PRECOMPUTE_MERKLE
7635 | OPTI_TYPE_EARLY_SKIP
7636 | OPTI_TYPE_NOT_ITERATED
7637 | OPTI_TYPE_APPENDED_SALT
7638 | OPTI_TYPE_RAW_HASH;
7639 dgst_pos0 = 3;
7640 dgst_pos1 = 4;
7641 dgst_pos2 = 2;
7642 dgst_pos3 = 1;
7643 break;
7644
7645 case 133: hash_type = HASH_TYPE_SHA1;
7646 salt_type = SALT_TYPE_EMBEDDED;
7647 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7648 opts_type = OPTS_TYPE_PT_GENERATE_BE
7649 | OPTS_TYPE_PT_UNICODE
7650 | OPTS_TYPE_ST_ADD80
7651 | OPTS_TYPE_ST_ADDBITS15;
7652 kern_type = KERN_TYPE_SHA1_PWUSLT;
7653 dgst_size = DGST_SIZE_4_5;
7654 parse_func = peoplesoft_parse_hash;
7655 sort_by_digest = sort_by_digest_4_5;
7656 opti_type = OPTI_TYPE_ZERO_BYTE
7657 | OPTI_TYPE_PRECOMPUTE_INIT
7658 | OPTI_TYPE_PRECOMPUTE_MERKLE
7659 | OPTI_TYPE_EARLY_SKIP
7660 | OPTI_TYPE_NOT_ITERATED
7661 | OPTI_TYPE_APPENDED_SALT
7662 | OPTI_TYPE_RAW_HASH;
7663 dgst_pos0 = 3;
7664 dgst_pos1 = 4;
7665 dgst_pos2 = 2;
7666 dgst_pos3 = 1;
7667 break;
7668
7669 case 140: hash_type = HASH_TYPE_SHA1;
7670 salt_type = SALT_TYPE_INTERN;
7671 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7672 opts_type = OPTS_TYPE_PT_GENERATE_BE
7673 | OPTS_TYPE_PT_ADD80
7674 | OPTS_TYPE_PT_ADDBITS15
7675 | OPTS_TYPE_PT_UNICODE;
7676 kern_type = KERN_TYPE_SHA1_SLTPWU;
7677 dgst_size = DGST_SIZE_4_5;
7678 parse_func = sha1s_parse_hash;
7679 sort_by_digest = sort_by_digest_4_5;
7680 opti_type = OPTI_TYPE_ZERO_BYTE
7681 | OPTI_TYPE_PRECOMPUTE_INIT
7682 | OPTI_TYPE_PRECOMPUTE_MERKLE
7683 | OPTI_TYPE_EARLY_SKIP
7684 | OPTI_TYPE_NOT_ITERATED
7685 | OPTI_TYPE_PREPENDED_SALT
7686 | OPTI_TYPE_RAW_HASH;
7687 dgst_pos0 = 3;
7688 dgst_pos1 = 4;
7689 dgst_pos2 = 2;
7690 dgst_pos3 = 1;
7691 break;
7692
7693 case 141: hash_type = HASH_TYPE_SHA1;
7694 salt_type = SALT_TYPE_EMBEDDED;
7695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7696 opts_type = OPTS_TYPE_PT_GENERATE_BE
7697 | OPTS_TYPE_PT_ADD80
7698 | OPTS_TYPE_PT_ADDBITS15
7699 | OPTS_TYPE_PT_UNICODE
7700 | OPTS_TYPE_ST_BASE64;
7701 kern_type = KERN_TYPE_SHA1_SLTPWU;
7702 dgst_size = DGST_SIZE_4_5;
7703 parse_func = episerver_parse_hash;
7704 sort_by_digest = sort_by_digest_4_5;
7705 opti_type = OPTI_TYPE_ZERO_BYTE
7706 | OPTI_TYPE_PRECOMPUTE_INIT
7707 | OPTI_TYPE_PRECOMPUTE_MERKLE
7708 | OPTI_TYPE_EARLY_SKIP
7709 | OPTI_TYPE_NOT_ITERATED
7710 | OPTI_TYPE_PREPENDED_SALT
7711 | OPTI_TYPE_RAW_HASH;
7712 dgst_pos0 = 3;
7713 dgst_pos1 = 4;
7714 dgst_pos2 = 2;
7715 dgst_pos3 = 1;
7716 break;
7717
7718 case 150: hash_type = HASH_TYPE_SHA1;
7719 salt_type = SALT_TYPE_INTERN;
7720 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7721 opts_type = OPTS_TYPE_PT_GENERATE_BE
7722 | OPTS_TYPE_ST_ADD80
7723 | OPTS_TYPE_ST_ADDBITS15;
7724 kern_type = KERN_TYPE_HMACSHA1_PW;
7725 dgst_size = DGST_SIZE_4_5;
7726 parse_func = hmacsha1_parse_hash;
7727 sort_by_digest = sort_by_digest_4_5;
7728 opti_type = OPTI_TYPE_ZERO_BYTE
7729 | OPTI_TYPE_NOT_ITERATED;
7730 dgst_pos0 = 3;
7731 dgst_pos1 = 4;
7732 dgst_pos2 = 2;
7733 dgst_pos3 = 1;
7734 break;
7735
7736 case 160: hash_type = HASH_TYPE_SHA1;
7737 salt_type = SALT_TYPE_INTERN;
7738 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7739 opts_type = OPTS_TYPE_PT_GENERATE_BE
7740 | OPTS_TYPE_PT_ADD80
7741 | OPTS_TYPE_PT_ADDBITS15;
7742 kern_type = KERN_TYPE_HMACSHA1_SLT;
7743 dgst_size = DGST_SIZE_4_5;
7744 parse_func = hmacsha1_parse_hash;
7745 sort_by_digest = sort_by_digest_4_5;
7746 opti_type = OPTI_TYPE_ZERO_BYTE
7747 | OPTI_TYPE_NOT_ITERATED;
7748 dgst_pos0 = 3;
7749 dgst_pos1 = 4;
7750 dgst_pos2 = 2;
7751 dgst_pos3 = 1;
7752 break;
7753
7754 case 190: hash_type = HASH_TYPE_SHA1;
7755 salt_type = SALT_TYPE_NONE;
7756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7757 opts_type = OPTS_TYPE_PT_GENERATE_BE
7758 | OPTS_TYPE_PT_ADD80
7759 | OPTS_TYPE_PT_ADDBITS15;
7760 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7761 dgst_size = DGST_SIZE_4_5;
7762 parse_func = sha1linkedin_parse_hash;
7763 sort_by_digest = sort_by_digest_4_5;
7764 opti_type = OPTI_TYPE_ZERO_BYTE
7765 | OPTI_TYPE_PRECOMPUTE_INIT
7766 | OPTI_TYPE_EARLY_SKIP
7767 | OPTI_TYPE_NOT_ITERATED
7768 | OPTI_TYPE_NOT_SALTED;
7769 dgst_pos0 = 0;
7770 dgst_pos1 = 4;
7771 dgst_pos2 = 3;
7772 dgst_pos3 = 2;
7773 break;
7774
7775 case 200: hash_type = HASH_TYPE_MYSQL;
7776 salt_type = SALT_TYPE_NONE;
7777 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7778 opts_type = 0;
7779 kern_type = KERN_TYPE_MYSQL;
7780 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7781 parse_func = mysql323_parse_hash;
7782 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7783 opti_type = OPTI_TYPE_ZERO_BYTE;
7784 dgst_pos0 = 0;
7785 dgst_pos1 = 1;
7786 dgst_pos2 = 2;
7787 dgst_pos3 = 3;
7788 break;
7789
7790 case 300: hash_type = HASH_TYPE_SHA1;
7791 salt_type = SALT_TYPE_NONE;
7792 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7793 opts_type = OPTS_TYPE_PT_GENERATE_BE
7794 | OPTS_TYPE_PT_ADD80
7795 | OPTS_TYPE_PT_ADDBITS15;
7796 kern_type = KERN_TYPE_MYSQL41;
7797 dgst_size = DGST_SIZE_4_5;
7798 parse_func = sha1_parse_hash;
7799 sort_by_digest = sort_by_digest_4_5;
7800 opti_type = OPTI_TYPE_ZERO_BYTE
7801 | OPTI_TYPE_PRECOMPUTE_INIT
7802 | OPTI_TYPE_PRECOMPUTE_MERKLE
7803 | OPTI_TYPE_EARLY_SKIP
7804 | OPTI_TYPE_NOT_ITERATED
7805 | OPTI_TYPE_NOT_SALTED;
7806 dgst_pos0 = 3;
7807 dgst_pos1 = 4;
7808 dgst_pos2 = 2;
7809 dgst_pos3 = 1;
7810 break;
7811
7812 case 400: hash_type = HASH_TYPE_MD5;
7813 salt_type = SALT_TYPE_EMBEDDED;
7814 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7815 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7816 kern_type = KERN_TYPE_PHPASS;
7817 dgst_size = DGST_SIZE_4_4;
7818 parse_func = phpass_parse_hash;
7819 sort_by_digest = sort_by_digest_4_4;
7820 opti_type = OPTI_TYPE_ZERO_BYTE
7821 | OPTI_TYPE_SLOW_HASH_SIMD;
7822 dgst_pos0 = 0;
7823 dgst_pos1 = 1;
7824 dgst_pos2 = 2;
7825 dgst_pos3 = 3;
7826 break;
7827
7828 case 500: hash_type = HASH_TYPE_MD5;
7829 salt_type = SALT_TYPE_EMBEDDED;
7830 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7831 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7832 kern_type = KERN_TYPE_MD5CRYPT;
7833 dgst_size = DGST_SIZE_4_4;
7834 parse_func = md5crypt_parse_hash;
7835 sort_by_digest = sort_by_digest_4_4;
7836 opti_type = OPTI_TYPE_ZERO_BYTE;
7837 dgst_pos0 = 0;
7838 dgst_pos1 = 1;
7839 dgst_pos2 = 2;
7840 dgst_pos3 = 3;
7841 break;
7842
7843 case 501: hash_type = HASH_TYPE_MD5;
7844 salt_type = SALT_TYPE_EMBEDDED;
7845 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7846 opts_type = OPTS_TYPE_PT_GENERATE_LE
7847 | OPTS_TYPE_HASH_COPY;
7848 kern_type = KERN_TYPE_MD5CRYPT;
7849 dgst_size = DGST_SIZE_4_4;
7850 parse_func = juniper_parse_hash;
7851 sort_by_digest = sort_by_digest_4_4;
7852 opti_type = OPTI_TYPE_ZERO_BYTE;
7853 dgst_pos0 = 0;
7854 dgst_pos1 = 1;
7855 dgst_pos2 = 2;
7856 dgst_pos3 = 3;
7857 break;
7858
7859 case 900: hash_type = HASH_TYPE_MD4;
7860 salt_type = SALT_TYPE_NONE;
7861 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7862 opts_type = OPTS_TYPE_PT_GENERATE_LE
7863 | OPTS_TYPE_PT_ADD80
7864 | OPTS_TYPE_PT_ADDBITS14;
7865 kern_type = KERN_TYPE_MD4;
7866 dgst_size = DGST_SIZE_4_4;
7867 parse_func = md4_parse_hash;
7868 sort_by_digest = sort_by_digest_4_4;
7869 opti_type = OPTI_TYPE_ZERO_BYTE
7870 | OPTI_TYPE_PRECOMPUTE_INIT
7871 | OPTI_TYPE_PRECOMPUTE_MERKLE
7872 | OPTI_TYPE_MEET_IN_MIDDLE
7873 | OPTI_TYPE_EARLY_SKIP
7874 | OPTI_TYPE_NOT_ITERATED
7875 | OPTI_TYPE_NOT_SALTED
7876 | OPTI_TYPE_RAW_HASH;
7877 dgst_pos0 = 0;
7878 dgst_pos1 = 3;
7879 dgst_pos2 = 2;
7880 dgst_pos3 = 1;
7881 break;
7882
7883 case 1000: hash_type = HASH_TYPE_MD4;
7884 salt_type = SALT_TYPE_NONE;
7885 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7886 opts_type = OPTS_TYPE_PT_GENERATE_LE
7887 | OPTS_TYPE_PT_ADD80
7888 | OPTS_TYPE_PT_ADDBITS14
7889 | OPTS_TYPE_PT_UNICODE;
7890 kern_type = KERN_TYPE_MD4_PWU;
7891 dgst_size = DGST_SIZE_4_4;
7892 parse_func = md4_parse_hash;
7893 sort_by_digest = sort_by_digest_4_4;
7894 opti_type = OPTI_TYPE_ZERO_BYTE
7895 | OPTI_TYPE_PRECOMPUTE_INIT
7896 | OPTI_TYPE_PRECOMPUTE_MERKLE
7897 | OPTI_TYPE_MEET_IN_MIDDLE
7898 | OPTI_TYPE_EARLY_SKIP
7899 | OPTI_TYPE_NOT_ITERATED
7900 | OPTI_TYPE_NOT_SALTED
7901 | OPTI_TYPE_RAW_HASH;
7902 dgst_pos0 = 0;
7903 dgst_pos1 = 3;
7904 dgst_pos2 = 2;
7905 dgst_pos3 = 1;
7906 break;
7907
7908 case 1100: hash_type = HASH_TYPE_MD4;
7909 salt_type = SALT_TYPE_INTERN;
7910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7911 opts_type = OPTS_TYPE_PT_GENERATE_LE
7912 | OPTS_TYPE_PT_ADD80
7913 | OPTS_TYPE_PT_ADDBITS14
7914 | OPTS_TYPE_PT_UNICODE
7915 | OPTS_TYPE_ST_ADD80
7916 | OPTS_TYPE_ST_UNICODE
7917 | OPTS_TYPE_ST_LOWER;
7918 kern_type = KERN_TYPE_MD44_PWUSLT;
7919 dgst_size = DGST_SIZE_4_4;
7920 parse_func = dcc_parse_hash;
7921 sort_by_digest = sort_by_digest_4_4;
7922 opti_type = OPTI_TYPE_ZERO_BYTE
7923 | OPTI_TYPE_PRECOMPUTE_INIT
7924 | OPTI_TYPE_PRECOMPUTE_MERKLE
7925 | OPTI_TYPE_EARLY_SKIP
7926 | OPTI_TYPE_NOT_ITERATED;
7927 dgst_pos0 = 0;
7928 dgst_pos1 = 3;
7929 dgst_pos2 = 2;
7930 dgst_pos3 = 1;
7931 break;
7932
7933 case 1400: hash_type = HASH_TYPE_SHA256;
7934 salt_type = SALT_TYPE_NONE;
7935 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7936 opts_type = OPTS_TYPE_PT_GENERATE_BE
7937 | OPTS_TYPE_PT_ADD80
7938 | OPTS_TYPE_PT_ADDBITS15;
7939 kern_type = KERN_TYPE_SHA256;
7940 dgst_size = DGST_SIZE_4_8;
7941 parse_func = sha256_parse_hash;
7942 sort_by_digest = sort_by_digest_4_8;
7943 opti_type = OPTI_TYPE_ZERO_BYTE
7944 | OPTI_TYPE_PRECOMPUTE_INIT
7945 | OPTI_TYPE_PRECOMPUTE_MERKLE
7946 | OPTI_TYPE_EARLY_SKIP
7947 | OPTI_TYPE_NOT_ITERATED
7948 | OPTI_TYPE_NOT_SALTED
7949 | OPTI_TYPE_RAW_HASH;
7950 dgst_pos0 = 3;
7951 dgst_pos1 = 7;
7952 dgst_pos2 = 2;
7953 dgst_pos3 = 6;
7954 break;
7955
7956 case 1410: hash_type = HASH_TYPE_SHA256;
7957 salt_type = SALT_TYPE_INTERN;
7958 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7959 opts_type = OPTS_TYPE_PT_GENERATE_BE
7960 | OPTS_TYPE_ST_ADD80
7961 | OPTS_TYPE_ST_ADDBITS15;
7962 kern_type = KERN_TYPE_SHA256_PWSLT;
7963 dgst_size = DGST_SIZE_4_8;
7964 parse_func = sha256s_parse_hash;
7965 sort_by_digest = sort_by_digest_4_8;
7966 opti_type = OPTI_TYPE_ZERO_BYTE
7967 | OPTI_TYPE_PRECOMPUTE_INIT
7968 | OPTI_TYPE_PRECOMPUTE_MERKLE
7969 | OPTI_TYPE_EARLY_SKIP
7970 | OPTI_TYPE_NOT_ITERATED
7971 | OPTI_TYPE_APPENDED_SALT
7972 | OPTI_TYPE_RAW_HASH;
7973 dgst_pos0 = 3;
7974 dgst_pos1 = 7;
7975 dgst_pos2 = 2;
7976 dgst_pos3 = 6;
7977 break;
7978
7979 case 1420: hash_type = HASH_TYPE_SHA256;
7980 salt_type = SALT_TYPE_INTERN;
7981 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7982 opts_type = OPTS_TYPE_PT_GENERATE_BE
7983 | OPTS_TYPE_PT_ADD80
7984 | OPTS_TYPE_PT_ADDBITS15;
7985 kern_type = KERN_TYPE_SHA256_SLTPW;
7986 dgst_size = DGST_SIZE_4_8;
7987 parse_func = sha256s_parse_hash;
7988 sort_by_digest = sort_by_digest_4_8;
7989 opti_type = OPTI_TYPE_ZERO_BYTE
7990 | OPTI_TYPE_PRECOMPUTE_INIT
7991 | OPTI_TYPE_PRECOMPUTE_MERKLE
7992 | OPTI_TYPE_EARLY_SKIP
7993 | OPTI_TYPE_NOT_ITERATED
7994 | OPTI_TYPE_PREPENDED_SALT
7995 | OPTI_TYPE_RAW_HASH;
7996 dgst_pos0 = 3;
7997 dgst_pos1 = 7;
7998 dgst_pos2 = 2;
7999 dgst_pos3 = 6;
8000 break;
8001
8002 case 1421: hash_type = HASH_TYPE_SHA256;
8003 salt_type = SALT_TYPE_EMBEDDED;
8004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8005 opts_type = OPTS_TYPE_PT_GENERATE_BE
8006 | OPTS_TYPE_PT_ADD80
8007 | OPTS_TYPE_PT_ADDBITS15;
8008 kern_type = KERN_TYPE_SHA256_SLTPW;
8009 dgst_size = DGST_SIZE_4_8;
8010 parse_func = hmailserver_parse_hash;
8011 sort_by_digest = sort_by_digest_4_8;
8012 opti_type = OPTI_TYPE_ZERO_BYTE
8013 | OPTI_TYPE_PRECOMPUTE_INIT
8014 | OPTI_TYPE_PRECOMPUTE_MERKLE
8015 | OPTI_TYPE_EARLY_SKIP
8016 | OPTI_TYPE_NOT_ITERATED
8017 | OPTI_TYPE_PREPENDED_SALT
8018 | OPTI_TYPE_RAW_HASH;
8019 dgst_pos0 = 3;
8020 dgst_pos1 = 7;
8021 dgst_pos2 = 2;
8022 dgst_pos3 = 6;
8023 break;
8024
8025 case 1430: hash_type = HASH_TYPE_SHA256;
8026 salt_type = SALT_TYPE_INTERN;
8027 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8028 opts_type = OPTS_TYPE_PT_GENERATE_BE
8029 | OPTS_TYPE_PT_UNICODE
8030 | OPTS_TYPE_ST_ADD80
8031 | OPTS_TYPE_ST_ADDBITS15;
8032 kern_type = KERN_TYPE_SHA256_PWUSLT;
8033 dgst_size = DGST_SIZE_4_8;
8034 parse_func = sha256s_parse_hash;
8035 sort_by_digest = sort_by_digest_4_8;
8036 opti_type = OPTI_TYPE_ZERO_BYTE
8037 | OPTI_TYPE_PRECOMPUTE_INIT
8038 | OPTI_TYPE_PRECOMPUTE_MERKLE
8039 | OPTI_TYPE_EARLY_SKIP
8040 | OPTI_TYPE_NOT_ITERATED
8041 | OPTI_TYPE_APPENDED_SALT
8042 | OPTI_TYPE_RAW_HASH;
8043 dgst_pos0 = 3;
8044 dgst_pos1 = 7;
8045 dgst_pos2 = 2;
8046 dgst_pos3 = 6;
8047 break;
8048
8049 case 1440: hash_type = HASH_TYPE_SHA256;
8050 salt_type = SALT_TYPE_INTERN;
8051 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8052 opts_type = OPTS_TYPE_PT_GENERATE_BE
8053 | OPTS_TYPE_PT_ADD80
8054 | OPTS_TYPE_PT_ADDBITS15
8055 | OPTS_TYPE_PT_UNICODE;
8056 kern_type = KERN_TYPE_SHA256_SLTPWU;
8057 dgst_size = DGST_SIZE_4_8;
8058 parse_func = sha256s_parse_hash;
8059 sort_by_digest = sort_by_digest_4_8;
8060 opti_type = OPTI_TYPE_ZERO_BYTE
8061 | OPTI_TYPE_PRECOMPUTE_INIT
8062 | OPTI_TYPE_PRECOMPUTE_MERKLE
8063 | OPTI_TYPE_EARLY_SKIP
8064 | OPTI_TYPE_NOT_ITERATED
8065 | OPTI_TYPE_PREPENDED_SALT
8066 | OPTI_TYPE_RAW_HASH;
8067 dgst_pos0 = 3;
8068 dgst_pos1 = 7;
8069 dgst_pos2 = 2;
8070 dgst_pos3 = 6;
8071 break;
8072
8073 case 1441: hash_type = HASH_TYPE_SHA256;
8074 salt_type = SALT_TYPE_EMBEDDED;
8075 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8076 opts_type = OPTS_TYPE_PT_GENERATE_BE
8077 | OPTS_TYPE_PT_ADD80
8078 | OPTS_TYPE_PT_ADDBITS15
8079 | OPTS_TYPE_PT_UNICODE
8080 | OPTS_TYPE_ST_BASE64;
8081 kern_type = KERN_TYPE_SHA256_SLTPWU;
8082 dgst_size = DGST_SIZE_4_8;
8083 parse_func = episerver4_parse_hash;
8084 sort_by_digest = sort_by_digest_4_8;
8085 opti_type = OPTI_TYPE_ZERO_BYTE
8086 | OPTI_TYPE_PRECOMPUTE_INIT
8087 | OPTI_TYPE_PRECOMPUTE_MERKLE
8088 | OPTI_TYPE_EARLY_SKIP
8089 | OPTI_TYPE_NOT_ITERATED
8090 | OPTI_TYPE_PREPENDED_SALT
8091 | OPTI_TYPE_RAW_HASH;
8092 dgst_pos0 = 3;
8093 dgst_pos1 = 7;
8094 dgst_pos2 = 2;
8095 dgst_pos3 = 6;
8096 break;
8097
8098 case 1450: hash_type = HASH_TYPE_SHA256;
8099 salt_type = SALT_TYPE_INTERN;
8100 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8101 opts_type = OPTS_TYPE_PT_GENERATE_BE
8102 | OPTS_TYPE_ST_ADD80;
8103 kern_type = KERN_TYPE_HMACSHA256_PW;
8104 dgst_size = DGST_SIZE_4_8;
8105 parse_func = hmacsha256_parse_hash;
8106 sort_by_digest = sort_by_digest_4_8;
8107 opti_type = OPTI_TYPE_ZERO_BYTE
8108 | OPTI_TYPE_NOT_ITERATED;
8109 dgst_pos0 = 3;
8110 dgst_pos1 = 7;
8111 dgst_pos2 = 2;
8112 dgst_pos3 = 6;
8113 break;
8114
8115 case 1460: hash_type = HASH_TYPE_SHA256;
8116 salt_type = SALT_TYPE_INTERN;
8117 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8118 opts_type = OPTS_TYPE_PT_GENERATE_BE
8119 | OPTS_TYPE_PT_ADD80
8120 | OPTS_TYPE_PT_ADDBITS15;
8121 kern_type = KERN_TYPE_HMACSHA256_SLT;
8122 dgst_size = DGST_SIZE_4_8;
8123 parse_func = hmacsha256_parse_hash;
8124 sort_by_digest = sort_by_digest_4_8;
8125 opti_type = OPTI_TYPE_ZERO_BYTE
8126 | OPTI_TYPE_NOT_ITERATED;
8127 dgst_pos0 = 3;
8128 dgst_pos1 = 7;
8129 dgst_pos2 = 2;
8130 dgst_pos3 = 6;
8131 break;
8132
8133 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8134 salt_type = SALT_TYPE_EMBEDDED;
8135 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8136 opts_type = OPTS_TYPE_PT_GENERATE_LE
8137 | OPTS_TYPE_PT_BITSLICE;
8138 kern_type = KERN_TYPE_DESCRYPT;
8139 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8140 parse_func = descrypt_parse_hash;
8141 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8142 opti_type = OPTI_TYPE_ZERO_BYTE
8143 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8144 dgst_pos0 = 0;
8145 dgst_pos1 = 1;
8146 dgst_pos2 = 2;
8147 dgst_pos3 = 3;
8148 break;
8149
8150 case 1600: hash_type = HASH_TYPE_MD5;
8151 salt_type = SALT_TYPE_EMBEDDED;
8152 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8153 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8154 kern_type = KERN_TYPE_APR1CRYPT;
8155 dgst_size = DGST_SIZE_4_4;
8156 parse_func = md5apr1_parse_hash;
8157 sort_by_digest = sort_by_digest_4_4;
8158 opti_type = OPTI_TYPE_ZERO_BYTE;
8159 dgst_pos0 = 0;
8160 dgst_pos1 = 1;
8161 dgst_pos2 = 2;
8162 dgst_pos3 = 3;
8163 break;
8164
8165 case 1700: hash_type = HASH_TYPE_SHA512;
8166 salt_type = SALT_TYPE_NONE;
8167 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8168 opts_type = OPTS_TYPE_PT_GENERATE_BE
8169 | OPTS_TYPE_PT_ADD80
8170 | OPTS_TYPE_PT_ADDBITS15;
8171 kern_type = KERN_TYPE_SHA512;
8172 dgst_size = DGST_SIZE_8_8;
8173 parse_func = sha512_parse_hash;
8174 sort_by_digest = sort_by_digest_8_8;
8175 opti_type = OPTI_TYPE_ZERO_BYTE
8176 | OPTI_TYPE_PRECOMPUTE_INIT
8177 | OPTI_TYPE_PRECOMPUTE_MERKLE
8178 | OPTI_TYPE_EARLY_SKIP
8179 | OPTI_TYPE_NOT_ITERATED
8180 | OPTI_TYPE_NOT_SALTED
8181 | OPTI_TYPE_USES_BITS_64
8182 | OPTI_TYPE_RAW_HASH;
8183 dgst_pos0 = 14;
8184 dgst_pos1 = 15;
8185 dgst_pos2 = 6;
8186 dgst_pos3 = 7;
8187 break;
8188
8189 case 1710: hash_type = HASH_TYPE_SHA512;
8190 salt_type = SALT_TYPE_INTERN;
8191 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8192 opts_type = OPTS_TYPE_PT_GENERATE_BE
8193 | OPTS_TYPE_ST_ADD80
8194 | OPTS_TYPE_ST_ADDBITS15;
8195 kern_type = KERN_TYPE_SHA512_PWSLT;
8196 dgst_size = DGST_SIZE_8_8;
8197 parse_func = sha512s_parse_hash;
8198 sort_by_digest = sort_by_digest_8_8;
8199 opti_type = OPTI_TYPE_ZERO_BYTE
8200 | OPTI_TYPE_PRECOMPUTE_INIT
8201 | OPTI_TYPE_PRECOMPUTE_MERKLE
8202 | OPTI_TYPE_EARLY_SKIP
8203 | OPTI_TYPE_NOT_ITERATED
8204 | OPTI_TYPE_APPENDED_SALT
8205 | OPTI_TYPE_USES_BITS_64
8206 | OPTI_TYPE_RAW_HASH;
8207 dgst_pos0 = 14;
8208 dgst_pos1 = 15;
8209 dgst_pos2 = 6;
8210 dgst_pos3 = 7;
8211 break;
8212
8213 case 1711: hash_type = HASH_TYPE_SHA512;
8214 salt_type = SALT_TYPE_EMBEDDED;
8215 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8216 opts_type = OPTS_TYPE_PT_GENERATE_BE
8217 | OPTS_TYPE_ST_ADD80
8218 | OPTS_TYPE_ST_ADDBITS15;
8219 kern_type = KERN_TYPE_SHA512_PWSLT;
8220 dgst_size = DGST_SIZE_8_8;
8221 parse_func = sha512b64s_parse_hash;
8222 sort_by_digest = sort_by_digest_8_8;
8223 opti_type = OPTI_TYPE_ZERO_BYTE
8224 | OPTI_TYPE_PRECOMPUTE_INIT
8225 | OPTI_TYPE_PRECOMPUTE_MERKLE
8226 | OPTI_TYPE_EARLY_SKIP
8227 | OPTI_TYPE_NOT_ITERATED
8228 | OPTI_TYPE_APPENDED_SALT
8229 | OPTI_TYPE_USES_BITS_64
8230 | OPTI_TYPE_RAW_HASH;
8231 dgst_pos0 = 14;
8232 dgst_pos1 = 15;
8233 dgst_pos2 = 6;
8234 dgst_pos3 = 7;
8235 break;
8236
8237 case 1720: hash_type = HASH_TYPE_SHA512;
8238 salt_type = SALT_TYPE_INTERN;
8239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8240 opts_type = OPTS_TYPE_PT_GENERATE_BE
8241 | OPTS_TYPE_PT_ADD80
8242 | OPTS_TYPE_PT_ADDBITS15;
8243 kern_type = KERN_TYPE_SHA512_SLTPW;
8244 dgst_size = DGST_SIZE_8_8;
8245 parse_func = sha512s_parse_hash;
8246 sort_by_digest = sort_by_digest_8_8;
8247 opti_type = OPTI_TYPE_ZERO_BYTE
8248 | OPTI_TYPE_PRECOMPUTE_INIT
8249 | OPTI_TYPE_PRECOMPUTE_MERKLE
8250 | OPTI_TYPE_EARLY_SKIP
8251 | OPTI_TYPE_NOT_ITERATED
8252 | OPTI_TYPE_PREPENDED_SALT
8253 | OPTI_TYPE_USES_BITS_64
8254 | OPTI_TYPE_RAW_HASH;
8255 dgst_pos0 = 14;
8256 dgst_pos1 = 15;
8257 dgst_pos2 = 6;
8258 dgst_pos3 = 7;
8259 break;
8260
8261 case 1722: hash_type = HASH_TYPE_SHA512;
8262 salt_type = SALT_TYPE_EMBEDDED;
8263 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8264 opts_type = OPTS_TYPE_PT_GENERATE_BE
8265 | OPTS_TYPE_PT_ADD80
8266 | OPTS_TYPE_PT_ADDBITS15
8267 | OPTS_TYPE_ST_HEX;
8268 kern_type = KERN_TYPE_SHA512_SLTPW;
8269 dgst_size = DGST_SIZE_8_8;
8270 parse_func = osx512_parse_hash;
8271 sort_by_digest = sort_by_digest_8_8;
8272 opti_type = OPTI_TYPE_ZERO_BYTE
8273 | OPTI_TYPE_PRECOMPUTE_INIT
8274 | OPTI_TYPE_PRECOMPUTE_MERKLE
8275 | OPTI_TYPE_EARLY_SKIP
8276 | OPTI_TYPE_NOT_ITERATED
8277 | OPTI_TYPE_PREPENDED_SALT
8278 | OPTI_TYPE_USES_BITS_64
8279 | OPTI_TYPE_RAW_HASH;
8280 dgst_pos0 = 14;
8281 dgst_pos1 = 15;
8282 dgst_pos2 = 6;
8283 dgst_pos3 = 7;
8284 break;
8285
8286 case 1730: hash_type = HASH_TYPE_SHA512;
8287 salt_type = SALT_TYPE_INTERN;
8288 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8289 opts_type = OPTS_TYPE_PT_GENERATE_BE
8290 | OPTS_TYPE_PT_UNICODE
8291 | OPTS_TYPE_ST_ADD80
8292 | OPTS_TYPE_ST_ADDBITS15;
8293 kern_type = KERN_TYPE_SHA512_PWSLTU;
8294 dgst_size = DGST_SIZE_8_8;
8295 parse_func = sha512s_parse_hash;
8296 sort_by_digest = sort_by_digest_8_8;
8297 opti_type = OPTI_TYPE_ZERO_BYTE
8298 | OPTI_TYPE_PRECOMPUTE_INIT
8299 | OPTI_TYPE_PRECOMPUTE_MERKLE
8300 | OPTI_TYPE_EARLY_SKIP
8301 | OPTI_TYPE_NOT_ITERATED
8302 | OPTI_TYPE_APPENDED_SALT
8303 | OPTI_TYPE_USES_BITS_64
8304 | OPTI_TYPE_RAW_HASH;
8305 dgst_pos0 = 14;
8306 dgst_pos1 = 15;
8307 dgst_pos2 = 6;
8308 dgst_pos3 = 7;
8309 break;
8310
8311 case 1731: hash_type = HASH_TYPE_SHA512;
8312 salt_type = SALT_TYPE_EMBEDDED;
8313 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8314 opts_type = OPTS_TYPE_PT_GENERATE_BE
8315 | OPTS_TYPE_PT_UNICODE
8316 | OPTS_TYPE_ST_ADD80
8317 | OPTS_TYPE_ST_ADDBITS15
8318 | OPTS_TYPE_ST_HEX;
8319 kern_type = KERN_TYPE_SHA512_PWSLTU;
8320 dgst_size = DGST_SIZE_8_8;
8321 parse_func = mssql2012_parse_hash;
8322 sort_by_digest = sort_by_digest_8_8;
8323 opti_type = OPTI_TYPE_ZERO_BYTE
8324 | OPTI_TYPE_PRECOMPUTE_INIT
8325 | OPTI_TYPE_PRECOMPUTE_MERKLE
8326 | OPTI_TYPE_EARLY_SKIP
8327 | OPTI_TYPE_NOT_ITERATED
8328 | OPTI_TYPE_APPENDED_SALT
8329 | OPTI_TYPE_USES_BITS_64
8330 | OPTI_TYPE_RAW_HASH;
8331 dgst_pos0 = 14;
8332 dgst_pos1 = 15;
8333 dgst_pos2 = 6;
8334 dgst_pos3 = 7;
8335 break;
8336
8337 case 1740: hash_type = HASH_TYPE_SHA512;
8338 salt_type = SALT_TYPE_INTERN;
8339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8340 opts_type = OPTS_TYPE_PT_GENERATE_BE
8341 | OPTS_TYPE_PT_ADD80
8342 | OPTS_TYPE_PT_ADDBITS15
8343 | OPTS_TYPE_PT_UNICODE;
8344 kern_type = KERN_TYPE_SHA512_SLTPWU;
8345 dgst_size = DGST_SIZE_8_8;
8346 parse_func = sha512s_parse_hash;
8347 sort_by_digest = sort_by_digest_8_8;
8348 opti_type = OPTI_TYPE_ZERO_BYTE
8349 | OPTI_TYPE_PRECOMPUTE_INIT
8350 | OPTI_TYPE_PRECOMPUTE_MERKLE
8351 | OPTI_TYPE_EARLY_SKIP
8352 | OPTI_TYPE_NOT_ITERATED
8353 | OPTI_TYPE_PREPENDED_SALT
8354 | OPTI_TYPE_USES_BITS_64
8355 | OPTI_TYPE_RAW_HASH;
8356 dgst_pos0 = 14;
8357 dgst_pos1 = 15;
8358 dgst_pos2 = 6;
8359 dgst_pos3 = 7;
8360 break;
8361
8362 case 1750: hash_type = HASH_TYPE_SHA512;
8363 salt_type = SALT_TYPE_INTERN;
8364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8365 opts_type = OPTS_TYPE_PT_GENERATE_BE
8366 | OPTS_TYPE_ST_ADD80;
8367 kern_type = KERN_TYPE_HMACSHA512_PW;
8368 dgst_size = DGST_SIZE_8_8;
8369 parse_func = hmacsha512_parse_hash;
8370 sort_by_digest = sort_by_digest_8_8;
8371 opti_type = OPTI_TYPE_ZERO_BYTE
8372 | OPTI_TYPE_USES_BITS_64
8373 | OPTI_TYPE_NOT_ITERATED;
8374 dgst_pos0 = 14;
8375 dgst_pos1 = 15;
8376 dgst_pos2 = 6;
8377 dgst_pos3 = 7;
8378 break;
8379
8380 case 1760: hash_type = HASH_TYPE_SHA512;
8381 salt_type = SALT_TYPE_INTERN;
8382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8383 opts_type = OPTS_TYPE_PT_GENERATE_BE
8384 | OPTS_TYPE_PT_ADD80
8385 | OPTS_TYPE_PT_ADDBITS15;
8386 kern_type = KERN_TYPE_HMACSHA512_SLT;
8387 dgst_size = DGST_SIZE_8_8;
8388 parse_func = hmacsha512_parse_hash;
8389 sort_by_digest = sort_by_digest_8_8;
8390 opti_type = OPTI_TYPE_ZERO_BYTE
8391 | OPTI_TYPE_USES_BITS_64
8392 | OPTI_TYPE_NOT_ITERATED;
8393 dgst_pos0 = 14;
8394 dgst_pos1 = 15;
8395 dgst_pos2 = 6;
8396 dgst_pos3 = 7;
8397 break;
8398
8399 case 1800: hash_type = HASH_TYPE_SHA512;
8400 salt_type = SALT_TYPE_EMBEDDED;
8401 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8402 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8403 kern_type = KERN_TYPE_SHA512CRYPT;
8404 dgst_size = DGST_SIZE_8_8;
8405 parse_func = sha512crypt_parse_hash;
8406 sort_by_digest = sort_by_digest_8_8;
8407 opti_type = OPTI_TYPE_ZERO_BYTE
8408 | OPTI_TYPE_USES_BITS_64;
8409 dgst_pos0 = 0;
8410 dgst_pos1 = 1;
8411 dgst_pos2 = 2;
8412 dgst_pos3 = 3;
8413 break;
8414
8415 case 2100: hash_type = HASH_TYPE_DCC2;
8416 salt_type = SALT_TYPE_EMBEDDED;
8417 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8418 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8419 | OPTS_TYPE_ST_LOWER
8420 | OPTS_TYPE_ST_UNICODE;
8421 kern_type = KERN_TYPE_DCC2;
8422 dgst_size = DGST_SIZE_4_4;
8423 parse_func = dcc2_parse_hash;
8424 sort_by_digest = sort_by_digest_4_4;
8425 opti_type = OPTI_TYPE_ZERO_BYTE
8426 | OPTI_TYPE_SLOW_HASH_SIMD;
8427 dgst_pos0 = 0;
8428 dgst_pos1 = 1;
8429 dgst_pos2 = 2;
8430 dgst_pos3 = 3;
8431 break;
8432
8433 case 2400: hash_type = HASH_TYPE_MD5;
8434 salt_type = SALT_TYPE_NONE;
8435 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8436 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8437 kern_type = KERN_TYPE_MD5PIX;
8438 dgst_size = DGST_SIZE_4_4;
8439 parse_func = md5pix_parse_hash;
8440 sort_by_digest = sort_by_digest_4_4;
8441 opti_type = OPTI_TYPE_ZERO_BYTE
8442 | OPTI_TYPE_PRECOMPUTE_INIT
8443 | OPTI_TYPE_PRECOMPUTE_MERKLE
8444 | OPTI_TYPE_EARLY_SKIP
8445 | OPTI_TYPE_NOT_ITERATED
8446 | OPTI_TYPE_NOT_SALTED;
8447 dgst_pos0 = 0;
8448 dgst_pos1 = 3;
8449 dgst_pos2 = 2;
8450 dgst_pos3 = 1;
8451 break;
8452
8453 case 2410: hash_type = HASH_TYPE_MD5;
8454 salt_type = SALT_TYPE_INTERN;
8455 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8456 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8457 kern_type = KERN_TYPE_MD5ASA;
8458 dgst_size = DGST_SIZE_4_4;
8459 parse_func = md5asa_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 dgst_pos0 = 0;
8467 dgst_pos1 = 3;
8468 dgst_pos2 = 2;
8469 dgst_pos3 = 1;
8470 break;
8471
8472 case 2500: hash_type = HASH_TYPE_WPA;
8473 salt_type = SALT_TYPE_EMBEDDED;
8474 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8475 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8476 kern_type = KERN_TYPE_WPA;
8477 dgst_size = DGST_SIZE_4_4;
8478 parse_func = wpa_parse_hash;
8479 sort_by_digest = sort_by_digest_4_4;
8480 opti_type = OPTI_TYPE_ZERO_BYTE
8481 | OPTI_TYPE_SLOW_HASH_SIMD;
8482 dgst_pos0 = 0;
8483 dgst_pos1 = 1;
8484 dgst_pos2 = 2;
8485 dgst_pos3 = 3;
8486 break;
8487
8488 case 2600: hash_type = HASH_TYPE_MD5;
8489 salt_type = SALT_TYPE_VIRTUAL;
8490 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8491 opts_type = OPTS_TYPE_PT_GENERATE_LE
8492 | OPTS_TYPE_PT_ADD80
8493 | OPTS_TYPE_PT_ADDBITS14
8494 | OPTS_TYPE_ST_ADD80;
8495 kern_type = KERN_TYPE_MD55_PWSLT1;
8496 dgst_size = DGST_SIZE_4_4;
8497 parse_func = md5md5_parse_hash;
8498 sort_by_digest = sort_by_digest_4_4;
8499 opti_type = OPTI_TYPE_ZERO_BYTE
8500 | OPTI_TYPE_PRECOMPUTE_INIT
8501 | OPTI_TYPE_PRECOMPUTE_MERKLE
8502 | OPTI_TYPE_EARLY_SKIP;
8503 dgst_pos0 = 0;
8504 dgst_pos1 = 3;
8505 dgst_pos2 = 2;
8506 dgst_pos3 = 1;
8507 break;
8508
8509 case 2611: hash_type = HASH_TYPE_MD5;
8510 salt_type = SALT_TYPE_INTERN;
8511 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8512 opts_type = OPTS_TYPE_PT_GENERATE_LE
8513 | OPTS_TYPE_PT_ADD80
8514 | OPTS_TYPE_PT_ADDBITS14
8515 | OPTS_TYPE_ST_ADD80;
8516 kern_type = KERN_TYPE_MD55_PWSLT1;
8517 dgst_size = DGST_SIZE_4_4;
8518 parse_func = vb3_parse_hash;
8519 sort_by_digest = sort_by_digest_4_4;
8520 opti_type = OPTI_TYPE_ZERO_BYTE
8521 | OPTI_TYPE_PRECOMPUTE_INIT
8522 | OPTI_TYPE_PRECOMPUTE_MERKLE
8523 | OPTI_TYPE_EARLY_SKIP;
8524 dgst_pos0 = 0;
8525 dgst_pos1 = 3;
8526 dgst_pos2 = 2;
8527 dgst_pos3 = 1;
8528 break;
8529
8530 case 2612: hash_type = HASH_TYPE_MD5;
8531 salt_type = SALT_TYPE_EMBEDDED;
8532 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8533 opts_type = OPTS_TYPE_PT_GENERATE_LE
8534 | OPTS_TYPE_PT_ADD80
8535 | OPTS_TYPE_PT_ADDBITS14
8536 | OPTS_TYPE_ST_ADD80
8537 | OPTS_TYPE_ST_HEX;
8538 kern_type = KERN_TYPE_MD55_PWSLT1;
8539 dgst_size = DGST_SIZE_4_4;
8540 parse_func = phps_parse_hash;
8541 sort_by_digest = sort_by_digest_4_4;
8542 opti_type = OPTI_TYPE_ZERO_BYTE
8543 | OPTI_TYPE_PRECOMPUTE_INIT
8544 | OPTI_TYPE_PRECOMPUTE_MERKLE
8545 | OPTI_TYPE_EARLY_SKIP;
8546 dgst_pos0 = 0;
8547 dgst_pos1 = 3;
8548 dgst_pos2 = 2;
8549 dgst_pos3 = 1;
8550 break;
8551
8552 case 2711: hash_type = HASH_TYPE_MD5;
8553 salt_type = SALT_TYPE_INTERN;
8554 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8555 opts_type = OPTS_TYPE_PT_GENERATE_LE
8556 | OPTS_TYPE_PT_ADD80
8557 | OPTS_TYPE_PT_ADDBITS14
8558 | OPTS_TYPE_ST_ADD80;
8559 kern_type = KERN_TYPE_MD55_PWSLT2;
8560 dgst_size = DGST_SIZE_4_4;
8561 parse_func = vb30_parse_hash;
8562 sort_by_digest = sort_by_digest_4_4;
8563 opti_type = OPTI_TYPE_ZERO_BYTE
8564 | OPTI_TYPE_PRECOMPUTE_INIT
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 2811: 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 kern_type = KERN_TYPE_MD55_SLTPW;
8579 dgst_size = DGST_SIZE_4_4;
8580 parse_func = ipb2_parse_hash;
8581 sort_by_digest = sort_by_digest_4_4;
8582 opti_type = OPTI_TYPE_ZERO_BYTE
8583 | OPTI_TYPE_PRECOMPUTE_INIT
8584 | OPTI_TYPE_EARLY_SKIP;
8585 dgst_pos0 = 0;
8586 dgst_pos1 = 3;
8587 dgst_pos2 = 2;
8588 dgst_pos3 = 1;
8589 break;
8590
8591 case 3000: hash_type = HASH_TYPE_LM;
8592 salt_type = SALT_TYPE_NONE;
8593 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8594 opts_type = OPTS_TYPE_PT_GENERATE_LE
8595 | OPTS_TYPE_PT_UPPER
8596 | OPTS_TYPE_PT_BITSLICE;
8597 kern_type = KERN_TYPE_LM;
8598 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8599 parse_func = lm_parse_hash;
8600 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8601 opti_type = OPTI_TYPE_ZERO_BYTE
8602 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8603 dgst_pos0 = 0;
8604 dgst_pos1 = 1;
8605 dgst_pos2 = 2;
8606 dgst_pos3 = 3;
8607 break;
8608
8609 case 3100: hash_type = HASH_TYPE_ORACLEH;
8610 salt_type = SALT_TYPE_INTERN;
8611 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8612 opts_type = OPTS_TYPE_PT_GENERATE_LE
8613 | OPTS_TYPE_PT_UPPER
8614 | OPTS_TYPE_ST_UPPER;
8615 kern_type = KERN_TYPE_ORACLEH;
8616 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8617 parse_func = oracleh_parse_hash;
8618 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8619 opti_type = OPTI_TYPE_ZERO_BYTE;
8620 dgst_pos0 = 0;
8621 dgst_pos1 = 1;
8622 dgst_pos2 = 2;
8623 dgst_pos3 = 3;
8624 break;
8625
8626 case 3200: hash_type = HASH_TYPE_BCRYPT;
8627 salt_type = SALT_TYPE_EMBEDDED;
8628 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8629 opts_type = OPTS_TYPE_PT_GENERATE_LE
8630 | OPTS_TYPE_ST_GENERATE_LE;
8631 kern_type = KERN_TYPE_BCRYPT;
8632 dgst_size = DGST_SIZE_4_6;
8633 parse_func = bcrypt_parse_hash;
8634 sort_by_digest = sort_by_digest_4_6;
8635 opti_type = OPTI_TYPE_ZERO_BYTE;
8636 dgst_pos0 = 0;
8637 dgst_pos1 = 1;
8638 dgst_pos2 = 2;
8639 dgst_pos3 = 3;
8640 break;
8641
8642 case 3710: hash_type = HASH_TYPE_MD5;
8643 salt_type = SALT_TYPE_INTERN;
8644 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8645 opts_type = OPTS_TYPE_PT_GENERATE_LE
8646 | OPTS_TYPE_PT_ADD80
8647 | OPTS_TYPE_PT_ADDBITS14;
8648 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8649 dgst_size = DGST_SIZE_4_4;
8650 parse_func = md5s_parse_hash;
8651 sort_by_digest = sort_by_digest_4_4;
8652 opti_type = OPTI_TYPE_ZERO_BYTE
8653 | OPTI_TYPE_PRECOMPUTE_INIT
8654 | OPTI_TYPE_PRECOMPUTE_MERKLE
8655 | OPTI_TYPE_EARLY_SKIP;
8656 dgst_pos0 = 0;
8657 dgst_pos1 = 3;
8658 dgst_pos2 = 2;
8659 dgst_pos3 = 1;
8660 break;
8661
8662 case 3711: hash_type = HASH_TYPE_MD5;
8663 salt_type = SALT_TYPE_EMBEDDED;
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 = mediawiki_b_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 3800: hash_type = HASH_TYPE_MD5;
8683 salt_type = SALT_TYPE_INTERN;
8684 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8685 opts_type = OPTS_TYPE_PT_GENERATE_LE
8686 | OPTS_TYPE_ST_ADDBITS14;
8687 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8688 dgst_size = DGST_SIZE_4_4;
8689 parse_func = md5s_parse_hash;
8690 sort_by_digest = sort_by_digest_4_4;
8691 opti_type = OPTI_TYPE_ZERO_BYTE
8692 | OPTI_TYPE_PRECOMPUTE_INIT
8693 | OPTI_TYPE_PRECOMPUTE_MERKLE
8694 | OPTI_TYPE_EARLY_SKIP
8695 | OPTI_TYPE_NOT_ITERATED
8696 | OPTI_TYPE_RAW_HASH;
8697 dgst_pos0 = 0;
8698 dgst_pos1 = 3;
8699 dgst_pos2 = 2;
8700 dgst_pos3 = 1;
8701 break;
8702
8703 case 4300: hash_type = HASH_TYPE_MD5;
8704 salt_type = SALT_TYPE_VIRTUAL;
8705 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8706 opts_type = OPTS_TYPE_PT_GENERATE_LE
8707 | OPTS_TYPE_PT_ADD80
8708 | OPTS_TYPE_PT_ADDBITS14
8709 | OPTS_TYPE_ST_ADD80;
8710 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8711 dgst_size = DGST_SIZE_4_4;
8712 parse_func = md5md5_parse_hash;
8713 sort_by_digest = sort_by_digest_4_4;
8714 opti_type = OPTI_TYPE_ZERO_BYTE
8715 | OPTI_TYPE_PRECOMPUTE_INIT
8716 | OPTI_TYPE_PRECOMPUTE_MERKLE
8717 | OPTI_TYPE_EARLY_SKIP;
8718 dgst_pos0 = 0;
8719 dgst_pos1 = 3;
8720 dgst_pos2 = 2;
8721 dgst_pos3 = 1;
8722 break;
8723
8724
8725 case 4400: hash_type = HASH_TYPE_MD5;
8726 salt_type = SALT_TYPE_NONE;
8727 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8728 opts_type = OPTS_TYPE_PT_GENERATE_BE
8729 | OPTS_TYPE_PT_ADD80
8730 | OPTS_TYPE_PT_ADDBITS15;
8731 kern_type = KERN_TYPE_MD5_SHA1;
8732 dgst_size = DGST_SIZE_4_4;
8733 parse_func = md5_parse_hash;
8734 sort_by_digest = sort_by_digest_4_4;
8735 opti_type = OPTI_TYPE_ZERO_BYTE
8736 | OPTI_TYPE_PRECOMPUTE_INIT
8737 | OPTI_TYPE_PRECOMPUTE_MERKLE
8738 | OPTI_TYPE_EARLY_SKIP
8739 | OPTI_TYPE_NOT_ITERATED
8740 | OPTI_TYPE_NOT_SALTED
8741 | OPTI_TYPE_RAW_HASH;
8742 dgst_pos0 = 0;
8743 dgst_pos1 = 3;
8744 dgst_pos2 = 2;
8745 dgst_pos3 = 1;
8746 break;
8747
8748 case 4500: hash_type = HASH_TYPE_SHA1;
8749 salt_type = SALT_TYPE_NONE;
8750 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8751 opts_type = OPTS_TYPE_PT_GENERATE_BE
8752 | OPTS_TYPE_PT_ADD80
8753 | OPTS_TYPE_PT_ADDBITS15;
8754 kern_type = KERN_TYPE_SHA11;
8755 dgst_size = DGST_SIZE_4_5;
8756 parse_func = sha1_parse_hash;
8757 sort_by_digest = sort_by_digest_4_5;
8758 opti_type = OPTI_TYPE_ZERO_BYTE
8759 | OPTI_TYPE_PRECOMPUTE_INIT
8760 | OPTI_TYPE_PRECOMPUTE_MERKLE
8761 | OPTI_TYPE_EARLY_SKIP
8762 | OPTI_TYPE_NOT_SALTED;
8763 dgst_pos0 = 3;
8764 dgst_pos1 = 4;
8765 dgst_pos2 = 2;
8766 dgst_pos3 = 1;
8767 break;
8768
8769 case 4700: hash_type = HASH_TYPE_SHA1;
8770 salt_type = SALT_TYPE_NONE;
8771 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8772 opts_type = OPTS_TYPE_PT_GENERATE_LE
8773 | OPTS_TYPE_PT_ADD80
8774 | OPTS_TYPE_PT_ADDBITS14;
8775 kern_type = KERN_TYPE_SHA1_MD5;
8776 dgst_size = DGST_SIZE_4_5;
8777 parse_func = sha1_parse_hash;
8778 sort_by_digest = sort_by_digest_4_5;
8779 opti_type = OPTI_TYPE_ZERO_BYTE
8780 | OPTI_TYPE_PRECOMPUTE_INIT
8781 | OPTI_TYPE_PRECOMPUTE_MERKLE
8782 | OPTI_TYPE_EARLY_SKIP
8783 | OPTI_TYPE_NOT_ITERATED
8784 | OPTI_TYPE_NOT_SALTED
8785 | OPTI_TYPE_RAW_HASH;
8786 dgst_pos0 = 3;
8787 dgst_pos1 = 4;
8788 dgst_pos2 = 2;
8789 dgst_pos3 = 1;
8790 break;
8791
8792 case 4800: hash_type = HASH_TYPE_MD5;
8793 salt_type = SALT_TYPE_EMBEDDED;
8794 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8795 opts_type = OPTS_TYPE_PT_GENERATE_LE
8796 | OPTS_TYPE_PT_ADDBITS14;
8797 kern_type = KERN_TYPE_MD5_CHAP;
8798 dgst_size = DGST_SIZE_4_4;
8799 parse_func = chap_parse_hash;
8800 sort_by_digest = sort_by_digest_4_4;
8801 opti_type = OPTI_TYPE_ZERO_BYTE
8802 | OPTI_TYPE_PRECOMPUTE_INIT
8803 | OPTI_TYPE_PRECOMPUTE_MERKLE
8804 | OPTI_TYPE_MEET_IN_MIDDLE
8805 | OPTI_TYPE_EARLY_SKIP
8806 | OPTI_TYPE_NOT_ITERATED
8807 | OPTI_TYPE_RAW_HASH;
8808 dgst_pos0 = 0;
8809 dgst_pos1 = 3;
8810 dgst_pos2 = 2;
8811 dgst_pos3 = 1;
8812 break;
8813
8814 case 4900: hash_type = HASH_TYPE_SHA1;
8815 salt_type = SALT_TYPE_INTERN;
8816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8817 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8818 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8819 dgst_size = DGST_SIZE_4_5;
8820 parse_func = sha1s_parse_hash;
8821 sort_by_digest = sort_by_digest_4_5;
8822 opti_type = OPTI_TYPE_ZERO_BYTE
8823 | OPTI_TYPE_PRECOMPUTE_INIT
8824 | OPTI_TYPE_PRECOMPUTE_MERKLE
8825 | OPTI_TYPE_EARLY_SKIP;
8826 dgst_pos0 = 3;
8827 dgst_pos1 = 4;
8828 dgst_pos2 = 2;
8829 dgst_pos3 = 1;
8830 break;
8831
8832 case 5000: hash_type = HASH_TYPE_KECCAK;
8833 salt_type = SALT_TYPE_EMBEDDED;
8834 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8835 opts_type = OPTS_TYPE_PT_GENERATE_LE
8836 | OPTS_TYPE_PT_ADD01;
8837 kern_type = KERN_TYPE_KECCAK;
8838 dgst_size = DGST_SIZE_8_25;
8839 parse_func = keccak_parse_hash;
8840 sort_by_digest = sort_by_digest_8_25;
8841 opti_type = OPTI_TYPE_ZERO_BYTE
8842 | OPTI_TYPE_USES_BITS_64
8843 | OPTI_TYPE_RAW_HASH;
8844 dgst_pos0 = 2;
8845 dgst_pos1 = 3;
8846 dgst_pos2 = 4;
8847 dgst_pos3 = 5;
8848 break;
8849
8850 case 5100: hash_type = HASH_TYPE_MD5H;
8851 salt_type = SALT_TYPE_NONE;
8852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8853 opts_type = OPTS_TYPE_PT_GENERATE_LE
8854 | OPTS_TYPE_PT_ADD80
8855 | OPTS_TYPE_PT_ADDBITS14;
8856 kern_type = KERN_TYPE_MD5H;
8857 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8858 parse_func = md5half_parse_hash;
8859 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8860 opti_type = OPTI_TYPE_ZERO_BYTE
8861 | OPTI_TYPE_RAW_HASH;
8862 dgst_pos0 = 0;
8863 dgst_pos1 = 1;
8864 dgst_pos2 = 2;
8865 dgst_pos3 = 3;
8866 break;
8867
8868 case 5200: hash_type = HASH_TYPE_SHA256;
8869 salt_type = SALT_TYPE_EMBEDDED;
8870 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8871 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8872 kern_type = KERN_TYPE_PSAFE3;
8873 dgst_size = DGST_SIZE_4_8;
8874 parse_func = psafe3_parse_hash;
8875 sort_by_digest = sort_by_digest_4_8;
8876 opti_type = OPTI_TYPE_ZERO_BYTE;
8877 dgst_pos0 = 0;
8878 dgst_pos1 = 1;
8879 dgst_pos2 = 2;
8880 dgst_pos3 = 3;
8881 break;
8882
8883 case 5300: hash_type = HASH_TYPE_MD5;
8884 salt_type = SALT_TYPE_EMBEDDED;
8885 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8886 opts_type = OPTS_TYPE_PT_GENERATE_LE
8887 | OPTS_TYPE_ST_ADD80;
8888 kern_type = KERN_TYPE_IKEPSK_MD5;
8889 dgst_size = DGST_SIZE_4_4;
8890 parse_func = ikepsk_md5_parse_hash;
8891 sort_by_digest = sort_by_digest_4_4;
8892 opti_type = OPTI_TYPE_ZERO_BYTE;
8893 dgst_pos0 = 0;
8894 dgst_pos1 = 3;
8895 dgst_pos2 = 2;
8896 dgst_pos3 = 1;
8897 break;
8898
8899 case 5400: hash_type = HASH_TYPE_SHA1;
8900 salt_type = SALT_TYPE_EMBEDDED;
8901 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8902 opts_type = OPTS_TYPE_PT_GENERATE_BE
8903 | OPTS_TYPE_ST_ADD80;
8904 kern_type = KERN_TYPE_IKEPSK_SHA1;
8905 dgst_size = DGST_SIZE_4_5;
8906 parse_func = ikepsk_sha1_parse_hash;
8907 sort_by_digest = sort_by_digest_4_5;
8908 opti_type = OPTI_TYPE_ZERO_BYTE;
8909 dgst_pos0 = 3;
8910 dgst_pos1 = 4;
8911 dgst_pos2 = 2;
8912 dgst_pos3 = 1;
8913 break;
8914
8915 case 5500: hash_type = HASH_TYPE_NETNTLM;
8916 salt_type = SALT_TYPE_EMBEDDED;
8917 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8918 opts_type = OPTS_TYPE_PT_GENERATE_LE
8919 | OPTS_TYPE_PT_ADD80
8920 | OPTS_TYPE_PT_ADDBITS14
8921 | OPTS_TYPE_PT_UNICODE
8922 | OPTS_TYPE_ST_HEX;
8923 kern_type = KERN_TYPE_NETNTLMv1;
8924 dgst_size = DGST_SIZE_4_4;
8925 parse_func = netntlmv1_parse_hash;
8926 sort_by_digest = sort_by_digest_4_4;
8927 opti_type = OPTI_TYPE_ZERO_BYTE
8928 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8929 dgst_pos0 = 0;
8930 dgst_pos1 = 1;
8931 dgst_pos2 = 2;
8932 dgst_pos3 = 3;
8933 break;
8934
8935 case 5600: hash_type = HASH_TYPE_MD5;
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 kern_type = KERN_TYPE_NETNTLMv2;
8943 dgst_size = DGST_SIZE_4_4;
8944 parse_func = netntlmv2_parse_hash;
8945 sort_by_digest = sort_by_digest_4_4;
8946 opti_type = OPTI_TYPE_ZERO_BYTE;
8947 dgst_pos0 = 0;
8948 dgst_pos1 = 3;
8949 dgst_pos2 = 2;
8950 dgst_pos3 = 1;
8951 break;
8952
8953 case 5700: hash_type = HASH_TYPE_SHA256;
8954 salt_type = SALT_TYPE_NONE;
8955 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8956 opts_type = OPTS_TYPE_PT_GENERATE_BE
8957 | OPTS_TYPE_PT_ADD80
8958 | OPTS_TYPE_PT_ADDBITS15;
8959 kern_type = KERN_TYPE_SHA256;
8960 dgst_size = DGST_SIZE_4_8;
8961 parse_func = cisco4_parse_hash;
8962 sort_by_digest = sort_by_digest_4_8;
8963 opti_type = OPTI_TYPE_ZERO_BYTE
8964 | OPTI_TYPE_PRECOMPUTE_INIT
8965 | OPTI_TYPE_PRECOMPUTE_MERKLE
8966 | OPTI_TYPE_EARLY_SKIP
8967 | OPTI_TYPE_NOT_ITERATED
8968 | OPTI_TYPE_NOT_SALTED
8969 | OPTI_TYPE_RAW_HASH;
8970 dgst_pos0 = 3;
8971 dgst_pos1 = 7;
8972 dgst_pos2 = 2;
8973 dgst_pos3 = 6;
8974 break;
8975
8976 case 5800: hash_type = HASH_TYPE_SHA1;
8977 salt_type = SALT_TYPE_INTERN;
8978 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8979 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8980 | OPTS_TYPE_ST_ADD80;
8981 kern_type = KERN_TYPE_ANDROIDPIN;
8982 dgst_size = DGST_SIZE_4_5;
8983 parse_func = androidpin_parse_hash;
8984 sort_by_digest = sort_by_digest_4_5;
8985 opti_type = OPTI_TYPE_ZERO_BYTE;
8986 dgst_pos0 = 0;
8987 dgst_pos1 = 1;
8988 dgst_pos2 = 2;
8989 dgst_pos3 = 3;
8990 break;
8991
8992 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8993 salt_type = SALT_TYPE_NONE;
8994 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8995 opts_type = OPTS_TYPE_PT_GENERATE_LE
8996 | OPTS_TYPE_PT_ADD80;
8997 kern_type = KERN_TYPE_RIPEMD160;
8998 dgst_size = DGST_SIZE_4_5;
8999 parse_func = ripemd160_parse_hash;
9000 sort_by_digest = sort_by_digest_4_5;
9001 opti_type = OPTI_TYPE_ZERO_BYTE;
9002 dgst_pos0 = 0;
9003 dgst_pos1 = 1;
9004 dgst_pos2 = 2;
9005 dgst_pos3 = 3;
9006 break;
9007
9008 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9009 salt_type = SALT_TYPE_NONE;
9010 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9011 opts_type = OPTS_TYPE_PT_GENERATE_BE
9012 | OPTS_TYPE_PT_ADD80;
9013 kern_type = KERN_TYPE_WHIRLPOOL;
9014 dgst_size = DGST_SIZE_4_16;
9015 parse_func = whirlpool_parse_hash;
9016 sort_by_digest = sort_by_digest_4_16;
9017 opti_type = OPTI_TYPE_ZERO_BYTE;
9018 dgst_pos0 = 0;
9019 dgst_pos1 = 1;
9020 dgst_pos2 = 2;
9021 dgst_pos3 = 3;
9022 break;
9023
9024 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9025 salt_type = SALT_TYPE_EMBEDDED;
9026 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9027 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9028 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9029 dgst_size = DGST_SIZE_4_5;
9030 parse_func = truecrypt_parse_hash_2k;
9031 sort_by_digest = sort_by_digest_4_5;
9032 opti_type = OPTI_TYPE_ZERO_BYTE;
9033 dgst_pos0 = 0;
9034 dgst_pos1 = 1;
9035 dgst_pos2 = 2;
9036 dgst_pos3 = 3;
9037 break;
9038
9039 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9040 salt_type = SALT_TYPE_EMBEDDED;
9041 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9042 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9043 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9044 dgst_size = DGST_SIZE_4_5;
9045 parse_func = truecrypt_parse_hash_2k;
9046 sort_by_digest = sort_by_digest_4_5;
9047 opti_type = OPTI_TYPE_ZERO_BYTE;
9048 dgst_pos0 = 0;
9049 dgst_pos1 = 1;
9050 dgst_pos2 = 2;
9051 dgst_pos3 = 3;
9052 break;
9053
9054 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9055 salt_type = SALT_TYPE_EMBEDDED;
9056 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9057 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9058 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9059 dgst_size = DGST_SIZE_4_5;
9060 parse_func = truecrypt_parse_hash_2k;
9061 sort_by_digest = sort_by_digest_4_5;
9062 opti_type = OPTI_TYPE_ZERO_BYTE;
9063 dgst_pos0 = 0;
9064 dgst_pos1 = 1;
9065 dgst_pos2 = 2;
9066 dgst_pos3 = 3;
9067 break;
9068
9069 case 6221: hash_type = HASH_TYPE_SHA512;
9070 salt_type = SALT_TYPE_EMBEDDED;
9071 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9072 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9073 kern_type = KERN_TYPE_TCSHA512_XTS512;
9074 dgst_size = DGST_SIZE_8_8;
9075 parse_func = truecrypt_parse_hash_1k;
9076 sort_by_digest = sort_by_digest_8_8;
9077 opti_type = OPTI_TYPE_ZERO_BYTE
9078 | OPTI_TYPE_USES_BITS_64;
9079 dgst_pos0 = 0;
9080 dgst_pos1 = 1;
9081 dgst_pos2 = 2;
9082 dgst_pos3 = 3;
9083 break;
9084
9085 case 6222: hash_type = HASH_TYPE_SHA512;
9086 salt_type = SALT_TYPE_EMBEDDED;
9087 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9088 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9089 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9090 dgst_size = DGST_SIZE_8_8;
9091 parse_func = truecrypt_parse_hash_1k;
9092 sort_by_digest = sort_by_digest_8_8;
9093 opti_type = OPTI_TYPE_ZERO_BYTE
9094 | OPTI_TYPE_USES_BITS_64;
9095 dgst_pos0 = 0;
9096 dgst_pos1 = 1;
9097 dgst_pos2 = 2;
9098 dgst_pos3 = 3;
9099 break;
9100
9101 case 6223: hash_type = HASH_TYPE_SHA512;
9102 salt_type = SALT_TYPE_EMBEDDED;
9103 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9104 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9105 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9106 dgst_size = DGST_SIZE_8_8;
9107 parse_func = truecrypt_parse_hash_1k;
9108 sort_by_digest = sort_by_digest_8_8;
9109 opti_type = OPTI_TYPE_ZERO_BYTE
9110 | OPTI_TYPE_USES_BITS_64;
9111 dgst_pos0 = 0;
9112 dgst_pos1 = 1;
9113 dgst_pos2 = 2;
9114 dgst_pos3 = 3;
9115 break;
9116
9117 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9118 salt_type = SALT_TYPE_EMBEDDED;
9119 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9120 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9121 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9122 dgst_size = DGST_SIZE_4_8;
9123 parse_func = truecrypt_parse_hash_1k;
9124 sort_by_digest = sort_by_digest_4_8;
9125 opti_type = OPTI_TYPE_ZERO_BYTE;
9126 dgst_pos0 = 0;
9127 dgst_pos1 = 1;
9128 dgst_pos2 = 2;
9129 dgst_pos3 = 3;
9130 break;
9131
9132 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9133 salt_type = SALT_TYPE_EMBEDDED;
9134 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9135 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9136 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9137 dgst_size = DGST_SIZE_4_8;
9138 parse_func = truecrypt_parse_hash_1k;
9139 sort_by_digest = sort_by_digest_4_8;
9140 opti_type = OPTI_TYPE_ZERO_BYTE;
9141 dgst_pos0 = 0;
9142 dgst_pos1 = 1;
9143 dgst_pos2 = 2;
9144 dgst_pos3 = 3;
9145 break;
9146
9147 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9148 salt_type = SALT_TYPE_EMBEDDED;
9149 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9150 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9151 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9152 dgst_size = DGST_SIZE_4_8;
9153 parse_func = truecrypt_parse_hash_1k;
9154 sort_by_digest = sort_by_digest_4_8;
9155 opti_type = OPTI_TYPE_ZERO_BYTE;
9156 dgst_pos0 = 0;
9157 dgst_pos1 = 1;
9158 dgst_pos2 = 2;
9159 dgst_pos3 = 3;
9160 break;
9161
9162 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9163 salt_type = SALT_TYPE_EMBEDDED;
9164 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9165 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9166 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9167 dgst_size = DGST_SIZE_4_5;
9168 parse_func = truecrypt_parse_hash_1k;
9169 sort_by_digest = sort_by_digest_4_5;
9170 opti_type = OPTI_TYPE_ZERO_BYTE;
9171 dgst_pos0 = 0;
9172 dgst_pos1 = 1;
9173 dgst_pos2 = 2;
9174 dgst_pos3 = 3;
9175 break;
9176
9177 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9178 salt_type = SALT_TYPE_EMBEDDED;
9179 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9180 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9181 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9182 dgst_size = DGST_SIZE_4_5;
9183 parse_func = truecrypt_parse_hash_1k;
9184 sort_by_digest = sort_by_digest_4_5;
9185 opti_type = OPTI_TYPE_ZERO_BYTE;
9186 dgst_pos0 = 0;
9187 dgst_pos1 = 1;
9188 dgst_pos2 = 2;
9189 dgst_pos3 = 3;
9190 break;
9191
9192 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9193 salt_type = SALT_TYPE_EMBEDDED;
9194 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9195 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9196 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9197 dgst_size = DGST_SIZE_4_5;
9198 parse_func = truecrypt_parse_hash_1k;
9199 sort_by_digest = sort_by_digest_4_5;
9200 opti_type = OPTI_TYPE_ZERO_BYTE;
9201 dgst_pos0 = 0;
9202 dgst_pos1 = 1;
9203 dgst_pos2 = 2;
9204 dgst_pos3 = 3;
9205 break;
9206
9207 case 6300: hash_type = HASH_TYPE_MD5;
9208 salt_type = SALT_TYPE_EMBEDDED;
9209 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9210 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9211 kern_type = KERN_TYPE_MD5AIX;
9212 dgst_size = DGST_SIZE_4_4;
9213 parse_func = md5aix_parse_hash;
9214 sort_by_digest = sort_by_digest_4_4;
9215 opti_type = OPTI_TYPE_ZERO_BYTE;
9216 dgst_pos0 = 0;
9217 dgst_pos1 = 1;
9218 dgst_pos2 = 2;
9219 dgst_pos3 = 3;
9220 break;
9221
9222 case 6400: hash_type = HASH_TYPE_SHA256;
9223 salt_type = SALT_TYPE_EMBEDDED;
9224 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9225 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9226 kern_type = KERN_TYPE_SHA256AIX;
9227 dgst_size = DGST_SIZE_4_8;
9228 parse_func = sha256aix_parse_hash;
9229 sort_by_digest = sort_by_digest_4_8;
9230 opti_type = OPTI_TYPE_ZERO_BYTE;
9231 dgst_pos0 = 0;
9232 dgst_pos1 = 1;
9233 dgst_pos2 = 2;
9234 dgst_pos3 = 3;
9235 break;
9236
9237 case 6500: hash_type = HASH_TYPE_SHA512;
9238 salt_type = SALT_TYPE_EMBEDDED;
9239 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9240 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9241 kern_type = KERN_TYPE_SHA512AIX;
9242 dgst_size = DGST_SIZE_8_8;
9243 parse_func = sha512aix_parse_hash;
9244 sort_by_digest = sort_by_digest_8_8;
9245 opti_type = OPTI_TYPE_ZERO_BYTE
9246 | OPTI_TYPE_USES_BITS_64;
9247 dgst_pos0 = 0;
9248 dgst_pos1 = 1;
9249 dgst_pos2 = 2;
9250 dgst_pos3 = 3;
9251 break;
9252
9253 case 6600: hash_type = HASH_TYPE_AES;
9254 salt_type = SALT_TYPE_EMBEDDED;
9255 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9256 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9257 kern_type = KERN_TYPE_AGILEKEY;
9258 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9259 parse_func = agilekey_parse_hash;
9260 sort_by_digest = sort_by_digest_4_5;
9261 opti_type = OPTI_TYPE_ZERO_BYTE;
9262 dgst_pos0 = 0;
9263 dgst_pos1 = 1;
9264 dgst_pos2 = 2;
9265 dgst_pos3 = 3;
9266 break;
9267
9268 case 6700: hash_type = HASH_TYPE_SHA1;
9269 salt_type = SALT_TYPE_EMBEDDED;
9270 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9271 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9272 kern_type = KERN_TYPE_SHA1AIX;
9273 dgst_size = DGST_SIZE_4_5;
9274 parse_func = sha1aix_parse_hash;
9275 sort_by_digest = sort_by_digest_4_5;
9276 opti_type = OPTI_TYPE_ZERO_BYTE;
9277 dgst_pos0 = 0;
9278 dgst_pos1 = 1;
9279 dgst_pos2 = 2;
9280 dgst_pos3 = 3;
9281 break;
9282
9283 case 6800: hash_type = HASH_TYPE_AES;
9284 salt_type = SALT_TYPE_EMBEDDED;
9285 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9286 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9287 kern_type = KERN_TYPE_LASTPASS;
9288 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9289 parse_func = lastpass_parse_hash;
9290 sort_by_digest = sort_by_digest_4_8;
9291 opti_type = OPTI_TYPE_ZERO_BYTE;
9292 dgst_pos0 = 0;
9293 dgst_pos1 = 1;
9294 dgst_pos2 = 2;
9295 dgst_pos3 = 3;
9296 break;
9297
9298 case 6900: hash_type = HASH_TYPE_GOST;
9299 salt_type = SALT_TYPE_NONE;
9300 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9301 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9302 kern_type = KERN_TYPE_GOST;
9303 dgst_size = DGST_SIZE_4_8;
9304 parse_func = gost_parse_hash;
9305 sort_by_digest = sort_by_digest_4_8;
9306 opti_type = OPTI_TYPE_ZERO_BYTE;
9307 dgst_pos0 = 0;
9308 dgst_pos1 = 1;
9309 dgst_pos2 = 2;
9310 dgst_pos3 = 3;
9311 break;
9312
9313 case 7100: hash_type = HASH_TYPE_SHA512;
9314 salt_type = SALT_TYPE_EMBEDDED;
9315 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9316 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9317 kern_type = KERN_TYPE_PBKDF2_SHA512;
9318 dgst_size = DGST_SIZE_8_16;
9319 parse_func = sha512osx_parse_hash;
9320 sort_by_digest = sort_by_digest_8_16;
9321 opti_type = OPTI_TYPE_ZERO_BYTE
9322 | OPTI_TYPE_USES_BITS_64
9323 | OPTI_TYPE_SLOW_HASH_SIMD;
9324 dgst_pos0 = 0;
9325 dgst_pos1 = 1;
9326 dgst_pos2 = 2;
9327 dgst_pos3 = 3;
9328 break;
9329
9330 case 7200: hash_type = HASH_TYPE_SHA512;
9331 salt_type = SALT_TYPE_EMBEDDED;
9332 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9333 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9334 kern_type = KERN_TYPE_PBKDF2_SHA512;
9335 dgst_size = DGST_SIZE_8_16;
9336 parse_func = sha512grub_parse_hash;
9337 sort_by_digest = sort_by_digest_8_16;
9338 opti_type = OPTI_TYPE_ZERO_BYTE
9339 | OPTI_TYPE_USES_BITS_64
9340 | OPTI_TYPE_SLOW_HASH_SIMD;
9341 dgst_pos0 = 0;
9342 dgst_pos1 = 1;
9343 dgst_pos2 = 2;
9344 dgst_pos3 = 3;
9345 break;
9346
9347 case 7300: hash_type = HASH_TYPE_SHA1;
9348 salt_type = SALT_TYPE_EMBEDDED;
9349 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9350 opts_type = OPTS_TYPE_PT_GENERATE_BE
9351 | OPTS_TYPE_ST_ADD80
9352 | OPTS_TYPE_ST_ADDBITS15;
9353 kern_type = KERN_TYPE_RAKP;
9354 dgst_size = DGST_SIZE_4_5;
9355 parse_func = rakp_parse_hash;
9356 sort_by_digest = sort_by_digest_4_5;
9357 opti_type = OPTI_TYPE_ZERO_BYTE
9358 | OPTI_TYPE_NOT_ITERATED;
9359 dgst_pos0 = 3;
9360 dgst_pos1 = 4;
9361 dgst_pos2 = 2;
9362 dgst_pos3 = 1;
9363 break;
9364
9365 case 7400: hash_type = HASH_TYPE_SHA256;
9366 salt_type = SALT_TYPE_EMBEDDED;
9367 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9368 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9369 kern_type = KERN_TYPE_SHA256CRYPT;
9370 dgst_size = DGST_SIZE_4_8;
9371 parse_func = sha256crypt_parse_hash;
9372 sort_by_digest = sort_by_digest_4_8;
9373 opti_type = OPTI_TYPE_ZERO_BYTE;
9374 dgst_pos0 = 0;
9375 dgst_pos1 = 1;
9376 dgst_pos2 = 2;
9377 dgst_pos3 = 3;
9378 break;
9379
9380 case 7500: hash_type = HASH_TYPE_KRB5PA;
9381 salt_type = SALT_TYPE_EMBEDDED;
9382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9383 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9384 kern_type = KERN_TYPE_KRB5PA;
9385 dgst_size = DGST_SIZE_4_4;
9386 parse_func = krb5pa_parse_hash;
9387 sort_by_digest = sort_by_digest_4_4;
9388 opti_type = OPTI_TYPE_ZERO_BYTE
9389 | OPTI_TYPE_NOT_ITERATED;
9390 dgst_pos0 = 0;
9391 dgst_pos1 = 1;
9392 dgst_pos2 = 2;
9393 dgst_pos3 = 3;
9394 break;
9395
9396 case 7600: hash_type = HASH_TYPE_SHA1;
9397 salt_type = SALT_TYPE_INTERN;
9398 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9399 opts_type = OPTS_TYPE_PT_GENERATE_BE
9400 | OPTS_TYPE_PT_ADD80
9401 | OPTS_TYPE_PT_ADDBITS15;
9402 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9403 dgst_size = DGST_SIZE_4_5;
9404 parse_func = redmine_parse_hash;
9405 sort_by_digest = sort_by_digest_4_5;
9406 opti_type = OPTI_TYPE_ZERO_BYTE
9407 | OPTI_TYPE_PRECOMPUTE_INIT
9408 | OPTI_TYPE_EARLY_SKIP
9409 | OPTI_TYPE_NOT_ITERATED
9410 | OPTI_TYPE_PREPENDED_SALT;
9411 dgst_pos0 = 3;
9412 dgst_pos1 = 4;
9413 dgst_pos2 = 2;
9414 dgst_pos3 = 1;
9415 break;
9416
9417 case 7700: hash_type = HASH_TYPE_SAPB;
9418 salt_type = SALT_TYPE_EMBEDDED;
9419 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9420 opts_type = OPTS_TYPE_PT_GENERATE_LE
9421 | OPTS_TYPE_PT_UPPER
9422 | OPTS_TYPE_ST_UPPER;
9423 kern_type = KERN_TYPE_SAPB;
9424 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9425 parse_func = sapb_parse_hash;
9426 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9427 opti_type = OPTI_TYPE_ZERO_BYTE
9428 | OPTI_TYPE_PRECOMPUTE_INIT
9429 | OPTI_TYPE_NOT_ITERATED;
9430 dgst_pos0 = 0;
9431 dgst_pos1 = 1;
9432 dgst_pos2 = 2;
9433 dgst_pos3 = 3;
9434 break;
9435
9436 case 7800: hash_type = HASH_TYPE_SAPG;
9437 salt_type = SALT_TYPE_EMBEDDED;
9438 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9439 opts_type = OPTS_TYPE_PT_GENERATE_BE
9440 | OPTS_TYPE_ST_ADD80
9441 | OPTS_TYPE_ST_UPPER;
9442 kern_type = KERN_TYPE_SAPG;
9443 dgst_size = DGST_SIZE_4_5;
9444 parse_func = sapg_parse_hash;
9445 sort_by_digest = sort_by_digest_4_5;
9446 opti_type = OPTI_TYPE_ZERO_BYTE
9447 | OPTI_TYPE_PRECOMPUTE_INIT
9448 | OPTI_TYPE_NOT_ITERATED;
9449 dgst_pos0 = 3;
9450 dgst_pos1 = 4;
9451 dgst_pos2 = 2;
9452 dgst_pos3 = 1;
9453 break;
9454
9455 case 7900: hash_type = HASH_TYPE_SHA512;
9456 salt_type = SALT_TYPE_EMBEDDED;
9457 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9458 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9459 kern_type = KERN_TYPE_DRUPAL7;
9460 dgst_size = DGST_SIZE_8_8;
9461 parse_func = drupal7_parse_hash;
9462 sort_by_digest = sort_by_digest_8_8;
9463 opti_type = OPTI_TYPE_ZERO_BYTE
9464 | OPTI_TYPE_USES_BITS_64;
9465 dgst_pos0 = 0;
9466 dgst_pos1 = 1;
9467 dgst_pos2 = 2;
9468 dgst_pos3 = 3;
9469 break;
9470
9471 case 8000: hash_type = HASH_TYPE_SHA256;
9472 salt_type = SALT_TYPE_EMBEDDED;
9473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9474 opts_type = OPTS_TYPE_PT_GENERATE_BE
9475 | OPTS_TYPE_PT_UNICODE
9476 | OPTS_TYPE_ST_ADD80
9477 | OPTS_TYPE_ST_HEX;
9478 kern_type = KERN_TYPE_SYBASEASE;
9479 dgst_size = DGST_SIZE_4_8;
9480 parse_func = sybasease_parse_hash;
9481 sort_by_digest = sort_by_digest_4_8;
9482 opti_type = OPTI_TYPE_ZERO_BYTE
9483 | OPTI_TYPE_PRECOMPUTE_INIT
9484 | OPTI_TYPE_EARLY_SKIP
9485 | OPTI_TYPE_NOT_ITERATED
9486 | OPTI_TYPE_RAW_HASH;
9487 dgst_pos0 = 3;
9488 dgst_pos1 = 7;
9489 dgst_pos2 = 2;
9490 dgst_pos3 = 6;
9491 break;
9492
9493 case 8100: hash_type = HASH_TYPE_SHA1;
9494 salt_type = SALT_TYPE_EMBEDDED;
9495 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9496 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9497 kern_type = KERN_TYPE_NETSCALER;
9498 dgst_size = DGST_SIZE_4_5;
9499 parse_func = netscaler_parse_hash;
9500 sort_by_digest = sort_by_digest_4_5;
9501 opti_type = OPTI_TYPE_ZERO_BYTE
9502 | OPTI_TYPE_PRECOMPUTE_INIT
9503 | OPTI_TYPE_PRECOMPUTE_MERKLE
9504 | OPTI_TYPE_EARLY_SKIP
9505 | OPTI_TYPE_NOT_ITERATED
9506 | OPTI_TYPE_PREPENDED_SALT
9507 | OPTI_TYPE_RAW_HASH;
9508 dgst_pos0 = 3;
9509 dgst_pos1 = 4;
9510 dgst_pos2 = 2;
9511 dgst_pos3 = 1;
9512 break;
9513
9514 case 8200: hash_type = HASH_TYPE_SHA256;
9515 salt_type = SALT_TYPE_EMBEDDED;
9516 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9517 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9518 kern_type = KERN_TYPE_CLOUDKEY;
9519 dgst_size = DGST_SIZE_4_8;
9520 parse_func = cloudkey_parse_hash;
9521 sort_by_digest = sort_by_digest_4_8;
9522 opti_type = OPTI_TYPE_ZERO_BYTE;
9523 dgst_pos0 = 0;
9524 dgst_pos1 = 1;
9525 dgst_pos2 = 2;
9526 dgst_pos3 = 3;
9527 break;
9528
9529 case 8300: hash_type = HASH_TYPE_SHA1;
9530 salt_type = SALT_TYPE_EMBEDDED;
9531 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9532 opts_type = OPTS_TYPE_PT_GENERATE_BE
9533 | OPTS_TYPE_ST_HEX
9534 | OPTS_TYPE_ST_ADD80;
9535 kern_type = KERN_TYPE_NSEC3;
9536 dgst_size = DGST_SIZE_4_5;
9537 parse_func = nsec3_parse_hash;
9538 sort_by_digest = sort_by_digest_4_5;
9539 opti_type = OPTI_TYPE_ZERO_BYTE;
9540 dgst_pos0 = 3;
9541 dgst_pos1 = 4;
9542 dgst_pos2 = 2;
9543 dgst_pos3 = 1;
9544 break;
9545
9546 case 8400: hash_type = HASH_TYPE_SHA1;
9547 salt_type = SALT_TYPE_INTERN;
9548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9549 opts_type = OPTS_TYPE_PT_GENERATE_BE
9550 | OPTS_TYPE_PT_ADD80
9551 | OPTS_TYPE_PT_ADDBITS15;
9552 kern_type = KERN_TYPE_WBB3;
9553 dgst_size = DGST_SIZE_4_5;
9554 parse_func = wbb3_parse_hash;
9555 sort_by_digest = sort_by_digest_4_5;
9556 opti_type = OPTI_TYPE_ZERO_BYTE
9557 | OPTI_TYPE_PRECOMPUTE_INIT
9558 | OPTI_TYPE_NOT_ITERATED;
9559 dgst_pos0 = 3;
9560 dgst_pos1 = 4;
9561 dgst_pos2 = 2;
9562 dgst_pos3 = 1;
9563 break;
9564
9565 case 8500: hash_type = HASH_TYPE_DESRACF;
9566 salt_type = SALT_TYPE_EMBEDDED;
9567 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9568 opts_type = OPTS_TYPE_PT_GENERATE_LE
9569 | OPTS_TYPE_ST_UPPER;
9570 kern_type = KERN_TYPE_RACF;
9571 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9572 parse_func = racf_parse_hash;
9573 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9574 opti_type = OPTI_TYPE_ZERO_BYTE
9575 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9576 dgst_pos0 = 0;
9577 dgst_pos1 = 1;
9578 dgst_pos2 = 2;
9579 dgst_pos3 = 3;
9580 break;
9581
9582 case 8600: hash_type = HASH_TYPE_LOTUS5;
9583 salt_type = SALT_TYPE_NONE;
9584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9585 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9586 kern_type = KERN_TYPE_LOTUS5;
9587 dgst_size = DGST_SIZE_4_4;
9588 parse_func = lotus5_parse_hash;
9589 sort_by_digest = sort_by_digest_4_4;
9590 opti_type = OPTI_TYPE_EARLY_SKIP
9591 | OPTI_TYPE_NOT_ITERATED
9592 | OPTI_TYPE_NOT_SALTED
9593 | OPTI_TYPE_RAW_HASH;
9594 dgst_pos0 = 0;
9595 dgst_pos1 = 1;
9596 dgst_pos2 = 2;
9597 dgst_pos3 = 3;
9598 break;
9599
9600 case 8700: hash_type = HASH_TYPE_LOTUS6;
9601 salt_type = SALT_TYPE_EMBEDDED;
9602 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9603 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9604 kern_type = KERN_TYPE_LOTUS6;
9605 dgst_size = DGST_SIZE_4_4;
9606 parse_func = lotus6_parse_hash;
9607 sort_by_digest = sort_by_digest_4_4;
9608 opti_type = OPTI_TYPE_EARLY_SKIP
9609 | OPTI_TYPE_NOT_ITERATED
9610 | OPTI_TYPE_RAW_HASH;
9611 dgst_pos0 = 0;
9612 dgst_pos1 = 1;
9613 dgst_pos2 = 2;
9614 dgst_pos3 = 3;
9615 break;
9616
9617 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9618 salt_type = SALT_TYPE_EMBEDDED;
9619 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9620 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9621 kern_type = KERN_TYPE_ANDROIDFDE;
9622 dgst_size = DGST_SIZE_4_4;
9623 parse_func = androidfde_parse_hash;
9624 sort_by_digest = sort_by_digest_4_4;
9625 opti_type = OPTI_TYPE_ZERO_BYTE;
9626 dgst_pos0 = 0;
9627 dgst_pos1 = 1;
9628 dgst_pos2 = 2;
9629 dgst_pos3 = 3;
9630 break;
9631
9632 case 8900: hash_type = HASH_TYPE_SCRYPT;
9633 salt_type = SALT_TYPE_EMBEDDED;
9634 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9635 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9636 kern_type = KERN_TYPE_SCRYPT;
9637 dgst_size = DGST_SIZE_4_8;
9638 parse_func = scrypt_parse_hash;
9639 sort_by_digest = sort_by_digest_4_8;
9640 opti_type = OPTI_TYPE_ZERO_BYTE;
9641 dgst_pos0 = 0;
9642 dgst_pos1 = 1;
9643 dgst_pos2 = 2;
9644 dgst_pos3 = 3;
9645 break;
9646
9647 case 9000: hash_type = HASH_TYPE_SHA1;
9648 salt_type = SALT_TYPE_EMBEDDED;
9649 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9650 opts_type = OPTS_TYPE_PT_GENERATE_LE
9651 | OPTS_TYPE_ST_GENERATE_LE;
9652 kern_type = KERN_TYPE_PSAFE2;
9653 dgst_size = DGST_SIZE_4_5;
9654 parse_func = psafe2_parse_hash;
9655 sort_by_digest = sort_by_digest_4_5;
9656 opti_type = OPTI_TYPE_ZERO_BYTE;
9657 dgst_pos0 = 0;
9658 dgst_pos1 = 1;
9659 dgst_pos2 = 2;
9660 dgst_pos3 = 3;
9661 break;
9662
9663 case 9100: hash_type = HASH_TYPE_LOTUS8;
9664 salt_type = SALT_TYPE_EMBEDDED;
9665 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9666 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9667 kern_type = KERN_TYPE_LOTUS8;
9668 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9669 parse_func = lotus8_parse_hash;
9670 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9671 opti_type = OPTI_TYPE_ZERO_BYTE;
9672 dgst_pos0 = 0;
9673 dgst_pos1 = 1;
9674 dgst_pos2 = 2;
9675 dgst_pos3 = 3;
9676 break;
9677
9678 case 9200: hash_type = HASH_TYPE_SHA256;
9679 salt_type = SALT_TYPE_EMBEDDED;
9680 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9681 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9682 kern_type = KERN_TYPE_PBKDF2_SHA256;
9683 dgst_size = DGST_SIZE_4_32;
9684 parse_func = cisco8_parse_hash;
9685 sort_by_digest = sort_by_digest_4_32;
9686 opti_type = OPTI_TYPE_ZERO_BYTE
9687 | OPTI_TYPE_SLOW_HASH_SIMD;
9688 dgst_pos0 = 0;
9689 dgst_pos1 = 1;
9690 dgst_pos2 = 2;
9691 dgst_pos3 = 3;
9692 break;
9693
9694 case 9300: hash_type = HASH_TYPE_SCRYPT;
9695 salt_type = SALT_TYPE_EMBEDDED;
9696 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9697 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9698 kern_type = KERN_TYPE_SCRYPT;
9699 dgst_size = DGST_SIZE_4_8;
9700 parse_func = cisco9_parse_hash;
9701 sort_by_digest = sort_by_digest_4_8;
9702 opti_type = OPTI_TYPE_ZERO_BYTE;
9703 dgst_pos0 = 0;
9704 dgst_pos1 = 1;
9705 dgst_pos2 = 2;
9706 dgst_pos3 = 3;
9707 break;
9708
9709 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9710 salt_type = SALT_TYPE_EMBEDDED;
9711 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9712 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9713 kern_type = KERN_TYPE_OFFICE2007;
9714 dgst_size = DGST_SIZE_4_4;
9715 parse_func = office2007_parse_hash;
9716 sort_by_digest = sort_by_digest_4_4;
9717 opti_type = OPTI_TYPE_ZERO_BYTE;
9718 dgst_pos0 = 0;
9719 dgst_pos1 = 1;
9720 dgst_pos2 = 2;
9721 dgst_pos3 = 3;
9722 break;
9723
9724 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9725 salt_type = SALT_TYPE_EMBEDDED;
9726 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9727 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9728 kern_type = KERN_TYPE_OFFICE2010;
9729 dgst_size = DGST_SIZE_4_4;
9730 parse_func = office2010_parse_hash;
9731 sort_by_digest = sort_by_digest_4_4;
9732 opti_type = OPTI_TYPE_ZERO_BYTE;
9733 dgst_pos0 = 0;
9734 dgst_pos1 = 1;
9735 dgst_pos2 = 2;
9736 dgst_pos3 = 3;
9737 break;
9738
9739 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9740 salt_type = SALT_TYPE_EMBEDDED;
9741 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9742 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9743 kern_type = KERN_TYPE_OFFICE2013;
9744 dgst_size = DGST_SIZE_4_4;
9745 parse_func = office2013_parse_hash;
9746 sort_by_digest = sort_by_digest_4_4;
9747 opti_type = OPTI_TYPE_ZERO_BYTE;
9748 dgst_pos0 = 0;
9749 dgst_pos1 = 1;
9750 dgst_pos2 = 2;
9751 dgst_pos3 = 3;
9752 break;
9753
9754 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9755 salt_type = SALT_TYPE_EMBEDDED;
9756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9757 opts_type = OPTS_TYPE_PT_GENERATE_LE
9758 | OPTS_TYPE_PT_ADD80
9759 | OPTS_TYPE_PT_UNICODE;
9760 kern_type = KERN_TYPE_OLDOFFICE01;
9761 dgst_size = DGST_SIZE_4_4;
9762 parse_func = oldoffice01_parse_hash;
9763 sort_by_digest = sort_by_digest_4_4;
9764 opti_type = OPTI_TYPE_ZERO_BYTE
9765 | OPTI_TYPE_PRECOMPUTE_INIT
9766 | OPTI_TYPE_NOT_ITERATED;
9767 dgst_pos0 = 0;
9768 dgst_pos1 = 1;
9769 dgst_pos2 = 2;
9770 dgst_pos3 = 3;
9771 break;
9772
9773 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9774 salt_type = SALT_TYPE_EMBEDDED;
9775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9776 opts_type = OPTS_TYPE_PT_GENERATE_LE
9777 | OPTS_TYPE_PT_ADD80;
9778 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9779 dgst_size = DGST_SIZE_4_4;
9780 parse_func = oldoffice01cm1_parse_hash;
9781 sort_by_digest = sort_by_digest_4_4;
9782 opti_type = OPTI_TYPE_ZERO_BYTE
9783 | OPTI_TYPE_PRECOMPUTE_INIT
9784 | OPTI_TYPE_NOT_ITERATED;
9785 dgst_pos0 = 0;
9786 dgst_pos1 = 1;
9787 dgst_pos2 = 2;
9788 dgst_pos3 = 3;
9789 break;
9790
9791 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9792 salt_type = SALT_TYPE_EMBEDDED;
9793 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9794 opts_type = OPTS_TYPE_PT_GENERATE_LE
9795 | OPTS_TYPE_PT_ADD80
9796 | OPTS_TYPE_PT_UNICODE
9797 | OPTS_TYPE_PT_NEVERCRACK;
9798 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9799 dgst_size = DGST_SIZE_4_4;
9800 parse_func = oldoffice01cm2_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 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9812 salt_type = SALT_TYPE_EMBEDDED;
9813 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9814 opts_type = OPTS_TYPE_PT_GENERATE_BE
9815 | OPTS_TYPE_PT_ADD80
9816 | OPTS_TYPE_PT_UNICODE;
9817 kern_type = KERN_TYPE_OLDOFFICE34;
9818 dgst_size = DGST_SIZE_4_4;
9819 parse_func = oldoffice34_parse_hash;
9820 sort_by_digest = sort_by_digest_4_4;
9821 opti_type = OPTI_TYPE_ZERO_BYTE
9822 | OPTI_TYPE_PRECOMPUTE_INIT
9823 | OPTI_TYPE_NOT_ITERATED;
9824 dgst_pos0 = 0;
9825 dgst_pos1 = 1;
9826 dgst_pos2 = 2;
9827 dgst_pos3 = 3;
9828 break;
9829
9830 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9831 salt_type = SALT_TYPE_EMBEDDED;
9832 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9833 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9834 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9835 dgst_size = DGST_SIZE_4_4;
9836 parse_func = oldoffice34cm1_parse_hash;
9837 sort_by_digest = sort_by_digest_4_4;
9838 opti_type = OPTI_TYPE_ZERO_BYTE
9839 | OPTI_TYPE_PRECOMPUTE_INIT
9840 | OPTI_TYPE_NOT_ITERATED;
9841 dgst_pos0 = 0;
9842 dgst_pos1 = 1;
9843 dgst_pos2 = 2;
9844 dgst_pos3 = 3;
9845 break;
9846
9847 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9848 salt_type = SALT_TYPE_EMBEDDED;
9849 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9850 opts_type = OPTS_TYPE_PT_GENERATE_BE
9851 | OPTS_TYPE_PT_ADD80
9852 | OPTS_TYPE_PT_UNICODE
9853 | OPTS_TYPE_PT_NEVERCRACK;
9854 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9855 dgst_size = DGST_SIZE_4_4;
9856 parse_func = oldoffice34cm2_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 9900: hash_type = HASH_TYPE_MD5;
9868 salt_type = SALT_TYPE_NONE;
9869 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9870 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9871 kern_type = KERN_TYPE_RADMIN2;
9872 dgst_size = DGST_SIZE_4_4;
9873 parse_func = radmin2_parse_hash;
9874 sort_by_digest = sort_by_digest_4_4;
9875 opti_type = OPTI_TYPE_ZERO_BYTE
9876 | OPTI_TYPE_PRECOMPUTE_INIT
9877 | OPTI_TYPE_EARLY_SKIP
9878 | OPTI_TYPE_NOT_ITERATED
9879 | OPTI_TYPE_NOT_SALTED;
9880 dgst_pos0 = 0;
9881 dgst_pos1 = 3;
9882 dgst_pos2 = 2;
9883 dgst_pos3 = 1;
9884 break;
9885
9886 case 10000: hash_type = HASH_TYPE_SHA256;
9887 salt_type = SALT_TYPE_EMBEDDED;
9888 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9889 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9890 kern_type = KERN_TYPE_PBKDF2_SHA256;
9891 dgst_size = DGST_SIZE_4_32;
9892 parse_func = djangopbkdf2_parse_hash;
9893 sort_by_digest = sort_by_digest_4_32;
9894 opti_type = OPTI_TYPE_ZERO_BYTE
9895 | OPTI_TYPE_SLOW_HASH_SIMD;
9896 dgst_pos0 = 0;
9897 dgst_pos1 = 1;
9898 dgst_pos2 = 2;
9899 dgst_pos3 = 3;
9900 break;
9901
9902 case 10100: hash_type = HASH_TYPE_SIPHASH;
9903 salt_type = SALT_TYPE_EMBEDDED;
9904 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9905 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9906 kern_type = KERN_TYPE_SIPHASH;
9907 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9908 parse_func = siphash_parse_hash;
9909 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9910 opti_type = OPTI_TYPE_ZERO_BYTE
9911 | OPTI_TYPE_NOT_ITERATED
9912 | OPTI_TYPE_RAW_HASH;
9913 dgst_pos0 = 0;
9914 dgst_pos1 = 1;
9915 dgst_pos2 = 2;
9916 dgst_pos3 = 3;
9917 break;
9918
9919 case 10200: hash_type = HASH_TYPE_MD5;
9920 salt_type = SALT_TYPE_EMBEDDED;
9921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9922 opts_type = OPTS_TYPE_PT_GENERATE_LE
9923 | OPTS_TYPE_ST_ADD80
9924 | OPTS_TYPE_ST_ADDBITS14;
9925 kern_type = KERN_TYPE_HMACMD5_PW;
9926 dgst_size = DGST_SIZE_4_4;
9927 parse_func = crammd5_parse_hash;
9928 sort_by_digest = sort_by_digest_4_4;
9929 opti_type = OPTI_TYPE_ZERO_BYTE
9930 | OPTI_TYPE_NOT_ITERATED;
9931 dgst_pos0 = 0;
9932 dgst_pos1 = 3;
9933 dgst_pos2 = 2;
9934 dgst_pos3 = 1;
9935 break;
9936
9937 case 10300: hash_type = HASH_TYPE_SHA1;
9938 salt_type = SALT_TYPE_EMBEDDED;
9939 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9940 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9941 kern_type = KERN_TYPE_SAPH_SHA1;
9942 dgst_size = DGST_SIZE_4_5;
9943 parse_func = saph_sha1_parse_hash;
9944 sort_by_digest = sort_by_digest_4_5;
9945 opti_type = OPTI_TYPE_ZERO_BYTE;
9946 dgst_pos0 = 0;
9947 dgst_pos1 = 1;
9948 dgst_pos2 = 2;
9949 dgst_pos3 = 3;
9950 break;
9951
9952 case 10400: hash_type = HASH_TYPE_PDFU16;
9953 salt_type = SALT_TYPE_EMBEDDED;
9954 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9955 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9956 kern_type = KERN_TYPE_PDF11;
9957 dgst_size = DGST_SIZE_4_4;
9958 parse_func = pdf11_parse_hash;
9959 sort_by_digest = sort_by_digest_4_4;
9960 opti_type = OPTI_TYPE_ZERO_BYTE
9961 | OPTI_TYPE_NOT_ITERATED;
9962 dgst_pos0 = 0;
9963 dgst_pos1 = 1;
9964 dgst_pos2 = 2;
9965 dgst_pos3 = 3;
9966 break;
9967
9968 case 10410: hash_type = HASH_TYPE_PDFU16;
9969 salt_type = SALT_TYPE_EMBEDDED;
9970 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9971 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9972 kern_type = KERN_TYPE_PDF11CM1;
9973 dgst_size = DGST_SIZE_4_4;
9974 parse_func = pdf11cm1_parse_hash;
9975 sort_by_digest = sort_by_digest_4_4;
9976 opti_type = OPTI_TYPE_ZERO_BYTE
9977 | OPTI_TYPE_NOT_ITERATED;
9978 dgst_pos0 = 0;
9979 dgst_pos1 = 1;
9980 dgst_pos2 = 2;
9981 dgst_pos3 = 3;
9982 break;
9983
9984 case 10420: hash_type = HASH_TYPE_PDFU16;
9985 salt_type = SALT_TYPE_EMBEDDED;
9986 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9987 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9988 kern_type = KERN_TYPE_PDF11CM2;
9989 dgst_size = DGST_SIZE_4_4;
9990 parse_func = pdf11cm2_parse_hash;
9991 sort_by_digest = sort_by_digest_4_4;
9992 opti_type = OPTI_TYPE_ZERO_BYTE
9993 | OPTI_TYPE_NOT_ITERATED;
9994 dgst_pos0 = 0;
9995 dgst_pos1 = 1;
9996 dgst_pos2 = 2;
9997 dgst_pos3 = 3;
9998 break;
9999
10000 case 10500: hash_type = HASH_TYPE_PDFU16;
10001 salt_type = SALT_TYPE_EMBEDDED;
10002 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10003 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10004 kern_type = KERN_TYPE_PDF14;
10005 dgst_size = DGST_SIZE_4_4;
10006 parse_func = pdf14_parse_hash;
10007 sort_by_digest = sort_by_digest_4_4;
10008 opti_type = OPTI_TYPE_ZERO_BYTE
10009 | OPTI_TYPE_NOT_ITERATED;
10010 dgst_pos0 = 0;
10011 dgst_pos1 = 1;
10012 dgst_pos2 = 2;
10013 dgst_pos3 = 3;
10014 break;
10015
10016 case 10600: hash_type = HASH_TYPE_SHA256;
10017 salt_type = SALT_TYPE_EMBEDDED;
10018 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10019 opts_type = OPTS_TYPE_PT_GENERATE_BE
10020 | OPTS_TYPE_ST_ADD80
10021 | OPTS_TYPE_ST_ADDBITS15
10022 | OPTS_TYPE_HASH_COPY;
10023 kern_type = KERN_TYPE_SHA256_PWSLT;
10024 dgst_size = DGST_SIZE_4_8;
10025 parse_func = pdf17l3_parse_hash;
10026 sort_by_digest = sort_by_digest_4_8;
10027 opti_type = OPTI_TYPE_ZERO_BYTE
10028 | OPTI_TYPE_PRECOMPUTE_INIT
10029 | OPTI_TYPE_PRECOMPUTE_MERKLE
10030 | OPTI_TYPE_EARLY_SKIP
10031 | OPTI_TYPE_NOT_ITERATED
10032 | OPTI_TYPE_APPENDED_SALT
10033 | OPTI_TYPE_RAW_HASH;
10034 dgst_pos0 = 3;
10035 dgst_pos1 = 7;
10036 dgst_pos2 = 2;
10037 dgst_pos3 = 6;
10038 break;
10039
10040 case 10700: hash_type = HASH_TYPE_PDFU32;
10041 salt_type = SALT_TYPE_EMBEDDED;
10042 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10043 opts_type = OPTS_TYPE_PT_GENERATE_LE
10044 | OPTS_TYPE_HASH_COPY;
10045 kern_type = KERN_TYPE_PDF17L8;
10046 dgst_size = DGST_SIZE_4_8;
10047 parse_func = pdf17l8_parse_hash;
10048 sort_by_digest = sort_by_digest_4_8;
10049 opti_type = OPTI_TYPE_ZERO_BYTE
10050 | OPTI_TYPE_NOT_ITERATED;
10051 dgst_pos0 = 0;
10052 dgst_pos1 = 1;
10053 dgst_pos2 = 2;
10054 dgst_pos3 = 3;
10055 break;
10056
10057 case 10800: hash_type = HASH_TYPE_SHA384;
10058 salt_type = SALT_TYPE_NONE;
10059 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10060 opts_type = OPTS_TYPE_PT_GENERATE_BE
10061 | OPTS_TYPE_PT_ADD80
10062 | OPTS_TYPE_PT_ADDBITS15;
10063 kern_type = KERN_TYPE_SHA384;
10064 dgst_size = DGST_SIZE_8_8;
10065 parse_func = sha384_parse_hash;
10066 sort_by_digest = sort_by_digest_8_8;
10067 opti_type = OPTI_TYPE_ZERO_BYTE
10068 | OPTI_TYPE_PRECOMPUTE_INIT
10069 | OPTI_TYPE_PRECOMPUTE_MERKLE
10070 | OPTI_TYPE_EARLY_SKIP
10071 | OPTI_TYPE_NOT_ITERATED
10072 | OPTI_TYPE_NOT_SALTED
10073 | OPTI_TYPE_USES_BITS_64
10074 | OPTI_TYPE_RAW_HASH;
10075 dgst_pos0 = 6;
10076 dgst_pos1 = 7;
10077 dgst_pos2 = 4;
10078 dgst_pos3 = 5;
10079 break;
10080
10081 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10082 salt_type = SALT_TYPE_EMBEDDED;
10083 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10084 opts_type = OPTS_TYPE_PT_GENERATE_LE
10085 | OPTS_TYPE_ST_BASE64
10086 | OPTS_TYPE_HASH_COPY;
10087 kern_type = KERN_TYPE_PBKDF2_SHA256;
10088 dgst_size = DGST_SIZE_4_32;
10089 parse_func = pbkdf2_sha256_parse_hash;
10090 sort_by_digest = sort_by_digest_4_32;
10091 opti_type = OPTI_TYPE_ZERO_BYTE
10092 | OPTI_TYPE_SLOW_HASH_SIMD;
10093 dgst_pos0 = 0;
10094 dgst_pos1 = 1;
10095 dgst_pos2 = 2;
10096 dgst_pos3 = 3;
10097 break;
10098
10099 case 11000: hash_type = HASH_TYPE_MD5;
10100 salt_type = SALT_TYPE_INTERN;
10101 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10102 opts_type = OPTS_TYPE_PT_GENERATE_LE
10103 | OPTS_TYPE_PT_ADD80;
10104 kern_type = KERN_TYPE_PRESTASHOP;
10105 dgst_size = DGST_SIZE_4_4;
10106 parse_func = prestashop_parse_hash;
10107 sort_by_digest = sort_by_digest_4_4;
10108 opti_type = OPTI_TYPE_ZERO_BYTE
10109 | OPTI_TYPE_PRECOMPUTE_INIT
10110 | OPTI_TYPE_NOT_ITERATED
10111 | OPTI_TYPE_PREPENDED_SALT;
10112 dgst_pos0 = 0;
10113 dgst_pos1 = 3;
10114 dgst_pos2 = 2;
10115 dgst_pos3 = 1;
10116 break;
10117
10118 case 11100: hash_type = HASH_TYPE_MD5;
10119 salt_type = SALT_TYPE_EMBEDDED;
10120 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10121 opts_type = OPTS_TYPE_PT_GENERATE_LE
10122 | OPTS_TYPE_ST_ADD80;
10123 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10124 dgst_size = DGST_SIZE_4_4;
10125 parse_func = postgresql_auth_parse_hash;
10126 sort_by_digest = sort_by_digest_4_4;
10127 opti_type = OPTI_TYPE_ZERO_BYTE
10128 | OPTI_TYPE_PRECOMPUTE_INIT
10129 | OPTI_TYPE_PRECOMPUTE_MERKLE
10130 | OPTI_TYPE_EARLY_SKIP;
10131 dgst_pos0 = 0;
10132 dgst_pos1 = 3;
10133 dgst_pos2 = 2;
10134 dgst_pos3 = 1;
10135 break;
10136
10137 case 11200: hash_type = HASH_TYPE_SHA1;
10138 salt_type = SALT_TYPE_EMBEDDED;
10139 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10140 opts_type = OPTS_TYPE_PT_GENERATE_BE
10141 | OPTS_TYPE_PT_ADD80
10142 | OPTS_TYPE_ST_HEX;
10143 kern_type = KERN_TYPE_MYSQL_AUTH;
10144 dgst_size = DGST_SIZE_4_5;
10145 parse_func = mysql_auth_parse_hash;
10146 sort_by_digest = sort_by_digest_4_5;
10147 opti_type = OPTI_TYPE_ZERO_BYTE
10148 | OPTI_TYPE_EARLY_SKIP;
10149 dgst_pos0 = 3;
10150 dgst_pos1 = 4;
10151 dgst_pos2 = 2;
10152 dgst_pos3 = 1;
10153 break;
10154
10155 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10156 salt_type = SALT_TYPE_EMBEDDED;
10157 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10158 opts_type = OPTS_TYPE_PT_GENERATE_LE
10159 | OPTS_TYPE_ST_HEX
10160 | OPTS_TYPE_ST_ADD80;
10161 kern_type = KERN_TYPE_BITCOIN_WALLET;
10162 dgst_size = DGST_SIZE_4_4;
10163 parse_func = bitcoin_wallet_parse_hash;
10164 sort_by_digest = sort_by_digest_4_4;
10165 opti_type = OPTI_TYPE_ZERO_BYTE;
10166 dgst_pos0 = 0;
10167 dgst_pos1 = 1;
10168 dgst_pos2 = 2;
10169 dgst_pos3 = 3;
10170 break;
10171
10172 case 11400: hash_type = HASH_TYPE_MD5;
10173 salt_type = SALT_TYPE_EMBEDDED;
10174 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10175 opts_type = OPTS_TYPE_PT_GENERATE_LE
10176 | OPTS_TYPE_PT_ADD80
10177 | OPTS_TYPE_HASH_COPY;
10178 kern_type = KERN_TYPE_SIP_AUTH;
10179 dgst_size = DGST_SIZE_4_4;
10180 parse_func = sip_auth_parse_hash;
10181 sort_by_digest = sort_by_digest_4_4;
10182 opti_type = OPTI_TYPE_ZERO_BYTE;
10183 dgst_pos0 = 0;
10184 dgst_pos1 = 3;
10185 dgst_pos2 = 2;
10186 dgst_pos3 = 1;
10187 break;
10188
10189 case 11500: hash_type = HASH_TYPE_CRC32;
10190 salt_type = SALT_TYPE_INTERN;
10191 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10192 opts_type = OPTS_TYPE_PT_GENERATE_LE
10193 | OPTS_TYPE_ST_GENERATE_LE
10194 | OPTS_TYPE_ST_HEX;
10195 kern_type = KERN_TYPE_CRC32;
10196 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10197 parse_func = crc32_parse_hash;
10198 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10199 opti_type = OPTI_TYPE_ZERO_BYTE;
10200 dgst_pos0 = 0;
10201 dgst_pos1 = 1;
10202 dgst_pos2 = 2;
10203 dgst_pos3 = 3;
10204 break;
10205
10206 case 11600: hash_type = HASH_TYPE_AES;
10207 salt_type = SALT_TYPE_EMBEDDED;
10208 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10209 opts_type = OPTS_TYPE_PT_GENERATE_LE
10210 | OPTS_TYPE_PT_NEVERCRACK;
10211 kern_type = KERN_TYPE_SEVEN_ZIP;
10212 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10213 parse_func = seven_zip_parse_hash;
10214 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10215 opti_type = OPTI_TYPE_ZERO_BYTE;
10216 dgst_pos0 = 0;
10217 dgst_pos1 = 1;
10218 dgst_pos2 = 2;
10219 dgst_pos3 = 3;
10220 break;
10221
10222 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10223 salt_type = SALT_TYPE_NONE;
10224 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10225 opts_type = OPTS_TYPE_PT_GENERATE_LE
10226 | OPTS_TYPE_PT_ADD01;
10227 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10228 dgst_size = DGST_SIZE_4_8;
10229 parse_func = gost2012sbog_256_parse_hash;
10230 sort_by_digest = sort_by_digest_4_8;
10231 opti_type = OPTI_TYPE_ZERO_BYTE;
10232 dgst_pos0 = 0;
10233 dgst_pos1 = 1;
10234 dgst_pos2 = 2;
10235 dgst_pos3 = 3;
10236 break;
10237
10238 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10239 salt_type = SALT_TYPE_NONE;
10240 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10241 opts_type = OPTS_TYPE_PT_GENERATE_LE
10242 | OPTS_TYPE_PT_ADD01;
10243 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10244 dgst_size = DGST_SIZE_4_16;
10245 parse_func = gost2012sbog_512_parse_hash;
10246 sort_by_digest = sort_by_digest_4_16;
10247 opti_type = OPTI_TYPE_ZERO_BYTE;
10248 dgst_pos0 = 0;
10249 dgst_pos1 = 1;
10250 dgst_pos2 = 2;
10251 dgst_pos3 = 3;
10252 break;
10253
10254 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10255 salt_type = SALT_TYPE_EMBEDDED;
10256 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10257 opts_type = OPTS_TYPE_PT_GENERATE_LE
10258 | OPTS_TYPE_ST_BASE64
10259 | OPTS_TYPE_HASH_COPY;
10260 kern_type = KERN_TYPE_PBKDF2_MD5;
10261 dgst_size = DGST_SIZE_4_32;
10262 parse_func = pbkdf2_md5_parse_hash;
10263 sort_by_digest = sort_by_digest_4_32;
10264 opti_type = OPTI_TYPE_ZERO_BYTE
10265 | OPTI_TYPE_SLOW_HASH_SIMD;
10266 dgst_pos0 = 0;
10267 dgst_pos1 = 1;
10268 dgst_pos2 = 2;
10269 dgst_pos3 = 3;
10270 break;
10271
10272 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10273 salt_type = SALT_TYPE_EMBEDDED;
10274 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10275 opts_type = OPTS_TYPE_PT_GENERATE_LE
10276 | OPTS_TYPE_ST_BASE64
10277 | OPTS_TYPE_HASH_COPY;
10278 kern_type = KERN_TYPE_PBKDF2_SHA1;
10279 dgst_size = DGST_SIZE_4_32;
10280 parse_func = pbkdf2_sha1_parse_hash;
10281 sort_by_digest = sort_by_digest_4_32;
10282 opti_type = OPTI_TYPE_ZERO_BYTE
10283 | OPTI_TYPE_SLOW_HASH_SIMD;
10284 dgst_pos0 = 0;
10285 dgst_pos1 = 1;
10286 dgst_pos2 = 2;
10287 dgst_pos3 = 3;
10288 break;
10289
10290 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10291 salt_type = SALT_TYPE_EMBEDDED;
10292 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10293 opts_type = OPTS_TYPE_PT_GENERATE_LE
10294 | OPTS_TYPE_ST_BASE64
10295 | OPTS_TYPE_HASH_COPY;
10296 kern_type = KERN_TYPE_PBKDF2_SHA512;
10297 dgst_size = DGST_SIZE_8_16;
10298 parse_func = pbkdf2_sha512_parse_hash;
10299 sort_by_digest = sort_by_digest_8_16;
10300 opti_type = OPTI_TYPE_ZERO_BYTE
10301 | OPTI_TYPE_USES_BITS_64
10302 | OPTI_TYPE_SLOW_HASH_SIMD;
10303 dgst_pos0 = 0;
10304 dgst_pos1 = 1;
10305 dgst_pos2 = 2;
10306 dgst_pos3 = 3;
10307 break;
10308
10309 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10310 salt_type = SALT_TYPE_EMBEDDED;
10311 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10312 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10313 kern_type = KERN_TYPE_ECRYPTFS;
10314 dgst_size = DGST_SIZE_8_8;
10315 parse_func = ecryptfs_parse_hash;
10316 sort_by_digest = sort_by_digest_8_8;
10317 opti_type = OPTI_TYPE_ZERO_BYTE
10318 | OPTI_TYPE_USES_BITS_64;
10319 dgst_pos0 = 0;
10320 dgst_pos1 = 1;
10321 dgst_pos2 = 2;
10322 dgst_pos3 = 3;
10323 break;
10324
10325 case 12300: hash_type = HASH_TYPE_ORACLET;
10326 salt_type = SALT_TYPE_EMBEDDED;
10327 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10328 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10329 kern_type = KERN_TYPE_ORACLET;
10330 dgst_size = DGST_SIZE_8_16;
10331 parse_func = oraclet_parse_hash;
10332 sort_by_digest = sort_by_digest_8_16;
10333 opti_type = OPTI_TYPE_ZERO_BYTE
10334 | OPTI_TYPE_USES_BITS_64;
10335 dgst_pos0 = 0;
10336 dgst_pos1 = 1;
10337 dgst_pos2 = 2;
10338 dgst_pos3 = 3;
10339 break;
10340
10341 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10342 salt_type = SALT_TYPE_EMBEDDED;
10343 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10344 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10345 kern_type = KERN_TYPE_BSDICRYPT;
10346 dgst_size = DGST_SIZE_4_4;
10347 parse_func = bsdicrypt_parse_hash;
10348 sort_by_digest = sort_by_digest_4_4;
10349 opti_type = OPTI_TYPE_ZERO_BYTE
10350 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10351 dgst_pos0 = 0;
10352 dgst_pos1 = 1;
10353 dgst_pos2 = 2;
10354 dgst_pos3 = 3;
10355 break;
10356
10357 case 12500: hash_type = HASH_TYPE_RAR3HP;
10358 salt_type = SALT_TYPE_EMBEDDED;
10359 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10360 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10361 kern_type = KERN_TYPE_RAR3;
10362 dgst_size = DGST_SIZE_4_4;
10363 parse_func = rar3hp_parse_hash;
10364 sort_by_digest = sort_by_digest_4_4;
10365 opti_type = OPTI_TYPE_ZERO_BYTE;
10366 dgst_pos0 = 0;
10367 dgst_pos1 = 1;
10368 dgst_pos2 = 2;
10369 dgst_pos3 = 3;
10370 break;
10371
10372 case 12600: hash_type = HASH_TYPE_SHA256;
10373 salt_type = SALT_TYPE_INTERN;
10374 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10375 opts_type = OPTS_TYPE_PT_GENERATE_BE
10376 | OPTS_TYPE_PT_ADD80;
10377 kern_type = KERN_TYPE_CF10;
10378 dgst_size = DGST_SIZE_4_8;
10379 parse_func = cf10_parse_hash;
10380 sort_by_digest = sort_by_digest_4_8;
10381 opti_type = OPTI_TYPE_ZERO_BYTE
10382 | OPTI_TYPE_PRECOMPUTE_INIT
10383 | OPTI_TYPE_EARLY_SKIP
10384 | OPTI_TYPE_NOT_ITERATED;
10385 dgst_pos0 = 3;
10386 dgst_pos1 = 7;
10387 dgst_pos2 = 2;
10388 dgst_pos3 = 6;
10389 break;
10390
10391 case 12700: hash_type = HASH_TYPE_AES;
10392 salt_type = SALT_TYPE_EMBEDDED;
10393 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10394 opts_type = OPTS_TYPE_PT_GENERATE_LE
10395 | OPTS_TYPE_HASH_COPY;
10396 kern_type = KERN_TYPE_MYWALLET;
10397 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10398 parse_func = mywallet_parse_hash;
10399 sort_by_digest = sort_by_digest_4_5;
10400 opti_type = OPTI_TYPE_ZERO_BYTE;
10401 dgst_pos0 = 0;
10402 dgst_pos1 = 1;
10403 dgst_pos2 = 2;
10404 dgst_pos3 = 3;
10405 break;
10406
10407 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10408 salt_type = SALT_TYPE_EMBEDDED;
10409 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10410 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10411 kern_type = KERN_TYPE_MS_DRSR;
10412 dgst_size = DGST_SIZE_4_8;
10413 parse_func = ms_drsr_parse_hash;
10414 sort_by_digest = sort_by_digest_4_8;
10415 opti_type = OPTI_TYPE_ZERO_BYTE;
10416 dgst_pos0 = 0;
10417 dgst_pos1 = 1;
10418 dgst_pos2 = 2;
10419 dgst_pos3 = 3;
10420 break;
10421
10422 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10423 salt_type = SALT_TYPE_EMBEDDED;
10424 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10425 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10426 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10427 dgst_size = DGST_SIZE_4_8;
10428 parse_func = androidfde_samsung_parse_hash;
10429 sort_by_digest = sort_by_digest_4_8;
10430 opti_type = OPTI_TYPE_ZERO_BYTE;
10431 dgst_pos0 = 0;
10432 dgst_pos1 = 1;
10433 dgst_pos2 = 2;
10434 dgst_pos3 = 3;
10435 break;
10436
10437 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10438 salt_type = SALT_TYPE_EMBEDDED;
10439 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10440 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10441 kern_type = KERN_TYPE_RAR5;
10442 dgst_size = DGST_SIZE_4_4;
10443 parse_func = rar5_parse_hash;
10444 sort_by_digest = sort_by_digest_4_4;
10445 opti_type = OPTI_TYPE_ZERO_BYTE;
10446 dgst_pos0 = 0;
10447 dgst_pos1 = 1;
10448 dgst_pos2 = 2;
10449 dgst_pos3 = 3;
10450 break;
10451
10452 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10453 salt_type = SALT_TYPE_EMBEDDED;
10454 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10455 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10456 kern_type = KERN_TYPE_KRB5TGS;
10457 dgst_size = DGST_SIZE_4_4;
10458 parse_func = krb5tgs_parse_hash;
10459 sort_by_digest = sort_by_digest_4_4;
10460 opti_type = OPTI_TYPE_ZERO_BYTE
10461 | OPTI_TYPE_NOT_ITERATED;
10462 dgst_pos0 = 0;
10463 dgst_pos1 = 1;
10464 dgst_pos2 = 2;
10465 dgst_pos3 = 3;
10466 break;
10467
10468 case 13200: hash_type = HASH_TYPE_AES;
10469 salt_type = SALT_TYPE_EMBEDDED;
10470 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10471 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10472 kern_type = KERN_TYPE_AXCRYPT;
10473 dgst_size = DGST_SIZE_4_4;
10474 parse_func = axcrypt_parse_hash;
10475 sort_by_digest = sort_by_digest_4_4;
10476 opti_type = OPTI_TYPE_ZERO_BYTE;
10477 dgst_pos0 = 0;
10478 dgst_pos1 = 1;
10479 dgst_pos2 = 2;
10480 dgst_pos3 = 3;
10481 break;
10482
10483 case 13300: hash_type = HASH_TYPE_SHA1;
10484 salt_type = SALT_TYPE_NONE;
10485 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10486 opts_type = OPTS_TYPE_PT_GENERATE_BE
10487 | OPTS_TYPE_PT_ADD80
10488 | OPTS_TYPE_PT_ADDBITS15;
10489 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10490 dgst_size = DGST_SIZE_4_5;
10491 parse_func = sha1axcrypt_parse_hash;
10492 sort_by_digest = sort_by_digest_4_5;
10493 opti_type = OPTI_TYPE_ZERO_BYTE
10494 | OPTI_TYPE_PRECOMPUTE_INIT
10495 | OPTI_TYPE_EARLY_SKIP
10496 | OPTI_TYPE_NOT_ITERATED
10497 | OPTI_TYPE_NOT_SALTED;
10498 dgst_pos0 = 0;
10499 dgst_pos1 = 4;
10500 dgst_pos2 = 3;
10501 dgst_pos3 = 2;
10502 break;
10503
10504 case 13400: hash_type = HASH_TYPE_AES;
10505 salt_type = SALT_TYPE_EMBEDDED;
10506 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10507 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10508 kern_type = KERN_TYPE_KEEPASS;
10509 dgst_size = DGST_SIZE_4_4;
10510 parse_func = keepass_parse_hash;
10511 sort_by_digest = sort_by_digest_4_4;
10512 opti_type = OPTI_TYPE_ZERO_BYTE;
10513 dgst_pos0 = 0;
10514 dgst_pos1 = 1;
10515 dgst_pos2 = 2;
10516 dgst_pos3 = 3;
10517 break;
10518
10519 case 13500: hash_type = HASH_TYPE_SHA1;
10520 salt_type = SALT_TYPE_EMBEDDED;
10521 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10522 opts_type = OPTS_TYPE_PT_GENERATE_BE
10523 | OPTS_TYPE_PT_UNICODE
10524 | OPTS_TYPE_PT_ADD80;
10525 kern_type = KERN_TYPE_PSTOKEN;
10526 dgst_size = DGST_SIZE_4_5;
10527 parse_func = pstoken_parse_hash;
10528 sort_by_digest = sort_by_digest_4_5;
10529 opti_type = OPTI_TYPE_ZERO_BYTE
10530 | OPTI_TYPE_PRECOMPUTE_INIT
10531 | OPTI_TYPE_EARLY_SKIP
10532 | OPTI_TYPE_NOT_ITERATED
10533 | OPTI_TYPE_PREPENDED_SALT
10534 | OPTI_TYPE_RAW_HASH;
10535 dgst_pos0 = 3;
10536 dgst_pos1 = 4;
10537 dgst_pos2 = 2;
10538 dgst_pos3 = 1;
10539 break;
10540
10541 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10542 salt_type = SALT_TYPE_EMBEDDED;
10543 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10544 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10545 kern_type = KERN_TYPE_ZIP2;
10546 dgst_size = DGST_SIZE_4_4;
10547 parse_func = zip2_parse_hash;
10548 sort_by_digest = sort_by_digest_4_4;
10549 opti_type = OPTI_TYPE_ZERO_BYTE;
10550 dgst_pos0 = 0;
10551 dgst_pos1 = 1;
10552 dgst_pos2 = 2;
10553 dgst_pos3 = 3;
10554 break;
10555
10556 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10557 salt_type = SALT_TYPE_EMBEDDED;
10558 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10559 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10560 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10561 dgst_size = DGST_SIZE_4_5;
10562 parse_func = veracrypt_parse_hash_655331;
10563 sort_by_digest = sort_by_digest_4_5;
10564 opti_type = OPTI_TYPE_ZERO_BYTE;
10565 dgst_pos0 = 0;
10566 dgst_pos1 = 1;
10567 dgst_pos2 = 2;
10568 dgst_pos3 = 3;
10569 break;
10570
10571 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10572 salt_type = SALT_TYPE_EMBEDDED;
10573 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10574 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10575 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10576 dgst_size = DGST_SIZE_4_5;
10577 parse_func = veracrypt_parse_hash_655331;
10578 sort_by_digest = sort_by_digest_4_5;
10579 opti_type = OPTI_TYPE_ZERO_BYTE;
10580 dgst_pos0 = 0;
10581 dgst_pos1 = 1;
10582 dgst_pos2 = 2;
10583 dgst_pos3 = 3;
10584 break;
10585
10586 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10587 salt_type = SALT_TYPE_EMBEDDED;
10588 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10589 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10590 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10591 dgst_size = DGST_SIZE_4_5;
10592 parse_func = veracrypt_parse_hash_655331;
10593 sort_by_digest = sort_by_digest_4_5;
10594 opti_type = OPTI_TYPE_ZERO_BYTE;
10595 dgst_pos0 = 0;
10596 dgst_pos1 = 1;
10597 dgst_pos2 = 2;
10598 dgst_pos3 = 3;
10599 break;
10600
10601 case 13721: hash_type = HASH_TYPE_SHA512;
10602 salt_type = SALT_TYPE_EMBEDDED;
10603 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10604 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10605 kern_type = KERN_TYPE_TCSHA512_XTS512;
10606 dgst_size = DGST_SIZE_8_8;
10607 parse_func = veracrypt_parse_hash_500000;
10608 sort_by_digest = sort_by_digest_8_8;
10609 opti_type = OPTI_TYPE_ZERO_BYTE
10610 | OPTI_TYPE_USES_BITS_64;
10611 dgst_pos0 = 0;
10612 dgst_pos1 = 1;
10613 dgst_pos2 = 2;
10614 dgst_pos3 = 3;
10615 break;
10616
10617 case 13722: hash_type = HASH_TYPE_SHA512;
10618 salt_type = SALT_TYPE_EMBEDDED;
10619 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10620 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10621 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10622 dgst_size = DGST_SIZE_8_8;
10623 parse_func = veracrypt_parse_hash_500000;
10624 sort_by_digest = sort_by_digest_8_8;
10625 opti_type = OPTI_TYPE_ZERO_BYTE
10626 | OPTI_TYPE_USES_BITS_64;
10627 dgst_pos0 = 0;
10628 dgst_pos1 = 1;
10629 dgst_pos2 = 2;
10630 dgst_pos3 = 3;
10631 break;
10632
10633 case 13723: hash_type = HASH_TYPE_SHA512;
10634 salt_type = SALT_TYPE_EMBEDDED;
10635 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10636 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10637 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10638 dgst_size = DGST_SIZE_8_8;
10639 parse_func = veracrypt_parse_hash_500000;
10640 sort_by_digest = sort_by_digest_8_8;
10641 opti_type = OPTI_TYPE_ZERO_BYTE
10642 | OPTI_TYPE_USES_BITS_64;
10643 dgst_pos0 = 0;
10644 dgst_pos1 = 1;
10645 dgst_pos2 = 2;
10646 dgst_pos3 = 3;
10647 break;
10648
10649 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10650 salt_type = SALT_TYPE_EMBEDDED;
10651 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10652 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10653 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10654 dgst_size = DGST_SIZE_4_8;
10655 parse_func = veracrypt_parse_hash_500000;
10656 sort_by_digest = sort_by_digest_4_8;
10657 opti_type = OPTI_TYPE_ZERO_BYTE;
10658 dgst_pos0 = 0;
10659 dgst_pos1 = 1;
10660 dgst_pos2 = 2;
10661 dgst_pos3 = 3;
10662 break;
10663
10664 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10665 salt_type = SALT_TYPE_EMBEDDED;
10666 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10667 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10668 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10669 dgst_size = DGST_SIZE_4_8;
10670 parse_func = veracrypt_parse_hash_500000;
10671 sort_by_digest = sort_by_digest_4_8;
10672 opti_type = OPTI_TYPE_ZERO_BYTE;
10673 dgst_pos0 = 0;
10674 dgst_pos1 = 1;
10675 dgst_pos2 = 2;
10676 dgst_pos3 = 3;
10677 break;
10678
10679 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10680 salt_type = SALT_TYPE_EMBEDDED;
10681 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10682 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10683 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10684 dgst_size = DGST_SIZE_4_8;
10685 parse_func = veracrypt_parse_hash_500000;
10686 sort_by_digest = sort_by_digest_4_8;
10687 opti_type = OPTI_TYPE_ZERO_BYTE;
10688 dgst_pos0 = 0;
10689 dgst_pos1 = 1;
10690 dgst_pos2 = 2;
10691 dgst_pos3 = 3;
10692 break;
10693
10694 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10695 salt_type = SALT_TYPE_EMBEDDED;
10696 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10697 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10698 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10699 dgst_size = DGST_SIZE_4_5;
10700 parse_func = veracrypt_parse_hash_327661;
10701 sort_by_digest = sort_by_digest_4_5;
10702 opti_type = OPTI_TYPE_ZERO_BYTE;
10703 dgst_pos0 = 0;
10704 dgst_pos1 = 1;
10705 dgst_pos2 = 2;
10706 dgst_pos3 = 3;
10707 break;
10708
10709 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10710 salt_type = SALT_TYPE_EMBEDDED;
10711 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10712 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10713 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10714 dgst_size = DGST_SIZE_4_5;
10715 parse_func = veracrypt_parse_hash_327661;
10716 sort_by_digest = sort_by_digest_4_5;
10717 opti_type = OPTI_TYPE_ZERO_BYTE;
10718 dgst_pos0 = 0;
10719 dgst_pos1 = 1;
10720 dgst_pos2 = 2;
10721 dgst_pos3 = 3;
10722 break;
10723
10724 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10725 salt_type = SALT_TYPE_EMBEDDED;
10726 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10727 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10728 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10729 dgst_size = DGST_SIZE_4_5;
10730 parse_func = veracrypt_parse_hash_327661;
10731 sort_by_digest = sort_by_digest_4_5;
10732 opti_type = OPTI_TYPE_ZERO_BYTE;
10733 dgst_pos0 = 0;
10734 dgst_pos1 = 1;
10735 dgst_pos2 = 2;
10736 dgst_pos3 = 3;
10737 break;
10738
10739 case 13751: hash_type = HASH_TYPE_SHA256;
10740 salt_type = SALT_TYPE_EMBEDDED;
10741 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10742 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10743 kern_type = KERN_TYPE_VCSHA256_XTS512;
10744 dgst_size = DGST_SIZE_4_8;
10745 parse_func = veracrypt_parse_hash_500000;
10746 sort_by_digest = sort_by_digest_4_8;
10747 opti_type = OPTI_TYPE_ZERO_BYTE;
10748 dgst_pos0 = 0;
10749 dgst_pos1 = 1;
10750 dgst_pos2 = 2;
10751 dgst_pos3 = 3;
10752 break;
10753
10754 case 13752: hash_type = HASH_TYPE_SHA256;
10755 salt_type = SALT_TYPE_EMBEDDED;
10756 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10757 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10758 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10759 dgst_size = DGST_SIZE_4_8;
10760 parse_func = veracrypt_parse_hash_500000;
10761 sort_by_digest = sort_by_digest_4_8;
10762 opti_type = OPTI_TYPE_ZERO_BYTE;
10763 dgst_pos0 = 0;
10764 dgst_pos1 = 1;
10765 dgst_pos2 = 2;
10766 dgst_pos3 = 3;
10767 break;
10768
10769 case 13753: hash_type = HASH_TYPE_SHA256;
10770 salt_type = SALT_TYPE_EMBEDDED;
10771 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10772 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10773 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10774 dgst_size = DGST_SIZE_4_8;
10775 parse_func = veracrypt_parse_hash_500000;
10776 sort_by_digest = sort_by_digest_4_8;
10777 opti_type = OPTI_TYPE_ZERO_BYTE;
10778 dgst_pos0 = 0;
10779 dgst_pos1 = 1;
10780 dgst_pos2 = 2;
10781 dgst_pos3 = 3;
10782 break;
10783
10784 case 13761: hash_type = HASH_TYPE_SHA256;
10785 salt_type = SALT_TYPE_EMBEDDED;
10786 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10787 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10788 kern_type = KERN_TYPE_VCSHA256_XTS512;
10789 dgst_size = DGST_SIZE_4_8;
10790 parse_func = veracrypt_parse_hash_200000;
10791 sort_by_digest = sort_by_digest_4_8;
10792 opti_type = OPTI_TYPE_ZERO_BYTE;
10793 dgst_pos0 = 0;
10794 dgst_pos1 = 1;
10795 dgst_pos2 = 2;
10796 dgst_pos3 = 3;
10797 break;
10798
10799 case 13762: hash_type = HASH_TYPE_SHA256;
10800 salt_type = SALT_TYPE_EMBEDDED;
10801 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10802 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10803 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10804 dgst_size = DGST_SIZE_4_8;
10805 parse_func = veracrypt_parse_hash_200000;
10806 sort_by_digest = sort_by_digest_4_8;
10807 opti_type = OPTI_TYPE_ZERO_BYTE;
10808 dgst_pos0 = 0;
10809 dgst_pos1 = 1;
10810 dgst_pos2 = 2;
10811 dgst_pos3 = 3;
10812 break;
10813
10814 case 13763: hash_type = HASH_TYPE_SHA256;
10815 salt_type = SALT_TYPE_EMBEDDED;
10816 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10817 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10818 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10819 dgst_size = DGST_SIZE_4_8;
10820 parse_func = veracrypt_parse_hash_200000;
10821 sort_by_digest = sort_by_digest_4_8;
10822 opti_type = OPTI_TYPE_ZERO_BYTE;
10823 dgst_pos0 = 0;
10824 dgst_pos1 = 1;
10825 dgst_pos2 = 2;
10826 dgst_pos3 = 3;
10827 break;
10828
10829 case 13800: hash_type = HASH_TYPE_SHA256;
10830 salt_type = SALT_TYPE_EMBEDDED;
10831 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10832 opts_type = OPTS_TYPE_PT_GENERATE_BE
10833 | OPTS_TYPE_PT_UNICODE;
10834 kern_type = KERN_TYPE_WIN8PHONE;
10835 dgst_size = DGST_SIZE_4_8;
10836 parse_func = win8phone_parse_hash;
10837 sort_by_digest = sort_by_digest_4_8;
10838 opti_type = OPTI_TYPE_ZERO_BYTE
10839 | OPTI_TYPE_PRECOMPUTE_INIT
10840 | OPTI_TYPE_EARLY_SKIP
10841 | OPTI_TYPE_NOT_ITERATED
10842 | OPTI_TYPE_RAW_HASH;
10843 dgst_pos0 = 3;
10844 dgst_pos1 = 7;
10845 dgst_pos2 = 2;
10846 dgst_pos3 = 6;
10847 break;
10848
10849
10850 default: usage_mini_print (PROGNAME); return (-1);
10851 }
10852
10853 /**
10854 * parser
10855 */
10856
10857 data.parse_func = parse_func;
10858
10859 /**
10860 * misc stuff
10861 */
10862
10863 if (hex_salt)
10864 {
10865 if (salt_type == SALT_TYPE_INTERN)
10866 {
10867 opts_type |= OPTS_TYPE_ST_HEX;
10868 }
10869 else
10870 {
10871 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10872
10873 return (-1);
10874 }
10875 }
10876
10877 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10878 | (salt_type == SALT_TYPE_EXTERN)
10879 | (salt_type == SALT_TYPE_EMBEDDED)
10880 | (salt_type == SALT_TYPE_VIRTUAL));
10881
10882 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10883
10884 data.hash_type = hash_type;
10885 data.attack_mode = attack_mode;
10886 data.attack_kern = attack_kern;
10887 data.attack_exec = attack_exec;
10888 data.kern_type = kern_type;
10889 data.opts_type = opts_type;
10890 data.dgst_size = dgst_size;
10891 data.salt_type = salt_type;
10892 data.isSalted = isSalted;
10893 data.sort_by_digest = sort_by_digest;
10894 data.dgst_pos0 = dgst_pos0;
10895 data.dgst_pos1 = dgst_pos1;
10896 data.dgst_pos2 = dgst_pos2;
10897 data.dgst_pos3 = dgst_pos3;
10898
10899 esalt_size = 0;
10900
10901 switch (hash_mode)
10902 {
10903 case 2500: esalt_size = sizeof (wpa_t); break;
10904 case 5300: esalt_size = sizeof (ikepsk_t); break;
10905 case 5400: esalt_size = sizeof (ikepsk_t); break;
10906 case 5500: esalt_size = sizeof (netntlm_t); break;
10907 case 5600: esalt_size = sizeof (netntlm_t); break;
10908 case 6211: esalt_size = sizeof (tc_t); break;
10909 case 6212: esalt_size = sizeof (tc_t); break;
10910 case 6213: esalt_size = sizeof (tc_t); break;
10911 case 6221: esalt_size = sizeof (tc_t); break;
10912 case 6222: esalt_size = sizeof (tc_t); break;
10913 case 6223: esalt_size = sizeof (tc_t); break;
10914 case 6231: esalt_size = sizeof (tc_t); break;
10915 case 6232: esalt_size = sizeof (tc_t); break;
10916 case 6233: esalt_size = sizeof (tc_t); break;
10917 case 6241: esalt_size = sizeof (tc_t); break;
10918 case 6242: esalt_size = sizeof (tc_t); break;
10919 case 6243: esalt_size = sizeof (tc_t); break;
10920 case 6600: esalt_size = sizeof (agilekey_t); break;
10921 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10922 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10923 case 7300: esalt_size = sizeof (rakp_t); break;
10924 case 7500: esalt_size = sizeof (krb5pa_t); break;
10925 case 8200: esalt_size = sizeof (cloudkey_t); break;
10926 case 8800: esalt_size = sizeof (androidfde_t); break;
10927 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10928 case 9400: esalt_size = sizeof (office2007_t); break;
10929 case 9500: esalt_size = sizeof (office2010_t); break;
10930 case 9600: esalt_size = sizeof (office2013_t); break;
10931 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10932 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10933 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10934 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10935 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10936 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10937 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10938 case 10200: esalt_size = sizeof (cram_md5_t); break;
10939 case 10400: esalt_size = sizeof (pdf_t); break;
10940 case 10410: esalt_size = sizeof (pdf_t); break;
10941 case 10420: esalt_size = sizeof (pdf_t); break;
10942 case 10500: esalt_size = sizeof (pdf_t); break;
10943 case 10600: esalt_size = sizeof (pdf_t); break;
10944 case 10700: esalt_size = sizeof (pdf_t); break;
10945 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10946 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10947 case 11400: esalt_size = sizeof (sip_t); break;
10948 case 11600: esalt_size = sizeof (seven_zip_t); break;
10949 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10950 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10951 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10952 case 13000: esalt_size = sizeof (rar5_t); break;
10953 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10954 case 13400: esalt_size = sizeof (keepass_t); break;
10955 case 13500: esalt_size = sizeof (pstoken_t); break;
10956 case 13600: esalt_size = sizeof (zip2_t); break;
10957 case 13711: esalt_size = sizeof (tc_t); break;
10958 case 13712: esalt_size = sizeof (tc_t); break;
10959 case 13713: esalt_size = sizeof (tc_t); break;
10960 case 13721: esalt_size = sizeof (tc_t); break;
10961 case 13722: esalt_size = sizeof (tc_t); break;
10962 case 13723: esalt_size = sizeof (tc_t); break;
10963 case 13731: esalt_size = sizeof (tc_t); break;
10964 case 13732: esalt_size = sizeof (tc_t); break;
10965 case 13733: esalt_size = sizeof (tc_t); break;
10966 case 13741: esalt_size = sizeof (tc_t); break;
10967 case 13742: esalt_size = sizeof (tc_t); break;
10968 case 13743: esalt_size = sizeof (tc_t); break;
10969 case 13751: esalt_size = sizeof (tc_t); break;
10970 case 13752: esalt_size = sizeof (tc_t); break;
10971 case 13753: esalt_size = sizeof (tc_t); break;
10972 case 13761: esalt_size = sizeof (tc_t); break;
10973 case 13762: esalt_size = sizeof (tc_t); break;
10974 case 13763: esalt_size = sizeof (tc_t); break;
10975 case 13800: esalt_size = sizeof (win8phone_t); break;
10976 }
10977
10978 data.esalt_size = esalt_size;
10979
10980 /**
10981 * choose dictionary parser
10982 */
10983
10984 if (hash_type == HASH_TYPE_LM)
10985 {
10986 get_next_word_func = get_next_word_lm;
10987 }
10988 else if (opts_type & OPTS_TYPE_PT_UPPER)
10989 {
10990 get_next_word_func = get_next_word_uc;
10991 }
10992 else
10993 {
10994 get_next_word_func = get_next_word_std;
10995 }
10996
10997 /**
10998 * dictstat
10999 */
11000
11001 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11002
11003 #ifdef _POSIX
11004 size_t dictstat_nmemb = 0;
11005 #endif
11006
11007 #ifdef _WIN
11008 uint dictstat_nmemb = 0;
11009 #endif
11010
11011 char dictstat[256] = { 0 };
11012
11013 FILE *dictstat_fp = NULL;
11014
11015 if (keyspace == 0)
11016 {
11017 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11018
11019 dictstat_fp = fopen (dictstat, "rb");
11020
11021 if (dictstat_fp)
11022 {
11023 #ifdef _POSIX
11024 struct stat tmpstat;
11025
11026 fstat (fileno (dictstat_fp), &tmpstat);
11027 #endif
11028
11029 #ifdef _WIN
11030 struct stat64 tmpstat;
11031
11032 _fstat64 (fileno (dictstat_fp), &tmpstat);
11033 #endif
11034
11035 if (tmpstat.st_mtime < COMPTIME)
11036 {
11037 /* with v0.15 the format changed so we have to ensure user is using a good version
11038 since there is no version-header in the dictstat file */
11039
11040 fclose (dictstat_fp);
11041
11042 unlink (dictstat);
11043 }
11044 else
11045 {
11046 while (!feof (dictstat_fp))
11047 {
11048 dictstat_t d;
11049
11050 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11051
11052 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11053
11054 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11055 {
11056 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11057
11058 return -1;
11059 }
11060 }
11061
11062 fclose (dictstat_fp);
11063 }
11064 }
11065 }
11066
11067 /**
11068 * potfile
11069 */
11070
11071 char potfile[256] = { 0 };
11072
11073 if (potfile_path == NULL)
11074 {
11075 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11076 }
11077 else
11078 {
11079 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11080 }
11081
11082 data.pot_fp = NULL;
11083
11084 FILE *out_fp = NULL;
11085 FILE *pot_fp = NULL;
11086
11087 if (show == 1 || left == 1)
11088 {
11089 pot_fp = fopen (potfile, "rb");
11090
11091 if (pot_fp == NULL)
11092 {
11093 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11094
11095 return (-1);
11096 }
11097
11098 if (outfile != NULL)
11099 {
11100 if ((out_fp = fopen (outfile, "ab")) == NULL)
11101 {
11102 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11103
11104 fclose (pot_fp);
11105
11106 return (-1);
11107 }
11108 }
11109 else
11110 {
11111 out_fp = stdout;
11112 }
11113 }
11114 else
11115 {
11116 if (potfile_disable == 0)
11117 {
11118 pot_fp = fopen (potfile, "ab");
11119
11120 if (pot_fp == NULL)
11121 {
11122 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11123
11124 return (-1);
11125 }
11126
11127 data.pot_fp = pot_fp;
11128 }
11129 }
11130
11131 pot_t *pot = NULL;
11132
11133 uint pot_cnt = 0;
11134 uint pot_avail = 0;
11135
11136 if (show == 1 || left == 1)
11137 {
11138 SUPPRESS_OUTPUT = 1;
11139
11140 pot_avail = count_lines (pot_fp);
11141
11142 rewind (pot_fp);
11143
11144 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11145
11146 uint pot_hashes_avail = 0;
11147
11148 uint line_num = 0;
11149
11150 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11151
11152 while (!feof (pot_fp))
11153 {
11154 line_num++;
11155
11156 int line_len = fgetl (pot_fp, line_buf);
11157
11158 if (line_len == 0) continue;
11159
11160 char *plain_buf = line_buf + line_len;
11161
11162 pot_t *pot_ptr = &pot[pot_cnt];
11163
11164 hash_t *hashes_buf = &pot_ptr->hash;
11165
11166 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11167 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11168
11169 if (pot_cnt == pot_hashes_avail)
11170 {
11171 uint pos = 0;
11172
11173 for (pos = 0; pos < INCR_POT; pos++)
11174 {
11175 if ((pot_cnt + pos) >= pot_avail) break;
11176
11177 pot_t *tmp_pot = &pot[pot_cnt + pos];
11178
11179 hash_t *tmp_hash = &tmp_pot->hash;
11180
11181 tmp_hash->digest = mymalloc (dgst_size);
11182
11183 if (isSalted)
11184 {
11185 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11186 }
11187
11188 if (esalt_size)
11189 {
11190 tmp_hash->esalt = mymalloc (esalt_size);
11191 }
11192
11193 pot_hashes_avail++;
11194 }
11195 }
11196
11197 int plain_len = 0;
11198
11199 int parser_status;
11200
11201 int iter = MAX_CUT_TRIES;
11202
11203 do
11204 {
11205 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11206 {
11207 if (line_buf[i] == ':')
11208 {
11209 line_len--;
11210
11211 break;
11212 }
11213 }
11214
11215 if (data.hash_mode != 2500)
11216 {
11217 parser_status = parse_func (line_buf, line_len, hashes_buf);
11218 }
11219 else
11220 {
11221 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11222
11223 if (line_len > max_salt_size)
11224 {
11225 parser_status = PARSER_GLOBAL_LENGTH;
11226 }
11227 else
11228 {
11229 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11230
11231 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11232
11233 hashes_buf->salt->salt_len = line_len;
11234
11235 parser_status = PARSER_OK;
11236 }
11237 }
11238
11239 // if NOT parsed without error, we add the ":" to the plain
11240
11241 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11242 {
11243 plain_len++;
11244 plain_buf--;
11245 }
11246
11247 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11248
11249 if (parser_status < PARSER_GLOBAL_ZERO)
11250 {
11251 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11252
11253 continue;
11254 }
11255
11256 if (plain_len >= 255) continue;
11257
11258 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11259
11260 pot_ptr->plain_len = plain_len;
11261
11262 pot_cnt++;
11263 }
11264
11265 myfree (line_buf);
11266
11267 fclose (pot_fp);
11268
11269 SUPPRESS_OUTPUT = 0;
11270
11271 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11272 }
11273
11274 /**
11275 * word len
11276 */
11277
11278 uint pw_min = PW_MIN;
11279 uint pw_max = PW_MAX;
11280
11281 switch (hash_mode)
11282 {
11283 case 125: if (pw_max > 32) pw_max = 32;
11284 break;
11285 case 400: if (pw_max > 40) pw_max = 40;
11286 break;
11287 case 500: if (pw_max > 16) pw_max = 16;
11288 break;
11289 case 1500: if (pw_max > 8) pw_max = 8;
11290 break;
11291 case 1600: if (pw_max > 16) pw_max = 16;
11292 break;
11293 case 1800: if (pw_max > 16) pw_max = 16;
11294 break;
11295 case 2100: if (pw_max > 16) pw_max = 16;
11296 break;
11297 case 2500: if (pw_min < 8) pw_min = 8;
11298 break;
11299 case 3000: if (pw_max > 7) pw_max = 7;
11300 break;
11301 case 5200: if (pw_max > 24) pw_max = 24;
11302 break;
11303 case 5800: if (pw_max > 16) pw_max = 16;
11304 break;
11305 case 6300: if (pw_max > 16) pw_max = 16;
11306 break;
11307 case 7400: if (pw_max > 16) pw_max = 16;
11308 break;
11309 case 7700: if (pw_max > 8) pw_max = 8;
11310 break;
11311 case 7900: if (pw_max > 48) pw_max = 48;
11312 break;
11313 case 8500: if (pw_max > 8) pw_max = 8;
11314 break;
11315 case 8600: if (pw_max > 16) pw_max = 16;
11316 break;
11317 case 9710: pw_min = 5;
11318 pw_max = 5;
11319 break;
11320 case 9810: pw_min = 5;
11321 pw_max = 5;
11322 break;
11323 case 10410: pw_min = 5;
11324 pw_max = 5;
11325 break;
11326 case 10300: if (pw_max < 3) pw_min = 3;
11327 if (pw_max > 40) pw_max = 40;
11328 break;
11329 case 10500: if (pw_max < 3) pw_min = 3;
11330 if (pw_max > 40) pw_max = 40;
11331 break;
11332 case 10700: if (pw_max > 16) pw_max = 16;
11333 break;
11334 case 11300: if (pw_max > 40) pw_max = 40;
11335 break;
11336 case 11600: if (pw_max > 32) pw_max = 32;
11337 break;
11338 case 12500: if (pw_max > 20) pw_max = 20;
11339 break;
11340 case 12800: if (pw_max > 24) pw_max = 24;
11341 break;
11342 }
11343
11344 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11345 {
11346 switch (attack_kern)
11347 {
11348 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11349 break;
11350 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11351 break;
11352 }
11353 }
11354
11355 /**
11356 * charsets : keep them together for more easy maintainnce
11357 */
11358
11359 cs_t mp_sys[6] = { { { 0 }, 0 } };
11360 cs_t mp_usr[4] = { { { 0 }, 0 } };
11361
11362 mp_setup_sys (mp_sys);
11363
11364 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11365 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11366 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11367 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11368
11369 /**
11370 * load hashes, part I: find input mode, count hashes
11371 */
11372
11373 uint hashlist_mode = 0;
11374 uint hashlist_format = HLFMT_HASHCAT;
11375
11376 uint hashes_avail = 0;
11377
11378 if (benchmark == 0)
11379 {
11380 struct stat f;
11381
11382 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11383
11384 if ((hash_mode == 2500) ||
11385 (hash_mode == 5200) ||
11386 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11387 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11388 (hash_mode == 9000))
11389 {
11390 hashlist_mode = HL_MODE_ARG;
11391
11392 char *hashfile = myargv[optind];
11393
11394 data.hashfile = hashfile;
11395
11396 logfile_top_var_string ("target", hashfile);
11397 }
11398
11399 if (hashlist_mode == HL_MODE_ARG)
11400 {
11401 if (hash_mode == 2500)
11402 {
11403 struct stat st;
11404
11405 if (stat (data.hashfile, &st) == -1)
11406 {
11407 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11408
11409 return (-1);
11410 }
11411
11412 hashes_avail = st.st_size / sizeof (hccap_t);
11413 }
11414 else
11415 {
11416 hashes_avail = 1;
11417 }
11418 }
11419 else if (hashlist_mode == HL_MODE_FILE)
11420 {
11421 char *hashfile = myargv[optind];
11422
11423 data.hashfile = hashfile;
11424
11425 logfile_top_var_string ("target", hashfile);
11426
11427 FILE *fp = NULL;
11428
11429 if ((fp = fopen (hashfile, "rb")) == NULL)
11430 {
11431 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11432
11433 return (-1);
11434 }
11435
11436 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11437
11438 hashes_avail = count_lines (fp);
11439
11440 rewind (fp);
11441
11442 if (hashes_avail == 0)
11443 {
11444 log_error ("ERROR: hashfile is empty or corrupt");
11445
11446 fclose (fp);
11447
11448 return (-1);
11449 }
11450
11451 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11452
11453 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11454 {
11455 log_error ("ERROR: remove not supported in native hashfile-format mode");
11456
11457 fclose (fp);
11458
11459 return (-1);
11460 }
11461
11462 fclose (fp);
11463 }
11464 }
11465 else
11466 {
11467 hashlist_mode = HL_MODE_ARG;
11468
11469 hashes_avail = 1;
11470 }
11471
11472 if (hash_mode == 3000) hashes_avail *= 2;
11473
11474 data.hashlist_mode = hashlist_mode;
11475 data.hashlist_format = hashlist_format;
11476
11477 logfile_top_uint (hashlist_mode);
11478 logfile_top_uint (hashlist_format);
11479
11480 /**
11481 * load hashes, part II: allocate required memory, set pointers
11482 */
11483
11484 hash_t *hashes_buf = NULL;
11485 void *digests_buf = NULL;
11486 salt_t *salts_buf = NULL;
11487 void *esalts_buf = NULL;
11488
11489 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11490
11491 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11492
11493 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11494 {
11495 u32 hash_pos;
11496
11497 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11498 {
11499 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11500
11501 hashes_buf[hash_pos].hash_info = hash_info;
11502
11503 if (username && (remove || show || left))
11504 {
11505 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11506 }
11507
11508 if (benchmark)
11509 {
11510 hash_info->orighash = (char *) mymalloc (256);
11511 }
11512 }
11513 }
11514
11515 if (isSalted)
11516 {
11517 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11518
11519 if (esalt_size)
11520 {
11521 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11522 }
11523 }
11524 else
11525 {
11526 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11527 }
11528
11529 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11530 {
11531 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11532
11533 if (isSalted)
11534 {
11535 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11536
11537 if (esalt_size)
11538 {
11539 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11540 }
11541 }
11542 else
11543 {
11544 hashes_buf[hash_pos].salt = &salts_buf[0];
11545 }
11546 }
11547
11548 /**
11549 * load hashes, part III: parse hashes or generate them if benchmark
11550 */
11551
11552 uint hashes_cnt = 0;
11553
11554 if (benchmark == 0)
11555 {
11556 if (keyspace == 1)
11557 {
11558 // useless to read hash file for keyspace, cheat a little bit w/ optind
11559 }
11560 else if (hashes_avail == 0)
11561 {
11562 }
11563 else if (hashlist_mode == HL_MODE_ARG)
11564 {
11565 char *input_buf = myargv[optind];
11566
11567 uint input_len = strlen (input_buf);
11568
11569 logfile_top_var_string ("target", input_buf);
11570
11571 char *hash_buf = NULL;
11572 int hash_len = 0;
11573
11574 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11575
11576 bool hash_fmt_error = 0;
11577
11578 if (hash_len < 1) hash_fmt_error = 1;
11579 if (hash_buf == NULL) hash_fmt_error = 1;
11580
11581 if (hash_fmt_error)
11582 {
11583 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11584 }
11585 else
11586 {
11587 if (opts_type & OPTS_TYPE_HASH_COPY)
11588 {
11589 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11590
11591 hash_info_tmp->orighash = mystrdup (hash_buf);
11592 }
11593
11594 if (isSalted)
11595 {
11596 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11597 }
11598
11599 int parser_status = PARSER_OK;
11600
11601 if (hash_mode == 2500)
11602 {
11603 if (hash_len == 0)
11604 {
11605 log_error ("ERROR: hccap file not specified");
11606
11607 return (-1);
11608 }
11609
11610 hashlist_mode = HL_MODE_FILE;
11611
11612 data.hashlist_mode = hashlist_mode;
11613
11614 FILE *fp = fopen (hash_buf, "rb");
11615
11616 if (fp == NULL)
11617 {
11618 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11619
11620 return (-1);
11621 }
11622
11623 if (hashes_avail < 1)
11624 {
11625 log_error ("ERROR: hccap file is empty or corrupt");
11626
11627 fclose (fp);
11628
11629 return (-1);
11630 }
11631
11632 uint hccap_size = sizeof (hccap_t);
11633
11634 char *in = (char *) mymalloc (hccap_size);
11635
11636 while (!feof (fp))
11637 {
11638 int n = fread (in, hccap_size, 1, fp);
11639
11640 if (n != 1)
11641 {
11642 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11643
11644 break;
11645 }
11646
11647 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11648
11649 if (parser_status != PARSER_OK)
11650 {
11651 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11652
11653 continue;
11654 }
11655
11656 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11657
11658 if ((show == 1) || (left == 1))
11659 {
11660 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11661
11662 char *salt_ptr = (char *) tmp_salt->salt_buf;
11663
11664 int cur_pos = tmp_salt->salt_len;
11665 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11666
11667 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11668
11669 // do the appending task
11670
11671 snprintf (salt_ptr + cur_pos,
11672 rem_len,
11673 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11674 wpa->orig_mac1[0],
11675 wpa->orig_mac1[1],
11676 wpa->orig_mac1[2],
11677 wpa->orig_mac1[3],
11678 wpa->orig_mac1[4],
11679 wpa->orig_mac1[5],
11680 wpa->orig_mac2[0],
11681 wpa->orig_mac2[1],
11682 wpa->orig_mac2[2],
11683 wpa->orig_mac2[3],
11684 wpa->orig_mac2[4],
11685 wpa->orig_mac2[5]);
11686
11687 // memset () the remaining part of the salt
11688
11689 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11690 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11691
11692 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11693
11694 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11695 }
11696
11697 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);
11698 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);
11699
11700 hashes_cnt++;
11701 }
11702
11703 fclose (fp);
11704
11705 myfree (in);
11706 }
11707 else if (hash_mode == 3000)
11708 {
11709 if (hash_len == 32)
11710 {
11711 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11712
11713 hash_t *lm_hash_left = NULL;
11714
11715 if (parser_status == PARSER_OK)
11716 {
11717 lm_hash_left = &hashes_buf[hashes_cnt];
11718
11719 hashes_cnt++;
11720 }
11721 else
11722 {
11723 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11724 }
11725
11726 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11727
11728 hash_t *lm_hash_right = NULL;
11729
11730 if (parser_status == PARSER_OK)
11731 {
11732 lm_hash_right = &hashes_buf[hashes_cnt];
11733
11734 hashes_cnt++;
11735 }
11736 else
11737 {
11738 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11739 }
11740
11741 // show / left
11742
11743 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11744 {
11745 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);
11746 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);
11747 }
11748 }
11749 else
11750 {
11751 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11752
11753 if (parser_status == PARSER_OK)
11754 {
11755 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11756 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11757 }
11758
11759 if (parser_status == PARSER_OK)
11760 {
11761 hashes_cnt++;
11762 }
11763 else
11764 {
11765 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11766 }
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 }
11790 else if (hashlist_mode == HL_MODE_FILE)
11791 {
11792 char *hashfile = data.hashfile;
11793
11794 FILE *fp;
11795
11796 if ((fp = fopen (hashfile, "rb")) == NULL)
11797 {
11798 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11799
11800 return (-1);
11801 }
11802
11803 uint line_num = 0;
11804
11805 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11806
11807 while (!feof (fp))
11808 {
11809 line_num++;
11810
11811 int line_len = fgetl (fp, line_buf);
11812
11813 if (line_len == 0) continue;
11814
11815 char *hash_buf = NULL;
11816 int hash_len = 0;
11817
11818 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11819
11820 bool hash_fmt_error = 0;
11821
11822 if (hash_len < 1) hash_fmt_error = 1;
11823 if (hash_buf == NULL) hash_fmt_error = 1;
11824
11825 if (hash_fmt_error)
11826 {
11827 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11828
11829 continue;
11830 }
11831
11832 if (username)
11833 {
11834 char *user_buf = NULL;
11835 int user_len = 0;
11836
11837 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11838
11839 if (remove || show)
11840 {
11841 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11842
11843 *user = (user_t *) mymalloc (sizeof (user_t));
11844
11845 user_t *user_ptr = *user;
11846
11847 if (user_buf != NULL)
11848 {
11849 user_ptr->user_name = mystrdup (user_buf);
11850 }
11851 else
11852 {
11853 user_ptr->user_name = mystrdup ("");
11854 }
11855
11856 user_ptr->user_len = user_len;
11857 }
11858 }
11859
11860 if (opts_type & OPTS_TYPE_HASH_COPY)
11861 {
11862 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11863
11864 hash_info_tmp->orighash = mystrdup (hash_buf);
11865 }
11866
11867 if (isSalted)
11868 {
11869 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11870 }
11871
11872 if (hash_mode == 3000)
11873 {
11874 if (hash_len == 32)
11875 {
11876 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11877
11878 if (parser_status < PARSER_GLOBAL_ZERO)
11879 {
11880 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11881
11882 continue;
11883 }
11884
11885 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11886
11887 hashes_cnt++;
11888
11889 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11890
11891 if (parser_status < PARSER_GLOBAL_ZERO)
11892 {
11893 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11894
11895 continue;
11896 }
11897
11898 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11899
11900 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);
11901
11902 hashes_cnt++;
11903
11904 // show / left
11905
11906 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);
11907 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);
11908 }
11909 else
11910 {
11911 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11912
11913 if (parser_status < PARSER_GLOBAL_ZERO)
11914 {
11915 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11916
11917 continue;
11918 }
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 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11923 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11924
11925 hashes_cnt++;
11926 }
11927 }
11928 else
11929 {
11930 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11931
11932 if (parser_status < PARSER_GLOBAL_ZERO)
11933 {
11934 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11935
11936 continue;
11937 }
11938
11939 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);
11940
11941 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11942 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11943
11944 hashes_cnt++;
11945 }
11946 }
11947
11948 myfree (line_buf);
11949
11950 fclose (fp);
11951
11952 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11953
11954 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11955 }
11956 }
11957 else
11958 {
11959 if (isSalted)
11960 {
11961 hashes_buf[0].salt->salt_len = 8;
11962
11963 // special salt handling
11964
11965 switch (hash_mode)
11966 {
11967 case 1500: hashes_buf[0].salt->salt_len = 2;
11968 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11969 break;
11970 case 1731: hashes_buf[0].salt->salt_len = 4;
11971 break;
11972 case 2410: hashes_buf[0].salt->salt_len = 4;
11973 break;
11974 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11975 break;
11976 case 3100: hashes_buf[0].salt->salt_len = 1;
11977 break;
11978 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11979 break;
11980 case 5800: hashes_buf[0].salt->salt_len = 16;
11981 break;
11982 case 6800: hashes_buf[0].salt->salt_len = 32;
11983 break;
11984 case 8400: hashes_buf[0].salt->salt_len = 40;
11985 break;
11986 case 8800: hashes_buf[0].salt->salt_len = 16;
11987 break;
11988 case 8900: hashes_buf[0].salt->salt_len = 16;
11989 hashes_buf[0].salt->scrypt_N = 1024;
11990 hashes_buf[0].salt->scrypt_r = 1;
11991 hashes_buf[0].salt->scrypt_p = 1;
11992 break;
11993 case 9100: hashes_buf[0].salt->salt_len = 16;
11994 break;
11995 case 9300: hashes_buf[0].salt->salt_len = 14;
11996 hashes_buf[0].salt->scrypt_N = 16384;
11997 hashes_buf[0].salt->scrypt_r = 1;
11998 hashes_buf[0].salt->scrypt_p = 1;
11999 break;
12000 case 9400: hashes_buf[0].salt->salt_len = 16;
12001 break;
12002 case 9500: hashes_buf[0].salt->salt_len = 16;
12003 break;
12004 case 9600: hashes_buf[0].salt->salt_len = 16;
12005 break;
12006 case 9700: hashes_buf[0].salt->salt_len = 16;
12007 break;
12008 case 9710: hashes_buf[0].salt->salt_len = 16;
12009 break;
12010 case 9720: hashes_buf[0].salt->salt_len = 16;
12011 break;
12012 case 9800: hashes_buf[0].salt->salt_len = 16;
12013 break;
12014 case 9810: hashes_buf[0].salt->salt_len = 16;
12015 break;
12016 case 9820: hashes_buf[0].salt->salt_len = 16;
12017 break;
12018 case 10300: hashes_buf[0].salt->salt_len = 12;
12019 break;
12020 case 11500: hashes_buf[0].salt->salt_len = 4;
12021 break;
12022 case 11600: hashes_buf[0].salt->salt_len = 4;
12023 break;
12024 case 12400: hashes_buf[0].salt->salt_len = 4;
12025 break;
12026 case 12500: hashes_buf[0].salt->salt_len = 8;
12027 break;
12028 case 12600: hashes_buf[0].salt->salt_len = 64;
12029 break;
12030 }
12031
12032 // special esalt handling
12033
12034 switch (hash_mode)
12035 {
12036 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12037 break;
12038 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12039 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12040 break;
12041 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12042 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12043 break;
12044 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12045 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12046 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12047 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12048 break;
12049 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12050 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12051 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12052 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12053 break;
12054 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12055 break;
12056 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12057 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12058 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12059 break;
12060 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12061 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12062 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12063 break;
12064 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12065 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12066 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12067 break;
12068 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12069 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12070 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12071 break;
12072 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12073 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12074 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12075 break;
12076 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12077 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12078 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12079 break;
12080 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12081 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12082 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12083 break;
12084 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12085 break;
12086 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12087 break;
12088 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12089 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12090 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12091 break;
12092 }
12093 }
12094
12095 // set hashfile
12096
12097 switch (hash_mode)
12098 {
12099 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12100 break;
12101 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12102 break;
12103 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12104 break;
12105 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12106 break;
12107 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12108 break;
12109 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12110 break;
12111 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12112 break;
12113 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12114 break;
12115 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12116 break;
12117 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12118 break;
12119 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12120 break;
12121 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12122 break;
12123 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12124 break;
12125 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12126 break;
12127 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12128 break;
12129 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12130 break;
12131 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12132 break;
12133 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12134 break;
12135 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12136 break;
12137 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12138 break;
12139 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12140 break;
12141 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12142 break;
12143 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12144 break;
12145 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12146 break;
12147 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12148 break;
12149 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12150 break;
12151 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12152 break;
12153 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12154 break;
12155 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12156 break;
12157 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12158 break;
12159 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12160 break;
12161 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12162 break;
12163 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12164 break;
12165 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12166 break;
12167 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12168 break;
12169 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12170 break;
12171 }
12172
12173 // set default iterations
12174
12175 switch (hash_mode)
12176 {
12177 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12178 break;
12179 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12180 break;
12181 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12182 break;
12183 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12184 break;
12185 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12186 break;
12187 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12188 break;
12189 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12190 break;
12191 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12192 break;
12193 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12194 break;
12195 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12196 break;
12197 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12198 break;
12199 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12200 break;
12201 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12202 break;
12203 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12204 break;
12205 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12206 break;
12207 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12208 break;
12209 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12210 break;
12211 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12212 break;
12213 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12214 break;
12215 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12216 break;
12217 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12218 break;
12219 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12220 break;
12221 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12222 break;
12223 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12224 break;
12225 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12226 break;
12227 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12228 break;
12229 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12230 break;
12231 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12232 break;
12233 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12234 break;
12235 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12236 break;
12237 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12238 break;
12239 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12240 break;
12241 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12242 break;
12243 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12244 break;
12245 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12246 break;
12247 case 8900: hashes_buf[0].salt->salt_iter = 1;
12248 break;
12249 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12250 break;
12251 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12252 break;
12253 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12254 break;
12255 case 9300: hashes_buf[0].salt->salt_iter = 1;
12256 break;
12257 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12258 break;
12259 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12260 break;
12261 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12262 break;
12263 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12264 break;
12265 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12266 break;
12267 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12268 break;
12269 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12270 break;
12271 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12272 break;
12273 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12274 break;
12275 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12276 break;
12277 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12278 break;
12279 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12280 break;
12281 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12282 break;
12283 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12284 break;
12285 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12286 break;
12287 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12288 break;
12289 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12290 break;
12291 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12292 break;
12293 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12294 break;
12295 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12296 break;
12297 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12298 break;
12299 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12300 break;
12301 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12302 break;
12303 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12304 break;
12305 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12306 break;
12307 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12308 break;
12309 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12310 break;
12311 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12312 break;
12313 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12314 break;
12315 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12316 break;
12317 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12318 break;
12319 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12320 break;
12321 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12322 break;
12323 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12324 break;
12325 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12326 break;
12327 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12328 break;
12329 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12330 break;
12331 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12332 break;
12333 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12334 break;
12335 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12336 break;
12337 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12338 break;
12339 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12340 break;
12341 }
12342
12343 hashes_cnt = 1;
12344 }
12345
12346 if (show == 1 || left == 1)
12347 {
12348 for (uint i = 0; i < pot_cnt; i++)
12349 {
12350 pot_t *pot_ptr = &pot[i];
12351
12352 hash_t *hashes_buf = &pot_ptr->hash;
12353
12354 local_free (hashes_buf->digest);
12355
12356 if (isSalted)
12357 {
12358 local_free (hashes_buf->salt);
12359 }
12360 }
12361
12362 local_free (pot);
12363
12364 if (data.quiet == 0) log_info_nn ("");
12365
12366 return (0);
12367 }
12368
12369 if (keyspace == 0)
12370 {
12371 if (hashes_cnt == 0)
12372 {
12373 log_error ("ERROR: No hashes loaded");
12374
12375 return (-1);
12376 }
12377 }
12378
12379 /**
12380 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12381 */
12382
12383 if (data.outfile != NULL)
12384 {
12385 if (data.hashfile != NULL)
12386 {
12387 #ifdef _POSIX
12388 struct stat tmpstat_outfile;
12389 struct stat tmpstat_hashfile;
12390 #endif
12391
12392 #ifdef _WIN
12393 struct stat64 tmpstat_outfile;
12394 struct stat64 tmpstat_hashfile;
12395 #endif
12396
12397 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12398
12399 if (tmp_outfile_fp)
12400 {
12401 #ifdef _POSIX
12402 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12403 #endif
12404
12405 #ifdef _WIN
12406 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12407 #endif
12408
12409 fclose (tmp_outfile_fp);
12410 }
12411
12412 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12413
12414 if (tmp_hashfile_fp)
12415 {
12416 #ifdef _POSIX
12417 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12418 #endif
12419
12420 #ifdef _WIN
12421 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12422 #endif
12423
12424 fclose (tmp_hashfile_fp);
12425 }
12426
12427 if (tmp_outfile_fp && tmp_outfile_fp)
12428 {
12429 tmpstat_outfile.st_mode = 0;
12430 tmpstat_outfile.st_nlink = 0;
12431 tmpstat_outfile.st_uid = 0;
12432 tmpstat_outfile.st_gid = 0;
12433 tmpstat_outfile.st_rdev = 0;
12434 tmpstat_outfile.st_atime = 0;
12435
12436 tmpstat_hashfile.st_mode = 0;
12437 tmpstat_hashfile.st_nlink = 0;
12438 tmpstat_hashfile.st_uid = 0;
12439 tmpstat_hashfile.st_gid = 0;
12440 tmpstat_hashfile.st_rdev = 0;
12441 tmpstat_hashfile.st_atime = 0;
12442
12443 #ifdef _POSIX
12444 tmpstat_outfile.st_blksize = 0;
12445 tmpstat_outfile.st_blocks = 0;
12446
12447 tmpstat_hashfile.st_blksize = 0;
12448 tmpstat_hashfile.st_blocks = 0;
12449 #endif
12450
12451 #ifdef _POSIX
12452 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12453 {
12454 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12455
12456 return (-1);
12457 }
12458 #endif
12459
12460 #ifdef _WIN
12461 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12462 {
12463 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12464
12465 return (-1);
12466 }
12467 #endif
12468 }
12469 }
12470 }
12471
12472 /**
12473 * Remove duplicates
12474 */
12475
12476 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12477
12478 if (isSalted)
12479 {
12480 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12481 }
12482 else
12483 {
12484 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12485 }
12486
12487 uint hashes_cnt_orig = hashes_cnt;
12488
12489 hashes_cnt = 1;
12490
12491 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12492 {
12493 if (isSalted)
12494 {
12495 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12496 {
12497 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12498 }
12499 }
12500 else
12501 {
12502 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12503 }
12504
12505 if (hashes_pos > hashes_cnt)
12506 {
12507 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12508 }
12509
12510 hashes_cnt++;
12511 }
12512
12513 /**
12514 * Potfile removes
12515 */
12516
12517 uint potfile_remove_cracks = 0;
12518
12519 if (potfile_disable == 0)
12520 {
12521 hash_t hash_buf;
12522
12523 hash_buf.digest = mymalloc (dgst_size);
12524 hash_buf.salt = NULL;
12525 hash_buf.esalt = NULL;
12526 hash_buf.hash_info = NULL;
12527 hash_buf.cracked = 0;
12528
12529 if (isSalted)
12530 {
12531 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12532 }
12533
12534 if (esalt_size)
12535 {
12536 hash_buf.esalt = mymalloc (esalt_size);
12537 }
12538
12539 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12540
12541 // no solution for these special hash types (for instane because they use hashfile in output etc)
12542 if ((hash_mode != 5200) &&
12543 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12544 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12545 (hash_mode != 9000))
12546 {
12547 FILE *fp = fopen (potfile, "rb");
12548
12549 if (fp != NULL)
12550 {
12551 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12552
12553 // to be safe work with a copy (because of line_len loop, i etc)
12554 // moved up here because it's easier to handle continue case
12555 // it's just 64kb
12556
12557 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12558
12559 while (!feof (fp))
12560 {
12561 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12562
12563 if (ptr == NULL) break;
12564
12565 int line_len = strlen (line_buf);
12566
12567 if (line_len == 0) continue;
12568
12569 int iter = MAX_CUT_TRIES;
12570
12571 for (int i = line_len - 1; i && iter; i--, line_len--)
12572 {
12573 if (line_buf[i] != ':') continue;
12574
12575 if (isSalted)
12576 {
12577 memset (hash_buf.salt, 0, sizeof (salt_t));
12578 }
12579
12580 hash_t *found = NULL;
12581
12582 if (hash_mode == 6800)
12583 {
12584 if (i < 64) // 64 = 16 * uint in salt_buf[]
12585 {
12586 // manipulate salt_buf
12587 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12588
12589 hash_buf.salt->salt_len = i;
12590
12591 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12592 }
12593 }
12594 else if (hash_mode == 2500)
12595 {
12596 if (i < 64) // 64 = 16 * uint in salt_buf[]
12597 {
12598 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12599 // manipulate salt_buf
12600
12601 memcpy (line_buf_cpy, line_buf, i);
12602
12603 char *mac2_pos = strrchr (line_buf_cpy, ':');
12604
12605 if (mac2_pos == NULL) continue;
12606
12607 mac2_pos[0] = 0;
12608 mac2_pos++;
12609
12610 if (strlen (mac2_pos) != 12) continue;
12611
12612 char *mac1_pos = strrchr (line_buf_cpy, ':');
12613
12614 if (mac1_pos == NULL) continue;
12615
12616 mac1_pos[0] = 0;
12617 mac1_pos++;
12618
12619 if (strlen (mac1_pos) != 12) continue;
12620
12621 uint essid_length = mac1_pos - line_buf_cpy - 1;
12622
12623 // here we need the ESSID
12624 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12625
12626 hash_buf.salt->salt_len = essid_length;
12627
12628 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12629
12630 if (found)
12631 {
12632 wpa_t *wpa = (wpa_t *) found->esalt;
12633
12634 // compare hex string(s) vs binary MAC address(es)
12635
12636 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12637 {
12638 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12639 {
12640 found = NULL;
12641
12642 break;
12643 }
12644 }
12645
12646 // early skip ;)
12647 if (!found) continue;
12648
12649 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12650 {
12651 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12652 {
12653 found = NULL;
12654
12655 break;
12656 }
12657 }
12658 }
12659 }
12660 }
12661 else
12662 {
12663 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12664
12665 if (parser_status == PARSER_OK)
12666 {
12667 if (isSalted)
12668 {
12669 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12670 }
12671 else
12672 {
12673 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12674 }
12675 }
12676 }
12677
12678 if (found == NULL) continue;
12679
12680 if (!found->cracked) potfile_remove_cracks++;
12681
12682 found->cracked = 1;
12683
12684 if (found) break;
12685
12686 iter--;
12687 }
12688 }
12689
12690 myfree (line_buf_cpy);
12691
12692 myfree (line_buf);
12693
12694 fclose (fp);
12695 }
12696 }
12697
12698 if (esalt_size)
12699 {
12700 local_free (hash_buf.esalt);
12701 }
12702
12703 if (isSalted)
12704 {
12705 local_free (hash_buf.salt);
12706 }
12707
12708 local_free (hash_buf.digest);
12709 }
12710
12711 /**
12712 * Now generate all the buffers required for later
12713 */
12714
12715 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12716
12717 salt_t *salts_buf_new = NULL;
12718 void *esalts_buf_new = NULL;
12719
12720 if (isSalted)
12721 {
12722 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12723
12724 if (esalt_size)
12725 {
12726 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12727 }
12728 }
12729 else
12730 {
12731 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12732 }
12733
12734 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12735
12736 uint digests_cnt = hashes_cnt;
12737 uint digests_done = 0;
12738
12739 size_t size_digests = digests_cnt * dgst_size;
12740 size_t size_shown = digests_cnt * sizeof (uint);
12741
12742 uint *digests_shown = (uint *) mymalloc (size_shown);
12743 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12744
12745 uint salts_cnt = 0;
12746 uint salts_done = 0;
12747
12748 hashinfo_t **hash_info = NULL;
12749
12750 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12751 {
12752 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12753
12754 if (username && (remove || show))
12755 {
12756 uint user_pos;
12757
12758 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12759 {
12760 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12761
12762 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12763 }
12764 }
12765 }
12766
12767 uint *salts_shown = (uint *) mymalloc (size_shown);
12768
12769 salt_t *salt_buf;
12770
12771 {
12772 // copied from inner loop
12773
12774 salt_buf = &salts_buf_new[salts_cnt];
12775
12776 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12777
12778 if (esalt_size)
12779 {
12780 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12781 }
12782
12783 salt_buf->digests_cnt = 0;
12784 salt_buf->digests_done = 0;
12785 salt_buf->digests_offset = 0;
12786
12787 salts_cnt++;
12788 }
12789
12790 if (hashes_buf[0].cracked == 1)
12791 {
12792 digests_shown[0] = 1;
12793
12794 digests_done++;
12795
12796 salt_buf->digests_done++;
12797 }
12798
12799 salt_buf->digests_cnt++;
12800
12801 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12802
12803 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12804 {
12805 hash_info[0] = hashes_buf[0].hash_info;
12806 }
12807
12808 // copy from inner loop
12809
12810 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12811 {
12812 if (isSalted)
12813 {
12814 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12815 {
12816 salt_buf = &salts_buf_new[salts_cnt];
12817
12818 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12819
12820 if (esalt_size)
12821 {
12822 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12823 }
12824
12825 salt_buf->digests_cnt = 0;
12826 salt_buf->digests_done = 0;
12827 salt_buf->digests_offset = hashes_pos;
12828
12829 salts_cnt++;
12830 }
12831 }
12832
12833 if (hashes_buf[hashes_pos].cracked == 1)
12834 {
12835 digests_shown[hashes_pos] = 1;
12836
12837 digests_done++;
12838
12839 salt_buf->digests_done++;
12840 }
12841
12842 salt_buf->digests_cnt++;
12843
12844 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12845
12846 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12847 {
12848 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12849 }
12850 }
12851
12852 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12853 {
12854 salt_t *salt_buf = &salts_buf_new[salt_pos];
12855
12856 if (salt_buf->digests_done == salt_buf->digests_cnt)
12857 {
12858 salts_shown[salt_pos] = 1;
12859
12860 salts_done++;
12861 }
12862
12863 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12864 }
12865
12866 local_free (digests_buf);
12867 local_free (salts_buf);
12868 local_free (esalts_buf);
12869
12870 digests_buf = digests_buf_new;
12871 salts_buf = salts_buf_new;
12872 esalts_buf = esalts_buf_new;
12873
12874 local_free (hashes_buf);
12875
12876 /**
12877 * special modification not set from parser
12878 */
12879
12880 switch (hash_mode)
12881 {
12882 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12883 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12884 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12885 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12886 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12887 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12888 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12889 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12890 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12891 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12892 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12893 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12894 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12895 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12896 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12897 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12898 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12899 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12900 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12901 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12902 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12903 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12904 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12905 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12906 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12907 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12908 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12909 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12910 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12911 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12912 }
12913
12914 if (truecrypt_keyfiles)
12915 {
12916 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12917
12918 char *keyfiles = strdup (truecrypt_keyfiles);
12919
12920 char *keyfile = strtok (keyfiles, ",");
12921
12922 do
12923 {
12924 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12925
12926 } while ((keyfile = strtok (NULL, ",")) != NULL);
12927
12928 free (keyfiles);
12929 }
12930
12931 if (veracrypt_keyfiles)
12932 {
12933 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12934
12935 char *keyfiles = strdup (veracrypt_keyfiles);
12936
12937 char *keyfile = strtok (keyfiles, ",");
12938
12939 do
12940 {
12941 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12942
12943 } while ((keyfile = strtok (NULL, ",")) != NULL);
12944
12945 free (keyfiles);
12946 }
12947
12948 data.digests_cnt = digests_cnt;
12949 data.digests_done = digests_done;
12950 data.digests_buf = digests_buf;
12951 data.digests_shown = digests_shown;
12952 data.digests_shown_tmp = digests_shown_tmp;
12953
12954 data.salts_cnt = salts_cnt;
12955 data.salts_done = salts_done;
12956 data.salts_buf = salts_buf;
12957 data.salts_shown = salts_shown;
12958
12959 data.esalts_buf = esalts_buf;
12960 data.hash_info = hash_info;
12961
12962 /**
12963 * Automatic Optimizers
12964 */
12965
12966 if (salts_cnt == 1)
12967 opti_type |= OPTI_TYPE_SINGLE_SALT;
12968
12969 if (digests_cnt == 1)
12970 opti_type |= OPTI_TYPE_SINGLE_HASH;
12971
12972 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12973 opti_type |= OPTI_TYPE_NOT_ITERATED;
12974
12975 if (attack_mode == ATTACK_MODE_BF)
12976 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12977
12978 data.opti_type = opti_type;
12979
12980 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12981 {
12982 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12983 {
12984 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12985 {
12986 if (opts_type & OPTS_TYPE_ST_ADD80)
12987 {
12988 opts_type &= ~OPTS_TYPE_ST_ADD80;
12989 opts_type |= OPTS_TYPE_PT_ADD80;
12990 }
12991
12992 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12993 {
12994 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12995 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12996 }
12997
12998 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12999 {
13000 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13001 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13002 }
13003 }
13004 }
13005 }
13006
13007 /**
13008 * Some algorithm, like descrypt, can benefit from JIT compilation
13009 */
13010
13011 int force_jit_compilation = -1;
13012
13013 if (hash_mode == 8900)
13014 {
13015 force_jit_compilation = 8900;
13016 }
13017 else if (hash_mode == 9300)
13018 {
13019 force_jit_compilation = 8900;
13020 }
13021 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13022 {
13023 force_jit_compilation = 1500;
13024 }
13025
13026 /**
13027 * generate bitmap tables
13028 */
13029
13030 const uint bitmap_shift1 = 5;
13031 const uint bitmap_shift2 = 13;
13032
13033 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13034
13035 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13036 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13037 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13038 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13039 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13040 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13041 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13042 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13043
13044 uint bitmap_bits;
13045 uint bitmap_nums;
13046 uint bitmap_mask;
13047 uint bitmap_size;
13048
13049 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13050 {
13051 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13052
13053 bitmap_nums = 1 << bitmap_bits;
13054
13055 bitmap_mask = bitmap_nums - 1;
13056
13057 bitmap_size = bitmap_nums * sizeof (uint);
13058
13059 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13060
13061 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;
13062 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;
13063
13064 break;
13065 }
13066
13067 bitmap_nums = 1 << bitmap_bits;
13068
13069 bitmap_mask = bitmap_nums - 1;
13070
13071 bitmap_size = bitmap_nums * sizeof (uint);
13072
13073 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);
13074 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);
13075
13076 /**
13077 * prepare quick rule
13078 */
13079
13080 data.rule_buf_l = rule_buf_l;
13081 data.rule_buf_r = rule_buf_r;
13082
13083 int rule_len_l = (int) strlen (rule_buf_l);
13084 int rule_len_r = (int) strlen (rule_buf_r);
13085
13086 data.rule_len_l = rule_len_l;
13087 data.rule_len_r = rule_len_r;
13088
13089 /**
13090 * load rules
13091 */
13092
13093 uint *all_kernel_rules_cnt = NULL;
13094
13095 kernel_rule_t **all_kernel_rules_buf = NULL;
13096
13097 if (rp_files_cnt)
13098 {
13099 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13100
13101 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13102 }
13103
13104 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13105
13106 int rule_len = 0;
13107
13108 for (uint i = 0; i < rp_files_cnt; i++)
13109 {
13110 uint kernel_rules_avail = 0;
13111
13112 uint kernel_rules_cnt = 0;
13113
13114 kernel_rule_t *kernel_rules_buf = NULL;
13115
13116 char *rp_file = rp_files[i];
13117
13118 char in[BLOCK_SIZE] = { 0 };
13119 char out[BLOCK_SIZE] = { 0 };
13120
13121 FILE *fp = NULL;
13122
13123 uint rule_line = 0;
13124
13125 if ((fp = fopen (rp_file, "rb")) == NULL)
13126 {
13127 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13128
13129 return (-1);
13130 }
13131
13132 while (!feof (fp))
13133 {
13134 memset (rule_buf, 0, HCBUFSIZ);
13135
13136 rule_len = fgetl (fp, rule_buf);
13137
13138 rule_line++;
13139
13140 if (rule_len == 0) continue;
13141
13142 if (rule_buf[0] == '#') continue;
13143
13144 if (kernel_rules_avail == kernel_rules_cnt)
13145 {
13146 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13147
13148 kernel_rules_avail += INCR_RULES;
13149 }
13150
13151 memset (in, 0, BLOCK_SIZE);
13152 memset (out, 0, BLOCK_SIZE);
13153
13154 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13155
13156 if (result == -1)
13157 {
13158 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13159
13160 continue;
13161 }
13162
13163 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13164 {
13165 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13166
13167 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13168
13169 continue;
13170 }
13171
13172 /* its so slow
13173 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13174 {
13175 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13176
13177 continue;
13178 }
13179 */
13180
13181 kernel_rules_cnt++;
13182 }
13183
13184 fclose (fp);
13185
13186 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13187
13188 all_kernel_rules_buf[i] = kernel_rules_buf;
13189 }
13190
13191 /**
13192 * merge rules or automatic rule generator
13193 */
13194
13195 uint kernel_rules_cnt = 0;
13196
13197 kernel_rule_t *kernel_rules_buf = NULL;
13198
13199 if (attack_mode == ATTACK_MODE_STRAIGHT)
13200 {
13201 if (rp_files_cnt)
13202 {
13203 kernel_rules_cnt = 1;
13204
13205 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13206
13207 repeats[0] = kernel_rules_cnt;
13208
13209 for (uint i = 0; i < rp_files_cnt; i++)
13210 {
13211 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13212
13213 repeats[i + 1] = kernel_rules_cnt;
13214 }
13215
13216 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13217
13218 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13219
13220 for (uint i = 0; i < kernel_rules_cnt; i++)
13221 {
13222 uint out_pos = 0;
13223
13224 kernel_rule_t *out = &kernel_rules_buf[i];
13225
13226 for (uint j = 0; j < rp_files_cnt; j++)
13227 {
13228 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13229 uint in_pos;
13230
13231 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13232
13233 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13234 {
13235 if (out_pos == RULES_MAX - 1)
13236 {
13237 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13238
13239 break;
13240 }
13241
13242 out->cmds[out_pos] = in->cmds[in_pos];
13243 }
13244 }
13245 }
13246
13247 local_free (repeats);
13248 }
13249 else if (rp_gen)
13250 {
13251 uint kernel_rules_avail = 0;
13252
13253 while (kernel_rules_cnt < rp_gen)
13254 {
13255 if (kernel_rules_avail == kernel_rules_cnt)
13256 {
13257 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13258
13259 kernel_rules_avail += INCR_RULES;
13260 }
13261
13262 memset (rule_buf, 0, HCBUFSIZ);
13263
13264 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13265
13266 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13267
13268 kernel_rules_cnt++;
13269 }
13270 }
13271 }
13272
13273 myfree (rule_buf);
13274
13275 /**
13276 * generate NOP rules
13277 */
13278
13279 if (kernel_rules_cnt == 0)
13280 {
13281 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13282
13283 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13284
13285 kernel_rules_cnt++;
13286 }
13287
13288 data.kernel_rules_cnt = kernel_rules_cnt;
13289 data.kernel_rules_buf = kernel_rules_buf;
13290
13291 /**
13292 * OpenCL platforms: detect
13293 */
13294
13295 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13296 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13297
13298 cl_uint platforms_cnt = 0;
13299 cl_uint platform_devices_cnt = 0;
13300
13301 if (keyspace == 0)
13302 {
13303 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13304
13305 if (platforms_cnt == 0)
13306 {
13307 log_info ("");
13308 log_info ("ATTENTION! No OpenCL compatible platform found");
13309 log_info ("");
13310 log_info ("You're probably missing the OpenCL runtime installation");
13311 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13312 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13313 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13314 log_info ("");
13315
13316 return (-1);
13317 }
13318
13319 if (opencl_platforms_filter != (uint) -1)
13320 {
13321 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13322
13323 if (opencl_platforms_filter > platform_cnt_mask)
13324 {
13325 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13326
13327 return (-1);
13328 }
13329 }
13330 }
13331
13332 /**
13333 * OpenCL device types:
13334 * 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.
13335 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13336 */
13337
13338 if (opencl_device_types == NULL)
13339 {
13340 cl_device_type device_types_all = 0;
13341
13342 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13343 {
13344 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13345
13346 cl_platform_id platform = platforms[platform_id];
13347
13348 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13349
13350 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13351 {
13352 cl_device_id device = platform_devices[platform_devices_id];
13353
13354 cl_device_type device_type;
13355
13356 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13357
13358 device_types_all |= device_type;
13359 }
13360 }
13361
13362 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13363 {
13364 device_types_filter |= CL_DEVICE_TYPE_CPU;
13365 }
13366 }
13367
13368 /**
13369 * OpenCL devices: simply push all devices from all platforms into the same device array
13370 */
13371
13372 int need_adl = 0;
13373 int need_nvapi = 0;
13374 int need_nvml = 0;
13375
13376 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13377
13378 data.devices_param = devices_param;
13379
13380 uint devices_cnt = 0;
13381
13382 uint devices_active = 0;
13383
13384 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13385 {
13386 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13387
13388 cl_platform_id platform = platforms[platform_id];
13389
13390 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13391
13392 char platform_vendor[INFOSZ] = { 0 };
13393
13394 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13395
13396 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13397 // this causes trouble with vendor id based macros
13398 // we'll assign generic to those without special optimization available
13399
13400 cl_uint platform_vendor_id = 0;
13401
13402 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13403 {
13404 platform_vendor_id = VENDOR_ID_AMD;
13405 }
13406 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13407 {
13408 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13409 }
13410 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13411 {
13412 platform_vendor_id = VENDOR_ID_APPLE;
13413 }
13414 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13415 {
13416 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13417 }
13418 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13419 {
13420 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13421 }
13422 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13423 {
13424 platform_vendor_id = VENDOR_ID_MESA;
13425 }
13426 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13427 {
13428 platform_vendor_id = VENDOR_ID_NV;
13429 }
13430 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13431 {
13432 platform_vendor_id = VENDOR_ID_POCL;
13433 }
13434 else
13435 {
13436 platform_vendor_id = VENDOR_ID_GENERIC;
13437 }
13438
13439 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13440 {
13441 size_t param_value_size = 0;
13442
13443 const uint device_id = devices_cnt;
13444
13445 hc_device_param_t *device_param = &data.devices_param[device_id];
13446
13447 device_param->platform_vendor_id = platform_vendor_id;
13448
13449 device_param->device = platform_devices[platform_devices_id];
13450
13451 device_param->device_id = device_id;
13452
13453 device_param->platform_devices_id = platform_devices_id;
13454
13455 // device_type
13456
13457 cl_device_type device_type;
13458
13459 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13460
13461 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13462
13463 device_param->device_type = device_type;
13464
13465 // device_name
13466
13467 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13468
13469 char *device_name = (char *) mymalloc (param_value_size);
13470
13471 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13472
13473 device_param->device_name = device_name;
13474
13475 // device_vendor
13476
13477 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13478
13479 char *device_vendor = (char *) mymalloc (param_value_size);
13480
13481 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13482
13483 device_param->device_vendor = device_vendor;
13484
13485 cl_uint device_vendor_id = 0;
13486
13487 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13488 {
13489 device_vendor_id = VENDOR_ID_AMD;
13490 }
13491 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13492 {
13493 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13494 }
13495 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13496 {
13497 device_vendor_id = VENDOR_ID_APPLE;
13498 }
13499 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13500 {
13501 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13502 }
13503 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13504 {
13505 device_vendor_id = VENDOR_ID_INTEL_SDK;
13506 }
13507 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13508 {
13509 device_vendor_id = VENDOR_ID_MESA;
13510 }
13511 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13512 {
13513 device_vendor_id = VENDOR_ID_NV;
13514 }
13515 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13516 {
13517 device_vendor_id = VENDOR_ID_POCL;
13518 }
13519 else
13520 {
13521 device_vendor_id = VENDOR_ID_GENERIC;
13522 }
13523
13524 device_param->device_vendor_id = device_vendor_id;
13525
13526 // tuning db
13527
13528 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13529
13530 // device_version
13531
13532 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13533
13534 char *device_version = (char *) mymalloc (param_value_size);
13535
13536 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13537
13538 device_param->device_version = device_version;
13539
13540 // device_opencl_version
13541
13542 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13543
13544 char *device_opencl_version = (char *) mymalloc (param_value_size);
13545
13546 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13547
13548 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13549
13550 myfree (device_opencl_version);
13551
13552 // vector_width
13553
13554 cl_uint vector_width;
13555
13556 if (opencl_vector_width_chgd == 0)
13557 {
13558 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13559 {
13560 if (opti_type & OPTI_TYPE_USES_BITS_64)
13561 {
13562 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13563 }
13564 else
13565 {
13566 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13567 }
13568 }
13569 else
13570 {
13571 vector_width = (cl_uint) tuningdb_entry->vector_width;
13572 }
13573 }
13574 else
13575 {
13576 vector_width = opencl_vector_width;
13577 }
13578
13579 if (vector_width > 16) vector_width = 16;
13580
13581 device_param->vector_width = vector_width;
13582
13583 // max_compute_units
13584
13585 cl_uint device_processors;
13586
13587 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13588
13589 device_param->device_processors = device_processors;
13590
13591 // device_maxmem_alloc
13592 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13593
13594 cl_ulong device_maxmem_alloc;
13595
13596 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13597
13598 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13599
13600 // device_global_mem
13601
13602 cl_ulong device_global_mem;
13603
13604 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13605
13606 device_param->device_global_mem = device_global_mem;
13607
13608 // max_work_group_size
13609
13610 size_t device_maxworkgroup_size;
13611
13612 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13613
13614 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13615
13616 // max_clock_frequency
13617
13618 cl_uint device_maxclock_frequency;
13619
13620 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13621
13622 device_param->device_maxclock_frequency = device_maxclock_frequency;
13623
13624 // device_endian_little
13625
13626 cl_bool device_endian_little;
13627
13628 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13629
13630 if (device_endian_little == CL_FALSE)
13631 {
13632 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13633
13634 device_param->skipped = 1;
13635 }
13636
13637 // device_available
13638
13639 cl_bool device_available;
13640
13641 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13642
13643 if (device_available == CL_FALSE)
13644 {
13645 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13646
13647 device_param->skipped = 1;
13648 }
13649
13650 // device_compiler_available
13651
13652 cl_bool device_compiler_available;
13653
13654 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13655
13656 if (device_compiler_available == CL_FALSE)
13657 {
13658 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13659
13660 device_param->skipped = 1;
13661 }
13662
13663 // device_execution_capabilities
13664
13665 cl_device_exec_capabilities device_execution_capabilities;
13666
13667 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13668
13669 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13670 {
13671 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13672
13673 device_param->skipped = 1;
13674 }
13675
13676 // device_extensions
13677
13678 size_t device_extensions_size;
13679
13680 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13681
13682 char *device_extensions = mymalloc (device_extensions_size + 1);
13683
13684 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13685
13686 if (strstr (device_extensions, "base_atomics") == 0)
13687 {
13688 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13689
13690 device_param->skipped = 1;
13691 }
13692
13693 if (strstr (device_extensions, "byte_addressable_store") == 0)
13694 {
13695 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13696
13697 device_param->skipped = 1;
13698 }
13699
13700 myfree (device_extensions);
13701
13702 // device_local_mem_size
13703
13704 cl_ulong device_local_mem_size;
13705
13706 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13707
13708 if (device_local_mem_size < 32768)
13709 {
13710 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13711
13712 device_param->skipped = 1;
13713 }
13714
13715 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13716 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13717 // This results in both utilizing it for 50%
13718 // However, Intel has much better SIMD control over their own hardware
13719 // It makes sense to give them full control over their own hardware
13720
13721 if (device_type & CL_DEVICE_TYPE_CPU)
13722 {
13723 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13724 {
13725 if (data.force == 0)
13726 {
13727 if (algorithm_pos == 0)
13728 {
13729 log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
13730 log_info (" You can use --force to override this but do not post error reports if you do so");
13731 }
13732
13733 device_param->skipped = 1;
13734 }
13735 }
13736 }
13737
13738 // skipped
13739
13740 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13741 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13742
13743 // driver_version
13744
13745 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13746
13747 char *driver_version = (char *) mymalloc (param_value_size);
13748
13749 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13750
13751 device_param->driver_version = driver_version;
13752
13753 // device_name_chksum
13754
13755 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13756
13757 #if __x86_64__
13758 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);
13759 #else
13760 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);
13761 #endif
13762
13763 uint device_name_digest[4] = { 0 };
13764
13765 md5_64 ((uint *) device_name_chksum, device_name_digest);
13766
13767 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13768
13769 device_param->device_name_chksum = device_name_chksum;
13770
13771 // device_processor_cores
13772
13773 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
13774 {
13775 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
13776 {
13777 need_adl = 1;
13778 }
13779
13780 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
13781 {
13782 need_nvml = 1;
13783
13784 #ifdef _WIN
13785 need_nvapi = 1;
13786 #endif
13787 }
13788 }
13789
13790 // device_processor_cores
13791
13792 if (device_type & CL_DEVICE_TYPE_CPU)
13793 {
13794 cl_uint device_processor_cores = 1;
13795
13796 device_param->device_processor_cores = device_processor_cores;
13797 }
13798
13799 if (device_type & CL_DEVICE_TYPE_GPU)
13800 {
13801 if (device_vendor_id == VENDOR_ID_AMD)
13802 {
13803 cl_uint device_processor_cores = 0;
13804
13805 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13806
13807 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13808
13809 device_param->device_processor_cores = device_processor_cores;
13810 }
13811 else if (device_vendor_id == VENDOR_ID_NV)
13812 {
13813 cl_uint kernel_exec_timeout = 0;
13814
13815 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13816
13817 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13818
13819 device_param->kernel_exec_timeout = kernel_exec_timeout;
13820
13821 cl_uint device_processor_cores = 0;
13822
13823 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13824
13825 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13826
13827 device_param->device_processor_cores = device_processor_cores;
13828
13829 cl_uint sm_minor = 0;
13830 cl_uint sm_major = 0;
13831
13832 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13833 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13834
13835 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13836 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13837
13838 device_param->sm_minor = sm_minor;
13839 device_param->sm_major = sm_major;
13840 }
13841 else
13842 {
13843 cl_uint device_processor_cores = 1;
13844
13845 device_param->device_processor_cores = device_processor_cores;
13846 }
13847 }
13848
13849 // display results
13850
13851 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13852 {
13853 if (machine_readable == 0)
13854 {
13855 if (device_param->skipped == 0)
13856 {
13857 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13858 device_id + 1,
13859 device_name,
13860 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13861 (unsigned int) (device_global_mem / 1024 / 1024),
13862 (unsigned int) device_processors);
13863 }
13864 else
13865 {
13866 log_info ("Device #%u: %s, skipped",
13867 device_id + 1,
13868 device_name);
13869 }
13870 }
13871 }
13872
13873 // common driver check
13874
13875 if (device_param->skipped == 0)
13876 {
13877 if (device_type & CL_DEVICE_TYPE_GPU)
13878 {
13879 if (platform_vendor_id == VENDOR_ID_AMD)
13880 {
13881 int catalyst_check = (force == 1) ? 0 : 1;
13882
13883 int catalyst_warn = 0;
13884
13885 int catalyst_broken = 0;
13886
13887 if (catalyst_check == 1)
13888 {
13889 catalyst_warn = 1;
13890
13891 // v14.9 and higher
13892 if (atoi (device_param->driver_version) >= 1573)
13893 {
13894 catalyst_warn = 0;
13895 }
13896
13897 catalyst_check = 0;
13898 }
13899
13900 if (catalyst_broken == 1)
13901 {
13902 log_info ("");
13903 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13904 log_info ("It will pass over cracked hashes and does not report them as cracked");
13905 log_info ("You are STRONGLY encouraged not to use it");
13906 log_info ("You can use --force to override this but do not post error reports if you do so");
13907 log_info ("");
13908
13909 return (-1);
13910 }
13911
13912 if (catalyst_warn == 1)
13913 {
13914 log_info ("");
13915 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13916 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13917 log_info ("See hashcat's homepage for official supported catalyst drivers");
13918 #ifdef _WIN
13919 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13920 #endif
13921 log_info ("You can use --force to override this but do not post error reports if you do so");
13922 log_info ("");
13923
13924 return (-1);
13925 }
13926 }
13927 else if (platform_vendor_id == VENDOR_ID_NV)
13928 {
13929 if (device_param->kernel_exec_timeout != 0)
13930 {
13931 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);
13932 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13933 }
13934 }
13935 }
13936
13937 /* turns out pocl still creates segfaults (because of llvm)
13938 if (device_type & CL_DEVICE_TYPE_CPU)
13939 {
13940 if (platform_vendor_id == VENDOR_ID_AMD)
13941 {
13942 if (force == 0)
13943 {
13944 log_info ("");
13945 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13946 log_info ("You are STRONGLY encouraged not to use it");
13947 log_info ("You can use --force to override this but do not post error reports if you do so");
13948 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13949 log_info ("");
13950
13951 return (-1);
13952 }
13953 }
13954 }
13955 */
13956
13957 /**
13958 * kernel accel and loops tuning db adjustment
13959 */
13960
13961 device_param->kernel_accel_min = 1;
13962 device_param->kernel_accel_max = 1024;
13963
13964 device_param->kernel_loops_min = 1;
13965 device_param->kernel_loops_max = 1024;
13966
13967 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13968
13969 if (tuningdb_entry)
13970 {
13971 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13972 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13973
13974 if (_kernel_accel)
13975 {
13976 device_param->kernel_accel_min = _kernel_accel;
13977 device_param->kernel_accel_max = _kernel_accel;
13978 }
13979
13980 if (_kernel_loops)
13981 {
13982 if (workload_profile == 1)
13983 {
13984 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13985 }
13986 else if (workload_profile == 2)
13987 {
13988 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13989 }
13990
13991 device_param->kernel_loops_min = _kernel_loops;
13992 device_param->kernel_loops_max = _kernel_loops;
13993 }
13994 }
13995
13996 // commandline parameters overwrite tuningdb entries
13997
13998 if (kernel_accel)
13999 {
14000 device_param->kernel_accel_min = kernel_accel;
14001 device_param->kernel_accel_max = kernel_accel;
14002 }
14003
14004 if (kernel_loops)
14005 {
14006 device_param->kernel_loops_min = kernel_loops;
14007 device_param->kernel_loops_max = kernel_loops;
14008 }
14009
14010 /**
14011 * activate device
14012 */
14013
14014 devices_active++;
14015 }
14016
14017 // next please
14018
14019 devices_cnt++;
14020 }
14021 }
14022
14023 if (keyspace == 0 && devices_active == 0)
14024 {
14025 log_error ("ERROR: No devices found/left");
14026
14027 return (-1);
14028 }
14029
14030 // 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)
14031
14032 if (devices_filter != (uint) -1)
14033 {
14034 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14035
14036 if (devices_filter > devices_cnt_mask)
14037 {
14038 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14039
14040 return (-1);
14041 }
14042 }
14043
14044 data.devices_cnt = devices_cnt;
14045
14046 data.devices_active = devices_active;
14047
14048 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14049 {
14050 if (machine_readable == 0)
14051 {
14052 log_info ("");
14053 }
14054 }
14055
14056 /**
14057 * HM devices: init
14058 */
14059
14060 #ifdef HAVE_HWMON
14061 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14062 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14063 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14064
14065 if (gpu_temp_disable == 0)
14066 {
14067 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14068 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14069 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14070
14071 data.hm_adl = NULL;
14072 data.hm_nvapi = NULL;
14073 data.hm_nvml = NULL;
14074
14075 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14076 {
14077 data.hm_nvml = nvml;
14078 }
14079
14080 if (data.hm_nvml)
14081 {
14082 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14083 {
14084 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14085
14086 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14087
14088 int tmp_out = 0;
14089
14090 for (int i = 0; i < tmp_in; i++)
14091 {
14092 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14093 }
14094
14095 for (int i = 0; i < tmp_out; i++)
14096 {
14097 unsigned int speed;
14098
14099 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14100
14101 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14102
14103 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14104 }
14105 }
14106 }
14107
14108 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14109 {
14110 data.hm_nvapi = nvapi;
14111 }
14112
14113 if (data.hm_nvapi)
14114 {
14115 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14116 {
14117 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14118
14119 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14120
14121 int tmp_out = 0;
14122
14123 for (int i = 0; i < tmp_in; i++)
14124 {
14125 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14126 }
14127 }
14128 }
14129
14130 if ((need_adl == 1) && (adl_init (adl) == 0))
14131 {
14132 data.hm_adl = adl;
14133 }
14134
14135 if (data.hm_adl)
14136 {
14137 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14138 {
14139 // total number of adapters
14140
14141 int hm_adapters_num;
14142
14143 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14144
14145 // adapter info
14146
14147 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14148
14149 if (lpAdapterInfo == NULL) return (-1);
14150
14151 // get a list (of ids of) valid/usable adapters
14152
14153 int num_adl_adapters = 0;
14154
14155 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14156
14157 if (num_adl_adapters > 0)
14158 {
14159 hc_thread_mutex_lock (mux_adl);
14160
14161 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14162
14163 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14164
14165 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14166 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14167
14168 hc_thread_mutex_unlock (mux_adl);
14169 }
14170
14171 myfree (valid_adl_device_list);
14172 myfree (lpAdapterInfo);
14173 }
14174 }
14175
14176 if (data.hm_adl == NULL && data.hm_nvml == NULL)
14177 {
14178 gpu_temp_disable = 1;
14179 }
14180 }
14181
14182 /**
14183 * OpenCL devices: allocate buffer for device specific information
14184 */
14185
14186 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14187 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14188
14189 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14190
14191 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14192
14193 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14194
14195 /**
14196 * User-defined GPU temp handling
14197 */
14198
14199 if (gpu_temp_disable == 1)
14200 {
14201 gpu_temp_abort = 0;
14202 gpu_temp_retain = 0;
14203 }
14204
14205 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14206 {
14207 if (gpu_temp_abort < gpu_temp_retain)
14208 {
14209 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14210
14211 return (-1);
14212 }
14213 }
14214
14215 data.gpu_temp_disable = gpu_temp_disable;
14216 data.gpu_temp_abort = gpu_temp_abort;
14217 data.gpu_temp_retain = gpu_temp_retain;
14218 #endif
14219
14220 /**
14221 * enable custom signal handler(s)
14222 */
14223
14224 if (benchmark == 0)
14225 {
14226 hc_signal (sigHandler_default);
14227 }
14228 else
14229 {
14230 hc_signal (sigHandler_benchmark);
14231 }
14232
14233 /**
14234 * inform the user
14235 */
14236
14237 if (data.quiet == 0)
14238 {
14239 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14240
14241 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);
14242
14243 if (attack_mode == ATTACK_MODE_STRAIGHT)
14244 {
14245 log_info ("Rules: %u", kernel_rules_cnt);
14246 }
14247
14248 if (opti_type)
14249 {
14250 log_info ("Applicable Optimizers:");
14251
14252 for (uint i = 0; i < 32; i++)
14253 {
14254 const uint opti_bit = 1u << i;
14255
14256 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14257 }
14258 }
14259
14260 /**
14261 * Watchdog and Temperature balance
14262 */
14263
14264 #ifdef HAVE_HWMON
14265 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL)
14266 {
14267 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14268 }
14269
14270 if (gpu_temp_abort == 0)
14271 {
14272 log_info ("Watchdog: Temperature abort trigger disabled");
14273 }
14274 else
14275 {
14276 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14277 }
14278
14279 if (gpu_temp_retain == 0)
14280 {
14281 log_info ("Watchdog: Temperature retain trigger disabled");
14282 }
14283 else
14284 {
14285 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14286 }
14287
14288 if (data.quiet == 0) log_info ("");
14289 #endif
14290 }
14291
14292 #ifdef HAVE_HWMON
14293
14294 /**
14295 * HM devices: copy
14296 */
14297
14298 if (gpu_temp_disable == 0)
14299 {
14300 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14301 {
14302 hc_device_param_t *device_param = &data.devices_param[device_id];
14303
14304 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14305
14306 if (device_param->skipped) continue;
14307
14308 const uint platform_devices_id = device_param->platform_devices_id;
14309
14310 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14311 {
14312 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14313 data.hm_device[device_id].nvapi = 0;
14314 data.hm_device[device_id].nvml = 0;
14315 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14316 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14317 data.hm_device[device_id].fan_set_supported = hm_adapters_adl[platform_devices_id].fan_set_supported;
14318 }
14319
14320 if (device_param->device_vendor_id == VENDOR_ID_NV)
14321 {
14322 data.hm_device[device_id].adl = 0;
14323 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14324 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14325 data.hm_device[device_id].od_version = 0;
14326 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14327 data.hm_device[device_id].fan_set_supported = 0;
14328 }
14329 }
14330 }
14331
14332 /**
14333 * powertune on user request
14334 */
14335
14336 if (powertune_enable == 1)
14337 {
14338 hc_thread_mutex_lock (mux_adl);
14339
14340 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14341 {
14342 hc_device_param_t *device_param = &data.devices_param[device_id];
14343
14344 if (device_param->skipped) continue;
14345
14346 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14347 {
14348 /**
14349 * Temporary fix:
14350 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14351 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14352 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14353 * Driver / ADL bug?
14354 */
14355
14356 if (data.hm_device[device_id].od_version == 6)
14357 {
14358 int ADL_rc;
14359
14360 // check powertune capabilities first, if not available then skip device
14361
14362 int powertune_supported = 0;
14363
14364 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14365 {
14366 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14367
14368 return (-1);
14369 }
14370
14371 // first backup current value, we will restore it later
14372
14373 if (powertune_supported != 0)
14374 {
14375 // powercontrol settings
14376
14377 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14378
14379 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14380 {
14381 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14382 }
14383
14384 if (ADL_rc != ADL_OK)
14385 {
14386 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14387
14388 return (-1);
14389 }
14390
14391 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14392 {
14393 log_error ("ERROR: Failed to set new ADL PowerControl values");
14394
14395 return (-1);
14396 }
14397
14398 // clocks
14399
14400 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14401
14402 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14403
14404 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)
14405 {
14406 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14407
14408 return (-1);
14409 }
14410
14411 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14412
14413 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14414
14415 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14416 {
14417 log_error ("ERROR: Failed to get ADL device capabilities");
14418
14419 return (-1);
14420 }
14421
14422 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14423 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14424
14425 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14426 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14427
14428 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14429 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14430
14431 // warning if profile has too low max values
14432
14433 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14434 {
14435 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14436 }
14437
14438 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14439 {
14440 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14441 }
14442
14443 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14444
14445 performance_state->iNumberOfPerformanceLevels = 2;
14446
14447 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14448 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14449 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14450 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14451
14452 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)
14453 {
14454 log_info ("ERROR: Failed to set ADL performance state");
14455
14456 return (-1);
14457 }
14458
14459 local_free (performance_state);
14460 }
14461
14462 // set powertune value only
14463
14464 if (powertune_supported != 0)
14465 {
14466 // powertune set
14467 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14468
14469 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14470 {
14471 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14472
14473 return (-1);
14474 }
14475
14476 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14477 {
14478 log_error ("ERROR: Failed to set new ADL PowerControl values");
14479
14480 return (-1);
14481 }
14482 }
14483 }
14484 }
14485
14486 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14487 {
14488 // first backup current value, we will restore it later
14489
14490 unsigned int limit;
14491
14492 int powertune_supported = 0;
14493
14494 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14495 {
14496 powertune_supported = 1;
14497 }
14498
14499 // if backup worked, activate the maximum allowed
14500
14501 if (powertune_supported != 0)
14502 {
14503 unsigned int minLimit;
14504 unsigned int maxLimit;
14505
14506 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14507 {
14508 if (maxLimit > 0)
14509 {
14510 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14511 {
14512 // now we can be sure we need to reset later
14513
14514 nvml_power_limit[device_id] = limit;
14515 }
14516 }
14517 }
14518 }
14519 }
14520 }
14521
14522 hc_thread_mutex_unlock (mux_adl);
14523 }
14524
14525 #endif // HAVE_HWMON
14526
14527 #ifdef DEBUG
14528 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14529 #endif
14530
14531 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14532
14533 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14534 {
14535 /**
14536 * host buffer
14537 */
14538
14539 hc_device_param_t *device_param = &data.devices_param[device_id];
14540
14541 if (device_param->skipped) continue;
14542
14543 /**
14544 * device properties
14545 */
14546
14547 const char *device_name_chksum = device_param->device_name_chksum;
14548 const u32 device_processors = device_param->device_processors;
14549 const u32 device_processor_cores = device_param->device_processor_cores;
14550
14551 /**
14552 * create context for each device
14553 */
14554
14555 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14556
14557 /**
14558 * create command-queue
14559 */
14560
14561 // not supported with NV
14562 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14563
14564 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14565
14566 /**
14567 * kernel threads: some algorithms need a fixed kernel-threads count
14568 * because of shared memory usage or bitslice
14569 * there needs to be some upper limit, otherwise there's too much overhead
14570 */
14571
14572 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14573
14574 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14575 {
14576 kernel_threads = KERNEL_THREADS_MAX_CPU;
14577 }
14578
14579 if (hash_mode == 1500) kernel_threads = 64; // DES
14580 if (hash_mode == 3000) kernel_threads = 64; // DES
14581 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14582 if (hash_mode == 7500) kernel_threads = 64; // RC4
14583 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14584 if (hash_mode == 9700) kernel_threads = 64; // RC4
14585 if (hash_mode == 9710) kernel_threads = 64; // RC4
14586 if (hash_mode == 9800) kernel_threads = 64; // RC4
14587 if (hash_mode == 9810) kernel_threads = 64; // RC4
14588 if (hash_mode == 10400) kernel_threads = 64; // RC4
14589 if (hash_mode == 10410) kernel_threads = 64; // RC4
14590 if (hash_mode == 10500) kernel_threads = 64; // RC4
14591 if (hash_mode == 13100) kernel_threads = 64; // RC4
14592
14593 device_param->kernel_threads = kernel_threads;
14594
14595 device_param->hardware_power = device_processors * kernel_threads;
14596
14597 /**
14598 * create input buffers on device : calculate size of fixed memory buffers
14599 */
14600
14601 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14602 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14603
14604 device_param->size_root_css = size_root_css;
14605 device_param->size_markov_css = size_markov_css;
14606
14607 size_t size_results = sizeof (uint);
14608
14609 device_param->size_results = size_results;
14610
14611 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14612 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14613
14614 size_t size_plains = digests_cnt * sizeof (plain_t);
14615 size_t size_salts = salts_cnt * sizeof (salt_t);
14616 size_t size_esalts = salts_cnt * esalt_size;
14617
14618 device_param->size_plains = size_plains;
14619 device_param->size_digests = size_digests;
14620 device_param->size_shown = size_shown;
14621 device_param->size_salts = size_salts;
14622
14623 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14624 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14625 size_t size_tm = 32 * sizeof (bs_word_t);
14626
14627 // scryptV stuff
14628
14629 size_t size_scryptV = 1;
14630
14631 if ((hash_mode == 8900) || (hash_mode == 9300))
14632 {
14633 uint tmto_start = 0;
14634 uint tmto_stop = 10;
14635
14636 if (scrypt_tmto)
14637 {
14638 tmto_start = scrypt_tmto;
14639 }
14640 else
14641 {
14642 // in case the user did not specify the tmto manually
14643 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14644 // but set the lower end only in case the user has a device with too less memory
14645
14646 if (hash_mode == 8900)
14647 {
14648 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14649 {
14650 tmto_start = 1;
14651 }
14652 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14653 {
14654 tmto_start = 2;
14655 }
14656 }
14657 else if (hash_mode == 9300)
14658 {
14659 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14660 {
14661 tmto_start = 2;
14662 }
14663 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14664 {
14665 tmto_start = 2;
14666 }
14667 }
14668 }
14669
14670 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14671 {
14672 // TODO: in theory the following calculation needs to be done per salt, not global
14673 // we assume all hashes have the same scrypt settings
14674
14675 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14676
14677 size_scryptV /= 1 << tmto;
14678
14679 size_scryptV *= device_processors * device_processor_cores;
14680
14681 if (size_scryptV > device_param->device_maxmem_alloc)
14682 {
14683 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14684
14685 continue;
14686 }
14687
14688 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14689 {
14690 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14691 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14692 }
14693
14694 break;
14695 }
14696
14697 if (data.salts_buf[0].scrypt_phy == 0)
14698 {
14699 log_error ("ERROR: can't allocate enough device memory");
14700
14701 return -1;
14702 }
14703
14704 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14705 }
14706
14707 /**
14708 * some algorithms need a fixed kernel-loops count
14709 */
14710
14711 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
14712 {
14713 const u32 kernel_loops_fixed = 1024;
14714
14715 device_param->kernel_loops_min = kernel_loops_fixed;
14716 device_param->kernel_loops_max = kernel_loops_fixed;
14717 }
14718
14719 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
14720 {
14721 const u32 kernel_loops_fixed = 1024;
14722
14723 device_param->kernel_loops_min = kernel_loops_fixed;
14724 device_param->kernel_loops_max = kernel_loops_fixed;
14725 }
14726
14727 if (hash_mode == 8900)
14728 {
14729 const u32 kernel_loops_fixed = 1;
14730
14731 device_param->kernel_loops_min = kernel_loops_fixed;
14732 device_param->kernel_loops_max = kernel_loops_fixed;
14733 }
14734
14735 if (hash_mode == 9300)
14736 {
14737 const u32 kernel_loops_fixed = 1;
14738
14739 device_param->kernel_loops_min = kernel_loops_fixed;
14740 device_param->kernel_loops_max = kernel_loops_fixed;
14741 }
14742
14743 if (hash_mode == 12500)
14744 {
14745 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14746
14747 device_param->kernel_loops_min = kernel_loops_fixed;
14748 device_param->kernel_loops_max = kernel_loops_fixed;
14749 }
14750
14751 /**
14752 * some algorithms have a maximum kernel-loops count
14753 */
14754
14755 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14756 {
14757 u32 innerloop_cnt = 0;
14758
14759 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14760 {
14761 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14762 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14763 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14764 }
14765 else
14766 {
14767 innerloop_cnt = data.salts_buf[0].salt_iter;
14768 }
14769
14770 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14771 (innerloop_cnt <= device_param->kernel_loops_max))
14772 {
14773 device_param->kernel_loops_max = innerloop_cnt;
14774 }
14775 }
14776
14777 u32 kernel_accel_min = device_param->kernel_accel_min;
14778 u32 kernel_accel_max = device_param->kernel_accel_max;
14779
14780 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14781
14782 size_t size_pws = 4;
14783 size_t size_tmps = 4;
14784 size_t size_hooks = 4;
14785
14786 while (kernel_accel_max >= kernel_accel_min)
14787 {
14788 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14789
14790 // size_pws
14791
14792 size_pws = kernel_power_max * sizeof (pw_t);
14793
14794 // size_tmps
14795
14796 switch (hash_mode)
14797 {
14798 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14799 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14800 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14801 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14802 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14803 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14804 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14805 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14806 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14807 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14808 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14809 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14810 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14811 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14812 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14813 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14814 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14815 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14816 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14817 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14818 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14819 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14820 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14821 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14822 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14823 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14824 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14825 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14826 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14827 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14828 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14829 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14830 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14831 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14832 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14833 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14834 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14835 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14836 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14837 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14838 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14839 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14840 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14841 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14842 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14843 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14844 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14845 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14846 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14847 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14848 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14849 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14850 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14851 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14852 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14853 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14854 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14855 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14856 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14857 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14858 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14859 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14860 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14861 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14862 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14863 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14864 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14865 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14866 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14867 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14868 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14869 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14870 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14871 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14872 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14873 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14874 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14875 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14876 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14877 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14878 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14879 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14880 };
14881
14882 // size_hooks
14883
14884 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14885 {
14886 // none yet
14887 }
14888
14889 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14890 // if not, decrease amplifier and try again
14891
14892 int skip = 0;
14893
14894 const u64 size_total
14895 = bitmap_size
14896 + bitmap_size
14897 + bitmap_size
14898 + bitmap_size
14899 + bitmap_size
14900 + bitmap_size
14901 + bitmap_size
14902 + bitmap_size
14903 + size_bfs
14904 + size_combs
14905 + size_digests
14906 + size_esalts
14907 + size_hooks
14908 + size_markov_css
14909 + size_plains
14910 + size_pws
14911 + size_pws // not a bug
14912 + size_results
14913 + size_root_css
14914 + size_rules
14915 + size_rules_c
14916 + size_salts
14917 + size_scryptV
14918 + size_shown
14919 + size_tm
14920 + size_tmps;
14921
14922 // Don't ask me, ask AMD!
14923
14924 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14925 if (size_total > device_param->device_global_mem) skip = 1;
14926
14927 if (skip == 1)
14928 {
14929 kernel_accel_max--;
14930
14931 continue;
14932 }
14933
14934 break;
14935 }
14936
14937 /*
14938 if (kernel_accel_max == 0)
14939 {
14940 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14941
14942 return -1;
14943 }
14944 */
14945
14946 device_param->kernel_accel_min = kernel_accel_min;
14947 device_param->kernel_accel_max = kernel_accel_max;
14948
14949 /*
14950 if (kernel_accel_max < kernel_accel)
14951 {
14952 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14953
14954 device_param->kernel_accel = kernel_accel_max;
14955 }
14956 */
14957
14958 device_param->size_bfs = size_bfs;
14959 device_param->size_combs = size_combs;
14960 device_param->size_rules = size_rules;
14961 device_param->size_rules_c = size_rules_c;
14962 device_param->size_pws = size_pws;
14963 device_param->size_tmps = size_tmps;
14964 device_param->size_hooks = size_hooks;
14965
14966 /**
14967 * default building options
14968 */
14969
14970 char build_opts[1024] = { 0 };
14971
14972 // we don't have sm_* on vendors not NV but it doesn't matter
14973
14974 #if _WIN
14975 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);
14976 #else
14977 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);
14978 #endif
14979
14980 char build_opts_new[1024] = { 0 };
14981
14982 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);
14983
14984 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14985
14986 /*
14987 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14988 {
14989 // we do vectorizing much better than the auto-vectorizer
14990
14991 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14992
14993 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14994 }
14995 */
14996
14997 #ifdef DEBUG
14998 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14999 #endif
15000
15001 /**
15002 * main kernel
15003 */
15004
15005 {
15006 /**
15007 * kernel source filename
15008 */
15009
15010 char source_file[256] = { 0 };
15011
15012 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15013
15014 struct stat sst;
15015
15016 if (stat (source_file, &sst) == -1)
15017 {
15018 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15019
15020 return -1;
15021 }
15022
15023 /**
15024 * kernel cached filename
15025 */
15026
15027 char cached_file[256] = { 0 };
15028
15029 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15030
15031 int cached = 1;
15032
15033 struct stat cst;
15034
15035 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15036 {
15037 cached = 0;
15038 }
15039
15040 /**
15041 * kernel compile or load
15042 */
15043
15044 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15045
15046 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15047
15048 if (force_jit_compilation == -1)
15049 {
15050 if (cached == 0)
15051 {
15052 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15053
15054 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15055
15056 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15057
15058 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15059
15060 #ifdef DEBUG
15061 size_t build_log_size = 0;
15062
15063 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15064
15065 if (build_log_size > 1)
15066 {
15067 char *build_log = (char *) malloc (build_log_size + 1);
15068
15069 memset (build_log, 0, build_log_size + 1);
15070
15071 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15072
15073 puts (build_log);
15074
15075 free (build_log);
15076 }
15077 #endif
15078
15079 if (rc != 0)
15080 {
15081 device_param->skipped = true;
15082
15083 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15084
15085 continue;
15086 }
15087
15088 size_t binary_size;
15089
15090 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15091
15092 u8 *binary = (u8 *) mymalloc (binary_size);
15093
15094 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15095
15096 writeProgramBin (cached_file, binary, binary_size);
15097
15098 local_free (binary);
15099 }
15100 else
15101 {
15102 #ifdef DEBUG
15103 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15104 #endif
15105
15106 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15107
15108 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15109
15110 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15111 }
15112 }
15113 else
15114 {
15115 #ifdef DEBUG
15116 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15117 #endif
15118
15119 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15120
15121 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15122
15123 char build_opts_update[1024] = { 0 };
15124
15125 if (force_jit_compilation == 1500)
15126 {
15127 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15128 }
15129 else if (force_jit_compilation == 8900)
15130 {
15131 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);
15132 }
15133 else
15134 {
15135 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15136 }
15137
15138 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15139
15140 #ifdef DEBUG
15141 size_t build_log_size = 0;
15142
15143 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15144
15145 if (build_log_size > 1)
15146 {
15147 char *build_log = (char *) malloc (build_log_size + 1);
15148
15149 memset (build_log, 0, build_log_size + 1);
15150
15151 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15152
15153 puts (build_log);
15154
15155 free (build_log);
15156 }
15157 #endif
15158
15159 if (rc != 0)
15160 {
15161 device_param->skipped = true;
15162
15163 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15164 }
15165 }
15166
15167 local_free (kernel_lengths);
15168 local_free (kernel_sources[0]);
15169 local_free (kernel_sources);
15170 }
15171
15172 /**
15173 * word generator kernel
15174 */
15175
15176 if (attack_mode != ATTACK_MODE_STRAIGHT)
15177 {
15178 /**
15179 * kernel mp source filename
15180 */
15181
15182 char source_file[256] = { 0 };
15183
15184 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15185
15186 struct stat sst;
15187
15188 if (stat (source_file, &sst) == -1)
15189 {
15190 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15191
15192 return -1;
15193 }
15194
15195 /**
15196 * kernel mp cached filename
15197 */
15198
15199 char cached_file[256] = { 0 };
15200
15201 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15202
15203 int cached = 1;
15204
15205 struct stat cst;
15206
15207 if (stat (cached_file, &cst) == -1)
15208 {
15209 cached = 0;
15210 }
15211
15212 /**
15213 * kernel compile or load
15214 */
15215
15216 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15217
15218 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15219
15220 if (cached == 0)
15221 {
15222 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15223 if (quiet == 0) log_info ("");
15224
15225 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15226
15227 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15228
15229 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15230
15231 if (rc != 0)
15232 {
15233 device_param->skipped = true;
15234
15235 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15236
15237 continue;
15238 }
15239
15240 size_t binary_size;
15241
15242 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15243
15244 u8 *binary = (u8 *) mymalloc (binary_size);
15245
15246 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15247
15248 writeProgramBin (cached_file, binary, binary_size);
15249
15250 local_free (binary);
15251 }
15252 else
15253 {
15254 #ifdef DEBUG
15255 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15256 #endif
15257
15258 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15259
15260 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15261
15262 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15263 }
15264
15265 local_free (kernel_lengths);
15266 local_free (kernel_sources[0]);
15267 local_free (kernel_sources);
15268 }
15269
15270 /**
15271 * amplifier kernel
15272 */
15273
15274 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15275 {
15276
15277 }
15278 else
15279 {
15280 /**
15281 * kernel amp source filename
15282 */
15283
15284 char source_file[256] = { 0 };
15285
15286 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15287
15288 struct stat sst;
15289
15290 if (stat (source_file, &sst) == -1)
15291 {
15292 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15293
15294 return -1;
15295 }
15296
15297 /**
15298 * kernel amp cached filename
15299 */
15300
15301 char cached_file[256] = { 0 };
15302
15303 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15304
15305 int cached = 1;
15306
15307 struct stat cst;
15308
15309 if (stat (cached_file, &cst) == -1)
15310 {
15311 cached = 0;
15312 }
15313
15314 /**
15315 * kernel compile or load
15316 */
15317
15318 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15319
15320 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15321
15322 if (cached == 0)
15323 {
15324 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15325 if (quiet == 0) log_info ("");
15326
15327 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15328
15329 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15330
15331 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15332
15333 if (rc != 0)
15334 {
15335 device_param->skipped = true;
15336
15337 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15338
15339 continue;
15340 }
15341
15342 size_t binary_size;
15343
15344 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15345
15346 u8 *binary = (u8 *) mymalloc (binary_size);
15347
15348 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15349
15350 writeProgramBin (cached_file, binary, binary_size);
15351
15352 local_free (binary);
15353 }
15354 else
15355 {
15356 #ifdef DEBUG
15357 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15358 #endif
15359
15360 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15361
15362 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15363
15364 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15365 }
15366
15367 local_free (kernel_lengths);
15368 local_free (kernel_sources[0]);
15369 local_free (kernel_sources);
15370 }
15371
15372 // some algorithm collide too fast, make that impossible
15373
15374 if (benchmark == 1)
15375 {
15376 ((uint *) digests_buf)[0] = -1;
15377 ((uint *) digests_buf)[1] = -1;
15378 ((uint *) digests_buf)[2] = -1;
15379 ((uint *) digests_buf)[3] = -1;
15380 }
15381
15382 /**
15383 * global buffers
15384 */
15385
15386 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15387 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15388 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15389 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15390 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15391 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15392 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15393 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15394 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15395 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15396 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15397 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15398 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15399 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15400 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15401 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15402 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15403 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15404
15405 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);
15406 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);
15407 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);
15408 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);
15409 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);
15410 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);
15411 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);
15412 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);
15413 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15414 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15415 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15416
15417 /**
15418 * special buffers
15419 */
15420
15421 if (attack_kern == ATTACK_KERN_STRAIGHT)
15422 {
15423 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15424 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15425
15426 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15427 }
15428 else if (attack_kern == ATTACK_KERN_COMBI)
15429 {
15430 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15431 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15432 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15433 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15434 }
15435 else if (attack_kern == ATTACK_KERN_BF)
15436 {
15437 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15438 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15439 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15440 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15441 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15442 }
15443
15444 if (size_esalts)
15445 {
15446 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15447
15448 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15449 }
15450
15451 /**
15452 * main host data
15453 */
15454
15455 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15456
15457 device_param->pws_buf = pws_buf;
15458
15459 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15460
15461 device_param->combs_buf = combs_buf;
15462
15463 void *hooks_buf = mymalloc (size_hooks);
15464
15465 device_param->hooks_buf = hooks_buf;
15466
15467 /**
15468 * kernel args
15469 */
15470
15471 device_param->kernel_params_buf32[21] = bitmap_mask;
15472 device_param->kernel_params_buf32[22] = bitmap_shift1;
15473 device_param->kernel_params_buf32[23] = bitmap_shift2;
15474 device_param->kernel_params_buf32[24] = 0; // salt_pos
15475 device_param->kernel_params_buf32[25] = 0; // loop_pos
15476 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15477 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15478 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15479 device_param->kernel_params_buf32[29] = 0; // digests_offset
15480 device_param->kernel_params_buf32[30] = 0; // combs_mode
15481 device_param->kernel_params_buf32[31] = 0; // gid_max
15482
15483 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15484 ? &device_param->d_pws_buf
15485 : &device_param->d_pws_amp_buf;
15486 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15487 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15488 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15489 device_param->kernel_params[ 4] = &device_param->d_tmps;
15490 device_param->kernel_params[ 5] = &device_param->d_hooks;
15491 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15492 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15493 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15494 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15495 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15496 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15497 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15498 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15499 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15500 device_param->kernel_params[15] = &device_param->d_digests_buf;
15501 device_param->kernel_params[16] = &device_param->d_digests_shown;
15502 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15503 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15504 device_param->kernel_params[19] = &device_param->d_result;
15505 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15506 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15507 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15508 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15509 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15510 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15511 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15512 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15513 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15514 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15515 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15516 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15517
15518 device_param->kernel_params_mp_buf64[3] = 0;
15519 device_param->kernel_params_mp_buf32[4] = 0;
15520 device_param->kernel_params_mp_buf32[5] = 0;
15521 device_param->kernel_params_mp_buf32[6] = 0;
15522 device_param->kernel_params_mp_buf32[7] = 0;
15523 device_param->kernel_params_mp_buf32[8] = 0;
15524
15525 device_param->kernel_params_mp[0] = NULL;
15526 device_param->kernel_params_mp[1] = NULL;
15527 device_param->kernel_params_mp[2] = NULL;
15528 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15529 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15530 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15531 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15532 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15533 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15534
15535 device_param->kernel_params_mp_l_buf64[3] = 0;
15536 device_param->kernel_params_mp_l_buf32[4] = 0;
15537 device_param->kernel_params_mp_l_buf32[5] = 0;
15538 device_param->kernel_params_mp_l_buf32[6] = 0;
15539 device_param->kernel_params_mp_l_buf32[7] = 0;
15540 device_param->kernel_params_mp_l_buf32[8] = 0;
15541 device_param->kernel_params_mp_l_buf32[9] = 0;
15542
15543 device_param->kernel_params_mp_l[0] = NULL;
15544 device_param->kernel_params_mp_l[1] = NULL;
15545 device_param->kernel_params_mp_l[2] = NULL;
15546 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15547 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15548 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15549 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15550 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15551 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15552 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15553
15554 device_param->kernel_params_mp_r_buf64[3] = 0;
15555 device_param->kernel_params_mp_r_buf32[4] = 0;
15556 device_param->kernel_params_mp_r_buf32[5] = 0;
15557 device_param->kernel_params_mp_r_buf32[6] = 0;
15558 device_param->kernel_params_mp_r_buf32[7] = 0;
15559 device_param->kernel_params_mp_r_buf32[8] = 0;
15560
15561 device_param->kernel_params_mp_r[0] = NULL;
15562 device_param->kernel_params_mp_r[1] = NULL;
15563 device_param->kernel_params_mp_r[2] = NULL;
15564 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15565 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15566 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15567 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15568 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15569 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15570
15571 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15572 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15573
15574 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15575 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15576 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15577 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15578 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15579 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15580 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15581
15582 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15583 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15584
15585 device_param->kernel_params_memset_buf32[1] = 0; // value
15586 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15587
15588 device_param->kernel_params_memset[0] = NULL;
15589 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15590 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15591
15592 /**
15593 * kernel name
15594 */
15595
15596 size_t kernel_wgs_tmp;
15597
15598 char kernel_name[64] = { 0 };
15599
15600 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15601 {
15602 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15603 {
15604 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15605
15606 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15607
15608 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15609
15610 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15611
15612 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15613
15614 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15615 }
15616 else
15617 {
15618 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15619
15620 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15621
15622 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15623
15624 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15625
15626 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15627
15628 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15629 }
15630
15631 if (data.attack_mode == ATTACK_MODE_BF)
15632 {
15633 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15634 {
15635 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15636
15637 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15638
15639 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);
15640 }
15641 }
15642 }
15643 else
15644 {
15645 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15646
15647 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15648
15649 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15650
15651 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15652
15653 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15654
15655 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15656
15657 if (opts_type & OPTS_TYPE_HOOK12)
15658 {
15659 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15660
15661 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15662
15663 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);
15664 }
15665
15666 if (opts_type & OPTS_TYPE_HOOK23)
15667 {
15668 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15669
15670 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15671
15672 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);
15673 }
15674 }
15675
15676 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);
15677 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);
15678 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);
15679
15680 for (uint i = 0; i <= 20; i++)
15681 {
15682 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15683 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15684 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15685
15686 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15687 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15688 }
15689
15690 for (uint i = 21; i <= 31; i++)
15691 {
15692 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15693 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15694 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15695
15696 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15697 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15698 }
15699
15700 // GPU memset
15701
15702 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15703
15704 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);
15705
15706 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15707 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15708 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15709
15710 // MP start
15711
15712 if (attack_mode == ATTACK_MODE_BF)
15713 {
15714 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15715 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15716
15717 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);
15718 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);
15719
15720 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15721 {
15722 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15723 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15724 }
15725 }
15726 else if (attack_mode == ATTACK_MODE_HYBRID1)
15727 {
15728 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15729
15730 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);
15731 }
15732 else if (attack_mode == ATTACK_MODE_HYBRID2)
15733 {
15734 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15735
15736 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);
15737 }
15738
15739 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15740 {
15741 // nothing to do
15742 }
15743 else
15744 {
15745 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15746
15747 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);
15748 }
15749
15750 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15751 {
15752 // nothing to do
15753 }
15754 else
15755 {
15756 for (uint i = 0; i < 5; i++)
15757 {
15758 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15759 }
15760
15761 for (uint i = 5; i < 7; i++)
15762 {
15763 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15764 }
15765 }
15766
15767 // maybe this has been updated by clGetKernelWorkGroupInfo()
15768 // value can only be decreased, so we don't need to reallocate buffers
15769
15770 device_param->kernel_threads = kernel_threads;
15771
15772 // zero some data buffers
15773
15774 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15775 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15776 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15777 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15778 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15779 run_kernel_bzero (device_param, device_param->d_result, size_results);
15780
15781 /**
15782 * special buffers
15783 */
15784
15785 if (attack_kern == ATTACK_KERN_STRAIGHT)
15786 {
15787 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15788 }
15789 else if (attack_kern == ATTACK_KERN_COMBI)
15790 {
15791 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15792 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15793 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15794 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15795 }
15796 else if (attack_kern == ATTACK_KERN_BF)
15797 {
15798 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15799 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15800 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15801 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15802 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15803 }
15804
15805 #if defined(HAVE_HWMON)
15806
15807 /**
15808 * Store initial fanspeed if gpu_temp_retain is enabled
15809 */
15810
15811 if (gpu_temp_disable == 0)
15812 {
15813 if (gpu_temp_retain != 0)
15814 {
15815 hc_thread_mutex_lock (mux_adl);
15816
15817 if (data.hm_device[device_id].fan_get_supported == 1)
15818 {
15819 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
15820 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
15821
15822 temp_retain_fanspeed_value[device_id] = fanspeed;
15823 temp_retain_fanpolicy_value[device_id] = fanpolicy;
15824
15825 // we also set it to tell the OS we take control over the fan and it's automatic controller
15826 // if it was set to automatic. we do not control user-defined fanspeeds.
15827
15828 if (fanpolicy == 1)
15829 {
15830 data.hm_device[device_id].fan_set_supported = 1;
15831
15832 int rc = -1;
15833
15834 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15835 {
15836 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
15837 }
15838 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15839 {
15840
15841 }
15842
15843 if (rc == 0)
15844 {
15845 data.hm_device[device_id].fan_set_supported = 1;
15846 }
15847 else
15848 {
15849 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
15850
15851 data.hm_device[device_id].fan_set_supported = 0;
15852 }
15853 }
15854 else
15855 {
15856 data.hm_device[device_id].fan_set_supported = 0;
15857 }
15858 }
15859
15860 hc_thread_mutex_unlock (mux_adl);
15861 }
15862 }
15863
15864 #endif // HAVE_HWMON
15865 }
15866
15867 if (data.quiet == 0) log_info_nn ("");
15868
15869 /**
15870 * In benchmark-mode, inform user which algorithm is checked
15871 */
15872
15873 if (benchmark == 1)
15874 {
15875 if (machine_readable == 0)
15876 {
15877 quiet = 0;
15878
15879 data.quiet = quiet;
15880
15881 char *hash_type = strhashtype (data.hash_mode); // not a bug
15882
15883 log_info ("Hashtype: %s", hash_type);
15884 log_info ("");
15885 }
15886 }
15887
15888 /**
15889 * keep track of the progress
15890 */
15891
15892 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15893 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15894 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15895
15896 /**
15897 * open filehandles
15898 */
15899
15900 #if _WIN
15901 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15902 {
15903 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15904
15905 return (-1);
15906 }
15907
15908 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15909 {
15910 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15911
15912 return (-1);
15913 }
15914
15915 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15916 {
15917 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15918
15919 return (-1);
15920 }
15921 #endif
15922
15923 /**
15924 * dictionary pad
15925 */
15926
15927 segment_size *= (1024 * 1024);
15928
15929 data.segment_size = segment_size;
15930
15931 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15932
15933 wl_data->buf = (char *) mymalloc (segment_size);
15934 wl_data->avail = segment_size;
15935 wl_data->incr = segment_size;
15936 wl_data->cnt = 0;
15937 wl_data->pos = 0;
15938
15939 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15940
15941 data.wordlist_mode = wordlist_mode;
15942
15943 cs_t *css_buf = NULL;
15944 uint css_cnt = 0;
15945 uint dictcnt = 0;
15946 uint maskcnt = 1;
15947 char **masks = NULL;
15948 char **dictfiles = NULL;
15949
15950 uint mask_from_file = 0;
15951
15952 if (attack_mode == ATTACK_MODE_STRAIGHT)
15953 {
15954 if (wordlist_mode == WL_MODE_FILE)
15955 {
15956 int wls_left = myargc - (optind + 1);
15957
15958 for (int i = 0; i < wls_left; i++)
15959 {
15960 char *l0_filename = myargv[optind + 1 + i];
15961
15962 struct stat l0_stat;
15963
15964 if (stat (l0_filename, &l0_stat) == -1)
15965 {
15966 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15967
15968 return (-1);
15969 }
15970
15971 uint is_dir = S_ISDIR (l0_stat.st_mode);
15972
15973 if (is_dir == 0)
15974 {
15975 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15976
15977 dictcnt++;
15978
15979 dictfiles[dictcnt - 1] = l0_filename;
15980 }
15981 else
15982 {
15983 // do not allow --keyspace w/ a directory
15984
15985 if (keyspace == 1)
15986 {
15987 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15988
15989 return (-1);
15990 }
15991
15992 char **dictionary_files = NULL;
15993
15994 dictionary_files = scan_directory (l0_filename);
15995
15996 if (dictionary_files != NULL)
15997 {
15998 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15999
16000 for (int d = 0; dictionary_files[d] != NULL; d++)
16001 {
16002 char *l1_filename = dictionary_files[d];
16003
16004 struct stat l1_stat;
16005
16006 if (stat (l1_filename, &l1_stat) == -1)
16007 {
16008 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16009
16010 return (-1);
16011 }
16012
16013 if (S_ISREG (l1_stat.st_mode))
16014 {
16015 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16016
16017 dictcnt++;
16018
16019 dictfiles[dictcnt - 1] = strdup (l1_filename);
16020 }
16021 }
16022 }
16023
16024 local_free (dictionary_files);
16025 }
16026 }
16027
16028 if (dictcnt < 1)
16029 {
16030 log_error ("ERROR: No usable dictionary file found.");
16031
16032 return (-1);
16033 }
16034 }
16035 else if (wordlist_mode == WL_MODE_STDIN)
16036 {
16037 dictcnt = 1;
16038 }
16039 }
16040 else if (attack_mode == ATTACK_MODE_COMBI)
16041 {
16042 // display
16043
16044 char *dictfile1 = myargv[optind + 1 + 0];
16045 char *dictfile2 = myargv[optind + 1 + 1];
16046
16047 // find the bigger dictionary and use as base
16048
16049 FILE *fp1 = NULL;
16050 FILE *fp2 = NULL;
16051
16052 struct stat tmp_stat;
16053
16054 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16055 {
16056 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16057
16058 return (-1);
16059 }
16060
16061 if (stat (dictfile1, &tmp_stat) == -1)
16062 {
16063 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16064
16065 fclose (fp1);
16066
16067 return (-1);
16068 }
16069
16070 if (S_ISDIR (tmp_stat.st_mode))
16071 {
16072 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16073
16074 fclose (fp1);
16075
16076 return (-1);
16077 }
16078
16079 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16080 {
16081 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16082
16083 fclose (fp1);
16084
16085 return (-1);
16086 }
16087
16088 if (stat (dictfile2, &tmp_stat) == -1)
16089 {
16090 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16091
16092 fclose (fp1);
16093 fclose (fp2);
16094
16095 return (-1);
16096 }
16097
16098 if (S_ISDIR (tmp_stat.st_mode))
16099 {
16100 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16101
16102 fclose (fp1);
16103 fclose (fp2);
16104
16105 return (-1);
16106 }
16107
16108 data.combs_cnt = 1;
16109
16110 data.quiet = 1;
16111
16112 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16113
16114 data.quiet = quiet;
16115
16116 if (words1_cnt == 0)
16117 {
16118 log_error ("ERROR: %s: empty file", dictfile1);
16119
16120 fclose (fp1);
16121 fclose (fp2);
16122
16123 return (-1);
16124 }
16125
16126 data.combs_cnt = 1;
16127
16128 data.quiet = 1;
16129
16130 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16131
16132 data.quiet = quiet;
16133
16134 if (words2_cnt == 0)
16135 {
16136 log_error ("ERROR: %s: empty file", dictfile2);
16137
16138 fclose (fp1);
16139 fclose (fp2);
16140
16141 return (-1);
16142 }
16143
16144 fclose (fp1);
16145 fclose (fp2);
16146
16147 data.dictfile = dictfile1;
16148 data.dictfile2 = dictfile2;
16149
16150 if (words1_cnt >= words2_cnt)
16151 {
16152 data.combs_cnt = words2_cnt;
16153 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16154
16155 dictfiles = &data.dictfile;
16156
16157 dictcnt = 1;
16158 }
16159 else
16160 {
16161 data.combs_cnt = words1_cnt;
16162 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16163
16164 dictfiles = &data.dictfile2;
16165
16166 dictcnt = 1;
16167
16168 // we also have to switch wordlist related rules!
16169
16170 char *tmpc = data.rule_buf_l;
16171
16172 data.rule_buf_l = data.rule_buf_r;
16173 data.rule_buf_r = tmpc;
16174
16175 int tmpi = data.rule_len_l;
16176
16177 data.rule_len_l = data.rule_len_r;
16178 data.rule_len_r = tmpi;
16179 }
16180 }
16181 else if (attack_mode == ATTACK_MODE_BF)
16182 {
16183 char *mask = NULL;
16184
16185 maskcnt = 0;
16186
16187 if (benchmark == 0)
16188 {
16189 mask = myargv[optind + 1];
16190
16191 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16192
16193 if ((optind + 2) <= myargc)
16194 {
16195 struct stat file_stat;
16196
16197 if (stat (mask, &file_stat) == -1)
16198 {
16199 maskcnt = 1;
16200
16201 masks[maskcnt - 1] = mystrdup (mask);
16202 }
16203 else
16204 {
16205 int wls_left = myargc - (optind + 1);
16206
16207 uint masks_avail = INCR_MASKS;
16208
16209 for (int i = 0; i < wls_left; i++)
16210 {
16211 if (i != 0)
16212 {
16213 mask = myargv[optind + 1 + i];
16214
16215 if (stat (mask, &file_stat) == -1)
16216 {
16217 log_error ("ERROR: %s: %s", mask, strerror (errno));
16218
16219 return (-1);
16220 }
16221 }
16222
16223 uint is_file = S_ISREG (file_stat.st_mode);
16224
16225 if (is_file == 1)
16226 {
16227 FILE *mask_fp;
16228
16229 if ((mask_fp = fopen (mask, "r")) == NULL)
16230 {
16231 log_error ("ERROR: %s: %s", mask, strerror (errno));
16232
16233 return (-1);
16234 }
16235
16236 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16237
16238 while (!feof (mask_fp))
16239 {
16240 memset (line_buf, 0, HCBUFSIZ);
16241
16242 int line_len = fgetl (mask_fp, line_buf);
16243
16244 if (line_len == 0) continue;
16245
16246 if (line_buf[0] == '#') continue;
16247
16248 if (masks_avail == maskcnt)
16249 {
16250 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16251
16252 masks_avail += INCR_MASKS;
16253 }
16254
16255 masks[maskcnt] = mystrdup (line_buf);
16256
16257 maskcnt++;
16258 }
16259
16260 myfree (line_buf);
16261
16262 fclose (mask_fp);
16263 }
16264 else
16265 {
16266 log_error ("ERROR: %s: unsupported file-type", mask);
16267
16268 return (-1);
16269 }
16270 }
16271
16272 mask_from_file = 1;
16273 }
16274 }
16275 else
16276 {
16277 custom_charset_1 = (char *) "?l?d?u";
16278 custom_charset_2 = (char *) "?l?d";
16279 custom_charset_3 = (char *) "?l?d*!$@_";
16280
16281 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16282 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16283 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16284
16285 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16286
16287 wordlist_mode = WL_MODE_MASK;
16288
16289 data.wordlist_mode = wordlist_mode;
16290
16291 increment = 1;
16292
16293 maskcnt = 1;
16294 }
16295 }
16296 else
16297 {
16298 /**
16299 * generate full masks and charsets
16300 */
16301
16302 masks = (char **) mymalloc (sizeof (char *));
16303
16304 switch (hash_mode)
16305 {
16306 case 1731: pw_min = 5;
16307 pw_max = 5;
16308 mask = mystrdup ("?b?b?b?b?b");
16309 break;
16310 case 12500: pw_min = 5;
16311 pw_max = 5;
16312 mask = mystrdup ("?b?b?b?b?b");
16313 break;
16314 default: pw_min = 7;
16315 pw_max = 7;
16316 mask = mystrdup ("?b?b?b?b?b?b?b");
16317 break;
16318 }
16319
16320 maskcnt = 1;
16321
16322 masks[maskcnt - 1] = mystrdup (mask);
16323
16324 wordlist_mode = WL_MODE_MASK;
16325
16326 data.wordlist_mode = wordlist_mode;
16327
16328 increment = 1;
16329 }
16330
16331 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16332
16333 if (increment)
16334 {
16335 if (increment_min > pw_min) pw_min = increment_min;
16336
16337 if (increment_max < pw_max) pw_max = increment_max;
16338 }
16339 }
16340 else if (attack_mode == ATTACK_MODE_HYBRID1)
16341 {
16342 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16343
16344 // display
16345
16346 char *mask = myargv[myargc - 1];
16347
16348 maskcnt = 0;
16349
16350 masks = (char **) mymalloc (1 * sizeof (char *));
16351
16352 // mod
16353
16354 struct stat file_stat;
16355
16356 if (stat (mask, &file_stat) == -1)
16357 {
16358 maskcnt = 1;
16359
16360 masks[maskcnt - 1] = mystrdup (mask);
16361 }
16362 else
16363 {
16364 uint is_file = S_ISREG (file_stat.st_mode);
16365
16366 if (is_file == 1)
16367 {
16368 FILE *mask_fp;
16369
16370 if ((mask_fp = fopen (mask, "r")) == NULL)
16371 {
16372 log_error ("ERROR: %s: %s", mask, strerror (errno));
16373
16374 return (-1);
16375 }
16376
16377 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16378
16379 uint masks_avail = 1;
16380
16381 while (!feof (mask_fp))
16382 {
16383 memset (line_buf, 0, HCBUFSIZ);
16384
16385 int line_len = fgetl (mask_fp, line_buf);
16386
16387 if (line_len == 0) continue;
16388
16389 if (line_buf[0] == '#') continue;
16390
16391 if (masks_avail == maskcnt)
16392 {
16393 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16394
16395 masks_avail += INCR_MASKS;
16396 }
16397
16398 masks[maskcnt] = mystrdup (line_buf);
16399
16400 maskcnt++;
16401 }
16402
16403 myfree (line_buf);
16404
16405 fclose (mask_fp);
16406
16407 mask_from_file = 1;
16408 }
16409 else
16410 {
16411 maskcnt = 1;
16412
16413 masks[maskcnt - 1] = mystrdup (mask);
16414 }
16415 }
16416
16417 // base
16418
16419 int wls_left = myargc - (optind + 2);
16420
16421 for (int i = 0; i < wls_left; i++)
16422 {
16423 char *filename = myargv[optind + 1 + i];
16424
16425 struct stat file_stat;
16426
16427 if (stat (filename, &file_stat) == -1)
16428 {
16429 log_error ("ERROR: %s: %s", filename, strerror (errno));
16430
16431 return (-1);
16432 }
16433
16434 uint is_dir = S_ISDIR (file_stat.st_mode);
16435
16436 if (is_dir == 0)
16437 {
16438 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16439
16440 dictcnt++;
16441
16442 dictfiles[dictcnt - 1] = filename;
16443 }
16444 else
16445 {
16446 // do not allow --keyspace w/ a directory
16447
16448 if (keyspace == 1)
16449 {
16450 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16451
16452 return (-1);
16453 }
16454
16455 char **dictionary_files = NULL;
16456
16457 dictionary_files = scan_directory (filename);
16458
16459 if (dictionary_files != NULL)
16460 {
16461 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16462
16463 for (int d = 0; dictionary_files[d] != NULL; d++)
16464 {
16465 char *l1_filename = dictionary_files[d];
16466
16467 struct stat l1_stat;
16468
16469 if (stat (l1_filename, &l1_stat) == -1)
16470 {
16471 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16472
16473 return (-1);
16474 }
16475
16476 if (S_ISREG (l1_stat.st_mode))
16477 {
16478 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16479
16480 dictcnt++;
16481
16482 dictfiles[dictcnt - 1] = strdup (l1_filename);
16483 }
16484 }
16485 }
16486
16487 local_free (dictionary_files);
16488 }
16489 }
16490
16491 if (dictcnt < 1)
16492 {
16493 log_error ("ERROR: No usable dictionary file found.");
16494
16495 return (-1);
16496 }
16497
16498 if (increment)
16499 {
16500 maskcnt = 0;
16501
16502 uint mask_min = increment_min; // we can't reject smaller masks here
16503 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16504
16505 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16506 {
16507 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16508
16509 if (cur_mask == NULL) break;
16510
16511 masks[maskcnt] = cur_mask;
16512
16513 maskcnt++;
16514
16515 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16516 }
16517 }
16518 }
16519 else if (attack_mode == ATTACK_MODE_HYBRID2)
16520 {
16521 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16522
16523 // display
16524
16525 char *mask = myargv[optind + 1 + 0];
16526
16527 maskcnt = 0;
16528
16529 masks = (char **) mymalloc (1 * sizeof (char *));
16530
16531 // mod
16532
16533 struct stat file_stat;
16534
16535 if (stat (mask, &file_stat) == -1)
16536 {
16537 maskcnt = 1;
16538
16539 masks[maskcnt - 1] = mystrdup (mask);
16540 }
16541 else
16542 {
16543 uint is_file = S_ISREG (file_stat.st_mode);
16544
16545 if (is_file == 1)
16546 {
16547 FILE *mask_fp;
16548
16549 if ((mask_fp = fopen (mask, "r")) == NULL)
16550 {
16551 log_error ("ERROR: %s: %s", mask, strerror (errno));
16552
16553 return (-1);
16554 }
16555
16556 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16557
16558 uint masks_avail = 1;
16559
16560 while (!feof (mask_fp))
16561 {
16562 memset (line_buf, 0, HCBUFSIZ);
16563
16564 int line_len = fgetl (mask_fp, line_buf);
16565
16566 if (line_len == 0) continue;
16567
16568 if (line_buf[0] == '#') continue;
16569
16570 if (masks_avail == maskcnt)
16571 {
16572 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16573
16574 masks_avail += INCR_MASKS;
16575 }
16576
16577 masks[maskcnt] = mystrdup (line_buf);
16578
16579 maskcnt++;
16580 }
16581
16582 myfree (line_buf);
16583
16584 fclose (mask_fp);
16585
16586 mask_from_file = 1;
16587 }
16588 else
16589 {
16590 maskcnt = 1;
16591
16592 masks[maskcnt - 1] = mystrdup (mask);
16593 }
16594 }
16595
16596 // base
16597
16598 int wls_left = myargc - (optind + 2);
16599
16600 for (int i = 0; i < wls_left; i++)
16601 {
16602 char *filename = myargv[optind + 2 + i];
16603
16604 struct stat file_stat;
16605
16606 if (stat (filename, &file_stat) == -1)
16607 {
16608 log_error ("ERROR: %s: %s", filename, strerror (errno));
16609
16610 return (-1);
16611 }
16612
16613 uint is_dir = S_ISDIR (file_stat.st_mode);
16614
16615 if (is_dir == 0)
16616 {
16617 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16618
16619 dictcnt++;
16620
16621 dictfiles[dictcnt - 1] = filename;
16622 }
16623 else
16624 {
16625 // do not allow --keyspace w/ a directory
16626
16627 if (keyspace == 1)
16628 {
16629 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16630
16631 return (-1);
16632 }
16633
16634 char **dictionary_files = NULL;
16635
16636 dictionary_files = scan_directory (filename);
16637
16638 if (dictionary_files != NULL)
16639 {
16640 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16641
16642 for (int d = 0; dictionary_files[d] != NULL; d++)
16643 {
16644 char *l1_filename = dictionary_files[d];
16645
16646 struct stat l1_stat;
16647
16648 if (stat (l1_filename, &l1_stat) == -1)
16649 {
16650 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16651
16652 return (-1);
16653 }
16654
16655 if (S_ISREG (l1_stat.st_mode))
16656 {
16657 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16658
16659 dictcnt++;
16660
16661 dictfiles[dictcnt - 1] = strdup (l1_filename);
16662 }
16663 }
16664 }
16665
16666 local_free (dictionary_files);
16667 }
16668 }
16669
16670 if (dictcnt < 1)
16671 {
16672 log_error ("ERROR: No usable dictionary file found.");
16673
16674 return (-1);
16675 }
16676
16677 if (increment)
16678 {
16679 maskcnt = 0;
16680
16681 uint mask_min = increment_min; // we can't reject smaller masks here
16682 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16683
16684 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16685 {
16686 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16687
16688 if (cur_mask == NULL) break;
16689
16690 masks[maskcnt] = cur_mask;
16691
16692 maskcnt++;
16693
16694 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16695 }
16696 }
16697 }
16698
16699 data.pw_min = pw_min;
16700 data.pw_max = pw_max;
16701
16702 /**
16703 * weak hash check
16704 */
16705
16706 if (weak_hash_threshold >= salts_cnt)
16707 {
16708 hc_device_param_t *device_param = NULL;
16709
16710 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16711 {
16712 device_param = &data.devices_param[device_id];
16713
16714 if (device_param->skipped) continue;
16715
16716 break;
16717 }
16718
16719 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16720
16721 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16722 {
16723 weak_hash_check (device_param, salt_pos);
16724 }
16725
16726 // Display hack, guarantee that there is at least one \r before real start
16727
16728 //if (data.quiet == 0) log_info ("");
16729 }
16730
16731 /**
16732 * status and monitor threads
16733 */
16734
16735 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16736
16737 hc_thread_t i_thread = 0;
16738
16739 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16740 {
16741 hc_thread_create (i_thread, thread_keypress, &benchmark);
16742 }
16743
16744 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16745
16746 uint ni_threads_cnt = 0;
16747
16748 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16749
16750 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16751
16752 ni_threads_cnt++;
16753
16754 /**
16755 * Outfile remove
16756 */
16757
16758 if (keyspace == 0)
16759 {
16760 if (outfile_check_timer != 0)
16761 {
16762 if (data.outfile_check_directory != NULL)
16763 {
16764 if ((hash_mode != 5200) &&
16765 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16766 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16767 (hash_mode != 9000))
16768 {
16769 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16770
16771 ni_threads_cnt++;
16772 }
16773 else
16774 {
16775 outfile_check_timer = 0;
16776 }
16777 }
16778 else
16779 {
16780 outfile_check_timer = 0;
16781 }
16782 }
16783 }
16784
16785 /**
16786 * Inform the user if we got some hashes remove because of the pot file remove feature
16787 */
16788
16789 if (data.quiet == 0)
16790 {
16791 if (potfile_remove_cracks > 0)
16792 {
16793 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16794 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16795 }
16796 }
16797
16798 data.outfile_check_timer = outfile_check_timer;
16799
16800 /**
16801 * main loop
16802 */
16803
16804 char **induction_dictionaries = NULL;
16805
16806 int induction_dictionaries_cnt = 0;
16807
16808 hcstat_table_t *root_table_buf = NULL;
16809 hcstat_table_t *markov_table_buf = NULL;
16810
16811 uint initial_restore_done = 0;
16812
16813 data.maskcnt = maskcnt;
16814
16815 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16816 {
16817 if (data.devices_status == STATUS_CRACKED) break;
16818
16819 data.devices_status = STATUS_INIT;
16820
16821 if (maskpos > rd->maskpos)
16822 {
16823 rd->dictpos = 0;
16824 }
16825
16826 rd->maskpos = maskpos;
16827 data.maskpos = maskpos;
16828
16829 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16830 {
16831 char *mask = masks[maskpos];
16832
16833 if (mask_from_file == 1)
16834 {
16835 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16836
16837 char *str_ptr;
16838 uint str_pos;
16839
16840 uint mask_offset = 0;
16841
16842 uint separator_cnt;
16843
16844 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16845 {
16846 str_ptr = strstr (mask + mask_offset, ",");
16847
16848 if (str_ptr == NULL) break;
16849
16850 str_pos = str_ptr - mask;
16851
16852 // escaped separator, i.e. "\,"
16853
16854 if (str_pos > 0)
16855 {
16856 if (mask[str_pos - 1] == '\\')
16857 {
16858 separator_cnt --;
16859
16860 mask_offset = str_pos + 1;
16861
16862 continue;
16863 }
16864 }
16865
16866 // reset the offset
16867
16868 mask_offset = 0;
16869
16870 mask[str_pos] = '\0';
16871
16872 switch (separator_cnt)
16873 {
16874 case 0:
16875 mp_reset_usr (mp_usr, 0);
16876
16877 custom_charset_1 = mask;
16878 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16879 break;
16880
16881 case 1:
16882 mp_reset_usr (mp_usr, 1);
16883
16884 custom_charset_2 = mask;
16885 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16886 break;
16887
16888 case 2:
16889 mp_reset_usr (mp_usr, 2);
16890
16891 custom_charset_3 = mask;
16892 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16893 break;
16894
16895 case 3:
16896 mp_reset_usr (mp_usr, 3);
16897
16898 custom_charset_4 = mask;
16899 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16900 break;
16901 }
16902
16903 mask = mask + str_pos + 1;
16904 }
16905 }
16906
16907 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16908 {
16909 if (maskpos > 0)
16910 {
16911 local_free (css_buf);
16912 local_free (data.root_css_buf);
16913 local_free (data.markov_css_buf);
16914
16915 local_free (masks[maskpos - 1]);
16916 }
16917
16918 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16919
16920 data.mask = mask;
16921 data.css_cnt = css_cnt;
16922 data.css_buf = css_buf;
16923
16924 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16925
16926 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16927
16928 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16929 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16930
16931 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16932
16933 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16934
16935 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16936 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16937
16938 data.root_css_buf = root_css_buf;
16939 data.markov_css_buf = markov_css_buf;
16940
16941 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16942
16943 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16944
16945 local_free (root_table_buf);
16946 local_free (markov_table_buf);
16947
16948 // args
16949
16950 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16951 {
16952 hc_device_param_t *device_param = &data.devices_param[device_id];
16953
16954 if (device_param->skipped) continue;
16955
16956 device_param->kernel_params_mp[0] = &device_param->d_combs;
16957 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16958 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16959
16960 device_param->kernel_params_mp_buf64[3] = 0;
16961 device_param->kernel_params_mp_buf32[4] = css_cnt;
16962 device_param->kernel_params_mp_buf32[5] = 0;
16963 device_param->kernel_params_mp_buf32[6] = 0;
16964 device_param->kernel_params_mp_buf32[7] = 0;
16965
16966 if (attack_mode == ATTACK_MODE_HYBRID1)
16967 {
16968 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16969 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16970 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16971 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16972 }
16973 else if (attack_mode == ATTACK_MODE_HYBRID2)
16974 {
16975 device_param->kernel_params_mp_buf32[5] = 0;
16976 device_param->kernel_params_mp_buf32[6] = 0;
16977 device_param->kernel_params_mp_buf32[7] = 0;
16978 }
16979
16980 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]);
16981 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]);
16982 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]);
16983
16984 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);
16985 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);
16986 }
16987 }
16988 else if (attack_mode == ATTACK_MODE_BF)
16989 {
16990 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16991
16992 if (increment)
16993 {
16994 for (uint i = 0; i < dictcnt; i++)
16995 {
16996 local_free (dictfiles[i]);
16997 }
16998
16999 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17000 {
17001 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17002
17003 if (l1_filename == NULL) break;
17004
17005 dictcnt++;
17006
17007 dictfiles[dictcnt - 1] = l1_filename;
17008 }
17009 }
17010 else
17011 {
17012 dictcnt++;
17013
17014 dictfiles[dictcnt - 1] = mask;
17015 }
17016
17017 if (dictcnt == 0)
17018 {
17019 log_error ("ERROR: Mask is too small");
17020
17021 return (-1);
17022 }
17023 }
17024 }
17025
17026 free (induction_dictionaries);
17027
17028 // induction_dictionaries_cnt = 0; // implied
17029
17030 if (attack_mode != ATTACK_MODE_BF)
17031 {
17032 if (keyspace == 0)
17033 {
17034 induction_dictionaries = scan_directory (induction_directory);
17035
17036 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17037 }
17038 }
17039
17040 if (induction_dictionaries_cnt)
17041 {
17042 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17043 }
17044
17045 /**
17046 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17047 */
17048 if (keyspace == 1)
17049 {
17050 if ((maskcnt > 1) || (dictcnt > 1))
17051 {
17052 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17053
17054 return (-1);
17055 }
17056 }
17057
17058 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17059 {
17060 char *subid = logfile_generate_subid ();
17061
17062 data.subid = subid;
17063
17064 logfile_sub_msg ("START");
17065
17066 data.devices_status = STATUS_INIT;
17067
17068 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17069 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17070 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17071
17072 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17073
17074 data.cpt_pos = 0;
17075
17076 data.cpt_start = time (NULL);
17077
17078 data.cpt_total = 0;
17079
17080 if (data.restore == 0)
17081 {
17082 rd->words_cur = skip;
17083
17084 skip = 0;
17085
17086 data.skip = 0;
17087 }
17088
17089 data.ms_paused = 0;
17090
17091 data.kernel_power_final = 0;
17092
17093 data.words_cur = rd->words_cur;
17094
17095 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17096 {
17097 hc_device_param_t *device_param = &data.devices_param[device_id];
17098
17099 if (device_param->skipped) continue;
17100
17101 device_param->speed_pos = 0;
17102
17103 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17104 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17105
17106 device_param->exec_pos = 0;
17107
17108 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17109
17110 device_param->outerloop_pos = 0;
17111 device_param->outerloop_left = 0;
17112 device_param->innerloop_pos = 0;
17113 device_param->innerloop_left = 0;
17114
17115 // some more resets:
17116
17117 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17118
17119 device_param->pws_cnt = 0;
17120
17121 device_param->words_off = 0;
17122 device_param->words_done = 0;
17123 }
17124
17125 // figure out some workload
17126
17127 if (attack_mode == ATTACK_MODE_STRAIGHT)
17128 {
17129 if (data.wordlist_mode == WL_MODE_FILE)
17130 {
17131 char *dictfile = NULL;
17132
17133 if (induction_dictionaries_cnt)
17134 {
17135 dictfile = induction_dictionaries[0];
17136 }
17137 else
17138 {
17139 dictfile = dictfiles[dictpos];
17140 }
17141
17142 data.dictfile = dictfile;
17143
17144 logfile_sub_string (dictfile);
17145
17146 for (uint i = 0; i < rp_files_cnt; i++)
17147 {
17148 logfile_sub_var_string ("rulefile", rp_files[i]);
17149 }
17150
17151 FILE *fd2 = fopen (dictfile, "rb");
17152
17153 if (fd2 == NULL)
17154 {
17155 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17156
17157 return (-1);
17158 }
17159
17160 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17161
17162 fclose (fd2);
17163
17164 if (data.words_cnt == 0)
17165 {
17166 if (data.devices_status == STATUS_CRACKED) break;
17167 if (data.devices_status == STATUS_ABORTED) break;
17168
17169 dictpos++;
17170
17171 continue;
17172 }
17173 }
17174 }
17175 else if (attack_mode == ATTACK_MODE_COMBI)
17176 {
17177 char *dictfile = data.dictfile;
17178 char *dictfile2 = data.dictfile2;
17179
17180 logfile_sub_string (dictfile);
17181 logfile_sub_string (dictfile2);
17182
17183 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17184 {
17185 FILE *fd2 = fopen (dictfile, "rb");
17186
17187 if (fd2 == NULL)
17188 {
17189 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17190
17191 return (-1);
17192 }
17193
17194 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17195
17196 fclose (fd2);
17197 }
17198 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17199 {
17200 FILE *fd2 = fopen (dictfile2, "rb");
17201
17202 if (fd2 == NULL)
17203 {
17204 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17205
17206 return (-1);
17207 }
17208
17209 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17210
17211 fclose (fd2);
17212 }
17213
17214 if (data.words_cnt == 0)
17215 {
17216 if (data.devices_status == STATUS_CRACKED) break;
17217 if (data.devices_status == STATUS_ABORTED) break;
17218
17219 dictpos++;
17220
17221 continue;
17222 }
17223 }
17224 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17225 {
17226 char *dictfile = NULL;
17227
17228 if (induction_dictionaries_cnt)
17229 {
17230 dictfile = induction_dictionaries[0];
17231 }
17232 else
17233 {
17234 dictfile = dictfiles[dictpos];
17235 }
17236
17237 data.dictfile = dictfile;
17238
17239 char *mask = data.mask;
17240
17241 logfile_sub_string (dictfile);
17242 logfile_sub_string (mask);
17243
17244 FILE *fd2 = fopen (dictfile, "rb");
17245
17246 if (fd2 == NULL)
17247 {
17248 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17249
17250 return (-1);
17251 }
17252
17253 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17254
17255 fclose (fd2);
17256
17257 if (data.words_cnt == 0)
17258 {
17259 if (data.devices_status == STATUS_CRACKED) break;
17260 if (data.devices_status == STATUS_ABORTED) break;
17261
17262 dictpos++;
17263
17264 continue;
17265 }
17266 }
17267 else if (attack_mode == ATTACK_MODE_BF)
17268 {
17269 local_free (css_buf);
17270 local_free (data.root_css_buf);
17271 local_free (data.markov_css_buf);
17272
17273 char *mask = dictfiles[dictpos];
17274
17275 logfile_sub_string (mask);
17276
17277 // base
17278
17279 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17280
17281 if (opts_type & OPTS_TYPE_PT_UNICODE)
17282 {
17283 uint css_cnt_unicode = css_cnt * 2;
17284
17285 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17286
17287 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17288 {
17289 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17290
17291 css_buf_unicode[j + 1].cs_buf[0] = 0;
17292 css_buf_unicode[j + 1].cs_len = 1;
17293 }
17294
17295 free (css_buf);
17296
17297 css_buf = css_buf_unicode;
17298 css_cnt = css_cnt_unicode;
17299 }
17300
17301 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17302
17303 uint mask_min = pw_min;
17304 uint mask_max = pw_max;
17305
17306 if (opts_type & OPTS_TYPE_PT_UNICODE)
17307 {
17308 mask_min *= 2;
17309 mask_max *= 2;
17310 }
17311
17312 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17313 {
17314 if (css_cnt < mask_min)
17315 {
17316 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17317 }
17318
17319 if (css_cnt > mask_max)
17320 {
17321 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17322 }
17323
17324 // skip to next mask
17325
17326 dictpos++;
17327
17328 rd->dictpos = dictpos;
17329
17330 logfile_sub_msg ("STOP");
17331
17332 continue;
17333 }
17334
17335 uint save_css_cnt = css_cnt;
17336
17337 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17338 {
17339 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17340 {
17341 uint salt_len = (uint) data.salts_buf[0].salt_len;
17342 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17343
17344 uint css_cnt_salt = css_cnt + salt_len;
17345
17346 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17347
17348 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17349
17350 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17351 {
17352 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17353 css_buf_salt[j].cs_len = 1;
17354 }
17355
17356 free (css_buf);
17357
17358 css_buf = css_buf_salt;
17359 css_cnt = css_cnt_salt;
17360 }
17361 }
17362
17363 data.mask = mask;
17364 data.css_cnt = css_cnt;
17365 data.css_buf = css_buf;
17366
17367 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17368
17369 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17370
17371 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17372
17373 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17374 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17375
17376 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17377
17378 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17379
17380 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17381 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17382
17383 data.root_css_buf = root_css_buf;
17384 data.markov_css_buf = markov_css_buf;
17385
17386 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17387
17388 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17389
17390 local_free (root_table_buf);
17391 local_free (markov_table_buf);
17392
17393 // copy + args
17394
17395 uint css_cnt_l = css_cnt;
17396 uint css_cnt_r;
17397
17398 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17399 {
17400 if (save_css_cnt < 6)
17401 {
17402 css_cnt_r = 1;
17403 }
17404 else if (save_css_cnt == 6)
17405 {
17406 css_cnt_r = 2;
17407 }
17408 else
17409 {
17410 if (opts_type & OPTS_TYPE_PT_UNICODE)
17411 {
17412 if (save_css_cnt == 8 || save_css_cnt == 10)
17413 {
17414 css_cnt_r = 2;
17415 }
17416 else
17417 {
17418 css_cnt_r = 4;
17419 }
17420 }
17421 else
17422 {
17423 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17424 {
17425 css_cnt_r = 3;
17426 }
17427 else
17428 {
17429 css_cnt_r = 4;
17430 }
17431 }
17432 }
17433 }
17434 else
17435 {
17436 css_cnt_r = 1;
17437
17438 /* unfinished code?
17439 int sum = css_buf[css_cnt_r - 1].cs_len;
17440
17441 for (uint i = 1; i < 4 && i < css_cnt; i++)
17442 {
17443 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17444
17445 css_cnt_r++;
17446
17447 sum *= css_buf[css_cnt_r - 1].cs_len;
17448 }
17449 */
17450 }
17451
17452 css_cnt_l -= css_cnt_r;
17453
17454 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17455
17456 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17457 {
17458 hc_device_param_t *device_param = &data.devices_param[device_id];
17459
17460 if (device_param->skipped) continue;
17461
17462 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17463 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17464 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17465
17466 device_param->kernel_params_mp_l_buf64[3] = 0;
17467 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17468 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17469 device_param->kernel_params_mp_l_buf32[6] = 0;
17470 device_param->kernel_params_mp_l_buf32[7] = 0;
17471 device_param->kernel_params_mp_l_buf32[8] = 0;
17472
17473 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17474 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17475 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17476 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17477
17478 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17479 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17480 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17481
17482 device_param->kernel_params_mp_r_buf64[3] = 0;
17483 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17484 device_param->kernel_params_mp_r_buf32[5] = 0;
17485 device_param->kernel_params_mp_r_buf32[6] = 0;
17486 device_param->kernel_params_mp_r_buf32[7] = 0;
17487
17488 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]);
17489 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]);
17490 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]);
17491
17492 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]);
17493 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]);
17494 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]);
17495
17496 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);
17497 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);
17498 }
17499 }
17500
17501 u64 words_base = data.words_cnt;
17502
17503 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17504 {
17505 if (data.kernel_rules_cnt)
17506 {
17507 words_base /= data.kernel_rules_cnt;
17508 }
17509 }
17510 else if (data.attack_kern == ATTACK_KERN_COMBI)
17511 {
17512 if (data.combs_cnt)
17513 {
17514 words_base /= data.combs_cnt;
17515 }
17516 }
17517 else if (data.attack_kern == ATTACK_KERN_BF)
17518 {
17519 if (data.bfs_cnt)
17520 {
17521 words_base /= data.bfs_cnt;
17522 }
17523 }
17524
17525 data.words_base = words_base;
17526
17527 if (keyspace == 1)
17528 {
17529 log_info ("%llu", (unsigned long long int) words_base);
17530
17531 return (0);
17532 }
17533
17534 if (data.words_cur > data.words_base)
17535 {
17536 log_error ("ERROR: restore value greater keyspace");
17537
17538 return (-1);
17539 }
17540
17541 if (data.words_cur)
17542 {
17543 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17544 {
17545 for (uint i = 0; i < data.salts_cnt; i++)
17546 {
17547 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17548 }
17549 }
17550 else if (data.attack_kern == ATTACK_KERN_COMBI)
17551 {
17552 for (uint i = 0; i < data.salts_cnt; i++)
17553 {
17554 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17555 }
17556 }
17557 else if (data.attack_kern == ATTACK_KERN_BF)
17558 {
17559 for (uint i = 0; i < data.salts_cnt; i++)
17560 {
17561 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17562 }
17563 }
17564 }
17565
17566 /*
17567 * Update loopback file
17568 */
17569
17570 if (loopback == 1)
17571 {
17572 time_t now;
17573
17574 time (&now);
17575
17576 uint random_num = get_random_num (0, 9999);
17577
17578 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17579
17580 data.loopback_file = loopback_file;
17581 }
17582
17583 /*
17584 * Update dictionary statistic
17585 */
17586
17587 if (keyspace == 0)
17588 {
17589 dictstat_fp = fopen (dictstat, "wb");
17590
17591 if (dictstat_fp)
17592 {
17593 lock_file (dictstat_fp);
17594
17595 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17596
17597 fclose (dictstat_fp);
17598 }
17599 }
17600
17601 /**
17602 * create autotune threads
17603 */
17604
17605 data.devices_status = STATUS_AUTOTUNE;
17606
17607 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17608
17609 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17610 {
17611 hc_device_param_t *device_param = &devices_param[device_id];
17612
17613 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
17614 }
17615
17616 hc_thread_wait (data.devices_cnt, c_threads);
17617
17618 /*
17619 * Inform user about possible slow speeds
17620 */
17621
17622 uint hardware_power_all = 0;
17623
17624 uint kernel_power_all = 0;
17625
17626 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17627 {
17628 hc_device_param_t *device_param = &devices_param[device_id];
17629
17630 hardware_power_all += device_param->hardware_power;
17631
17632 kernel_power_all += device_param->kernel_power;
17633 }
17634
17635 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
17636
17637 data.kernel_power_all = kernel_power_all;
17638
17639 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17640 {
17641 if (data.words_base < kernel_power_all)
17642 {
17643 if (quiet == 0)
17644 {
17645 log_info ("ATTENTION!");
17646 log_info (" The wordlist or mask you are using is too small.");
17647 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17648 log_info (" The cracking speed will drop.");
17649 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17650 log_info ("");
17651 }
17652 }
17653 }
17654
17655 /**
17656 * create cracker threads
17657 */
17658
17659 data.devices_status = STATUS_RUNNING;
17660
17661 if (initial_restore_done == 0)
17662 {
17663 if (data.restore_disable == 0) cycle_restore ();
17664
17665 initial_restore_done = 1;
17666 }
17667
17668 hc_timer_set (&data.timer_running);
17669
17670 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17671 {
17672 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17673 {
17674 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17675 if (quiet == 0) fflush (stdout);
17676 }
17677 }
17678 else if (wordlist_mode == WL_MODE_STDIN)
17679 {
17680 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17681 if (data.quiet == 0) log_info ("");
17682 }
17683
17684 time_t runtime_start;
17685
17686 time (&runtime_start);
17687
17688 data.runtime_start = runtime_start;
17689
17690 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17691 {
17692 hc_device_param_t *device_param = &devices_param[device_id];
17693
17694 if (wordlist_mode == WL_MODE_STDIN)
17695 {
17696 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17697 }
17698 else
17699 {
17700 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17701 }
17702 }
17703
17704 hc_thread_wait (data.devices_cnt, c_threads);
17705
17706 local_free (c_threads);
17707
17708 data.restore = 0;
17709
17710 // finalize task
17711
17712 logfile_sub_var_uint ("status-after-work", data.devices_status);
17713
17714 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17715
17716 if (data.devices_status == STATUS_CRACKED) break;
17717 if (data.devices_status == STATUS_ABORTED) break;
17718
17719 if (data.devices_status == STATUS_BYPASS)
17720 {
17721 data.devices_status = STATUS_RUNNING;
17722 }
17723
17724 if (induction_dictionaries_cnt)
17725 {
17726 unlink (induction_dictionaries[0]);
17727 }
17728
17729 free (induction_dictionaries);
17730
17731 if (attack_mode != ATTACK_MODE_BF)
17732 {
17733 induction_dictionaries = scan_directory (induction_directory);
17734
17735 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17736 }
17737
17738 if (benchmark == 0)
17739 {
17740 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17741 {
17742 if (quiet == 0) clear_prompt ();
17743
17744 if (quiet == 0) log_info ("");
17745
17746 if (status == 1)
17747 {
17748 status_display ();
17749 }
17750 else
17751 {
17752 if (quiet == 0) status_display ();
17753 }
17754
17755 if (quiet == 0) log_info ("");
17756 }
17757 }
17758
17759 if (attack_mode == ATTACK_MODE_BF)
17760 {
17761 dictpos++;
17762
17763 rd->dictpos = dictpos;
17764 }
17765 else
17766 {
17767 if (induction_dictionaries_cnt)
17768 {
17769 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17770 }
17771 else
17772 {
17773 dictpos++;
17774
17775 rd->dictpos = dictpos;
17776 }
17777 }
17778
17779 time_t runtime_stop;
17780
17781 time (&runtime_stop);
17782
17783 data.runtime_stop = runtime_stop;
17784
17785 logfile_sub_uint (runtime_start);
17786 logfile_sub_uint (runtime_stop);
17787
17788 logfile_sub_msg ("STOP");
17789
17790 global_free (subid);
17791 }
17792
17793 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17794
17795 if (data.devices_status == STATUS_CRACKED) break;
17796 if (data.devices_status == STATUS_ABORTED) break;
17797 if (data.devices_status == STATUS_QUIT) break;
17798
17799 if (data.devices_status == STATUS_BYPASS)
17800 {
17801 data.devices_status = STATUS_RUNNING;
17802 }
17803 }
17804
17805 // 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
17806
17807 if (attack_mode == ATTACK_MODE_STRAIGHT)
17808 {
17809 if (data.wordlist_mode == WL_MODE_FILE)
17810 {
17811 if (data.dictfile == NULL)
17812 {
17813 if (dictfiles != NULL)
17814 {
17815 data.dictfile = dictfiles[0];
17816
17817 hc_timer_set (&data.timer_running);
17818 }
17819 }
17820 }
17821 }
17822 // NOTE: combi is okay because it is already set beforehand
17823 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17824 {
17825 if (data.dictfile == NULL)
17826 {
17827 if (dictfiles != NULL)
17828 {
17829 hc_timer_set (&data.timer_running);
17830
17831 data.dictfile = dictfiles[0];
17832 }
17833 }
17834 }
17835 else if (attack_mode == ATTACK_MODE_BF)
17836 {
17837 if (data.mask == NULL)
17838 {
17839 hc_timer_set (&data.timer_running);
17840
17841 data.mask = masks[0];
17842 }
17843 }
17844
17845 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17846 {
17847 data.devices_status = STATUS_EXHAUSTED;
17848 }
17849
17850 // if cracked / aborted remove last induction dictionary
17851
17852 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17853 {
17854 struct stat induct_stat;
17855
17856 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17857 {
17858 unlink (induction_dictionaries[file_pos]);
17859 }
17860 }
17861
17862 // wait for non-interactive threads
17863
17864 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17865 {
17866 hc_thread_wait (1, &ni_threads[thread_idx]);
17867 }
17868
17869 local_free (ni_threads);
17870
17871 // wait for interactive threads
17872
17873 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17874 {
17875 hc_thread_wait (1, &i_thread);
17876 }
17877
17878 // we dont need restore file anymore
17879 if (data.restore_disable == 0)
17880 {
17881 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17882 {
17883 unlink (eff_restore_file);
17884 unlink (new_restore_file);
17885 }
17886 else
17887 {
17888 cycle_restore ();
17889 }
17890 }
17891
17892 // finally save left hashes
17893
17894 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17895 {
17896 save_hash ();
17897 }
17898
17899 /**
17900 * Clean up
17901 */
17902
17903 if (benchmark == 1)
17904 {
17905 status_benchmark ();
17906
17907 if (machine_readable == 0)
17908 {
17909 log_info ("");
17910 }
17911 }
17912 else
17913 {
17914 if (quiet == 0) clear_prompt ();
17915
17916 if (quiet == 0) log_info ("");
17917
17918 if (status == 1)
17919 {
17920 status_display ();
17921 }
17922 else
17923 {
17924 if (quiet == 0) status_display ();
17925 }
17926
17927 if (quiet == 0) log_info ("");
17928 }
17929
17930 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17931 {
17932 hc_device_param_t *device_param = &data.devices_param[device_id];
17933
17934 if (device_param->skipped) continue;
17935
17936 local_free (device_param->combs_buf);
17937
17938 local_free (device_param->hooks_buf);
17939
17940 local_free (device_param->device_name);
17941
17942 local_free (device_param->device_name_chksum);
17943
17944 local_free (device_param->device_version);
17945
17946 local_free (device_param->driver_version);
17947
17948 if (device_param->pws_buf) myfree (device_param->pws_buf);
17949 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17950 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17951 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17952 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17953 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17954 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17955 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17956 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17957 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17958 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17959 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17960 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17961 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17962 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17963 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17964 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17965 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17966 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17967 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17968 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17969 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17970 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17971 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17972 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17973 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17974 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17975 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17976 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17977
17978 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17979 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17980 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17981 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17982 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17983 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17984 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17985 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17986 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17987 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17988 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17989
17990 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17991 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17992 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17993
17994 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17995 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17996 }
17997
17998 // reset default fan speed
17999
18000 #ifdef HAVE_HWMON
18001 if (gpu_temp_disable == 0)
18002 {
18003 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
18004 {
18005 hc_thread_mutex_lock (mux_adl);
18006
18007 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18008 {
18009 hc_device_param_t *device_param = &data.devices_param[device_id];
18010
18011 if (device_param->skipped) continue;
18012
18013 if (data.hm_device[device_id].fan_set_supported == 1)
18014 {
18015 int fanspeed = temp_retain_fanspeed_value[device_id];
18016 int fanpolicy = temp_retain_fanpolicy_value[device_id];
18017
18018 if (fanpolicy == 1)
18019 {
18020 int rc = -1;
18021
18022 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18023 {
18024 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
18025 }
18026 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18027 {
18028
18029 }
18030
18031 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18032 }
18033 }
18034 }
18035
18036 hc_thread_mutex_unlock (mux_adl);
18037 }
18038 }
18039
18040 // reset power tuning
18041
18042 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18043 {
18044 hc_thread_mutex_lock (mux_adl);
18045
18046 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18047 {
18048 hc_device_param_t *device_param = &data.devices_param[device_id];
18049
18050 if (device_param->skipped) continue;
18051
18052 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18053 {
18054 if (data.hm_device[device_id].od_version == 6)
18055 {
18056 // check powertune capabilities first, if not available then skip device
18057
18058 int powertune_supported = 0;
18059
18060 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18061 {
18062 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18063
18064 return (-1);
18065 }
18066
18067 if (powertune_supported != 0)
18068 {
18069 // powercontrol settings
18070
18071 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18072 {
18073 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18074
18075 return (-1);
18076 }
18077
18078 // clocks
18079
18080 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18081
18082 performance_state->iNumberOfPerformanceLevels = 2;
18083
18084 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18085 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18086 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18087 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18088
18089 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18090 {
18091 log_info ("ERROR: Failed to restore ADL performance state");
18092
18093 return (-1);
18094 }
18095
18096 local_free (performance_state);
18097 }
18098 }
18099 }
18100
18101 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18102 {
18103 unsigned int limit = nvml_power_limit[device_id];
18104
18105 if (limit > 0)
18106 {
18107 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18108 }
18109 }
18110 }
18111
18112 hc_thread_mutex_unlock (mux_adl);
18113 }
18114
18115 if (gpu_temp_disable == 0)
18116 {
18117 if (data.hm_nvml)
18118 {
18119 hm_NVML_nvmlShutdown (data.hm_nvml);
18120
18121 nvml_close (data.hm_nvml);
18122
18123 data.hm_nvml = NULL;
18124 }
18125
18126 if (data.hm_adl)
18127 {
18128 hm_ADL_Main_Control_Destroy (data.hm_adl);
18129
18130 adl_close (data.hm_adl);
18131
18132 data.hm_adl = NULL;
18133 }
18134 }
18135 #endif // HAVE_HWMON
18136
18137 // free memory
18138
18139 local_free (masks);
18140
18141 local_free (dictstat_base);
18142
18143 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18144 {
18145 pot_t *pot_ptr = &pot[pot_pos];
18146
18147 hash_t *hash = &pot_ptr->hash;
18148
18149 local_free (hash->digest);
18150
18151 if (isSalted)
18152 {
18153 local_free (hash->salt);
18154 }
18155 }
18156
18157 local_free (pot);
18158
18159 local_free (all_kernel_rules_cnt);
18160 local_free (all_kernel_rules_buf);
18161
18162 local_free (wl_data->buf);
18163 local_free (wl_data);
18164
18165 local_free (bitmap_s1_a);
18166 local_free (bitmap_s1_b);
18167 local_free (bitmap_s1_c);
18168 local_free (bitmap_s1_d);
18169 local_free (bitmap_s2_a);
18170 local_free (bitmap_s2_b);
18171 local_free (bitmap_s2_c);
18172 local_free (bitmap_s2_d);
18173
18174 #ifdef HAVE_HWMON
18175 local_free (temp_retain_fanspeed_value);
18176 local_free (od_clock_mem_status);
18177 local_free (od_power_control_status);
18178 local_free (nvml_power_limit);
18179 #endif
18180
18181 global_free (devices_param);
18182
18183 global_free (kernel_rules_buf);
18184
18185 global_free (root_css_buf);
18186 global_free (markov_css_buf);
18187
18188 global_free (digests_buf);
18189 global_free (digests_shown);
18190 global_free (digests_shown_tmp);
18191
18192 global_free (salts_buf);
18193 global_free (salts_shown);
18194
18195 global_free (esalts_buf);
18196
18197 global_free (words_progress_done);
18198 global_free (words_progress_rejected);
18199 global_free (words_progress_restored);
18200
18201 if (pot_fp) fclose (pot_fp);
18202
18203 if (data.devices_status == STATUS_QUIT) break;
18204 }
18205
18206 // destroy others mutex
18207
18208 hc_thread_mutex_delete (mux_dispatcher);
18209 hc_thread_mutex_delete (mux_counter);
18210 hc_thread_mutex_delete (mux_display);
18211 hc_thread_mutex_delete (mux_adl);
18212
18213 // free memory
18214
18215 local_free (eff_restore_file);
18216 local_free (new_restore_file);
18217
18218 local_free (rd);
18219
18220 // tuning db
18221
18222 tuning_db_destroy (tuning_db);
18223
18224 // loopback
18225
18226 local_free (loopback_file);
18227
18228 if (loopback == 1) unlink (loopback_file);
18229
18230 // induction directory
18231
18232 if (induction_dir == NULL)
18233 {
18234 if (attack_mode != ATTACK_MODE_BF)
18235 {
18236 if (rmdir (induction_directory) == -1)
18237 {
18238 if (errno == ENOENT)
18239 {
18240 // good, we can ignore
18241 }
18242 else if (errno == ENOTEMPTY)
18243 {
18244 // good, we can ignore
18245 }
18246 else
18247 {
18248 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18249
18250 return (-1);
18251 }
18252 }
18253
18254 local_free (induction_directory);
18255 }
18256 }
18257
18258 // outfile-check directory
18259
18260 if (outfile_check_dir == NULL)
18261 {
18262 if (rmdir (outfile_check_directory) == -1)
18263 {
18264 if (errno == ENOENT)
18265 {
18266 // good, we can ignore
18267 }
18268 else if (errno == ENOTEMPTY)
18269 {
18270 // good, we can ignore
18271 }
18272 else
18273 {
18274 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18275
18276 return (-1);
18277 }
18278 }
18279
18280 local_free (outfile_check_directory);
18281 }
18282
18283 time_t proc_stop;
18284
18285 time (&proc_stop);
18286
18287 logfile_top_uint (proc_start);
18288 logfile_top_uint (proc_stop);
18289
18290 logfile_top_msg ("STOP");
18291
18292 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18293 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18294
18295 if (data.ocl) ocl_close (data.ocl);
18296
18297 if (data.devices_status == STATUS_ABORTED) return 2;
18298 if (data.devices_status == STATUS_QUIT) return 2;
18299 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18300 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18301 if (data.devices_status == STATUS_CRACKED) return 0;
18302
18303 return -1;
18304 }
Hashcat additions to support pwdhash