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