projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
No need to check for cracked hashes in benchmark mode
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define MACHINE_READABLE 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 0
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
152
153 #define NVIDIA_100PERCENTCPU_WORKAROUND 100
154
155 #define global_free(attr) \
156 { \
157 myfree ((void *) data.attr); \
158 \
159 data.attr = NULL; \
160 }
161
162 #define local_free(attr) \
163 { \
164 myfree ((void *) attr); \
165 \
166 attr = NULL; \
167 }
168
169 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
170 #define HC_API_CALL __stdcall
171 #else
172 #define HC_API_CALL
173 #endif
174
175 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
176 {
177 900,
178 0,
179 5100,
180 100,
181 1400,
182 10800,
183 1700,
184 5000,
185 10100,
186 6000,
187 6100,
188 6900,
189 11700,
190 11800,
191 400,
192 8900,
193 11900,
194 12000,
195 10900,
196 12100,
197 23,
198 2500,
199 5300,
200 5400,
201 5500,
202 5600,
203 7300,
204 7500,
205 13100,
206 8300,
207 11100,
208 11200,
209 11400,
210 121,
211 2611,
212 2711,
213 2811,
214 8400,
215 11,
216 2612,
217 7900,
218 21,
219 11000,
220 124,
221 10000,
222 3711,
223 7600,
224 12,
225 131,
226 132,
227 1731,
228 200,
229 300,
230 3100,
231 112,
232 12300,
233 8000,
234 141,
235 1441,
236 1600,
237 12600,
238 1421,
239 101,
240 111,
241 1711,
242 3000,
243 1000,
244 1100,
245 2100,
246 12800,
247 1500,
248 12400,
249 500,
250 3200,
251 7400,
252 1800,
253 122,
254 1722,
255 7100,
256 6300,
257 6700,
258 6400,
259 6500,
260 2400,
261 2410,
262 5700,
263 9200,
264 9300,
265 22,
266 501,
267 5800,
268 8100,
269 8500,
270 7200,
271 9900,
272 7700,
273 7800,
274 10300,
275 8600,
276 8700,
277 9100,
278 133,
279 13500,
280 11600,
281 13600,
282 12500,
283 13000,
284 13200,
285 13300,
286 6211,
287 6221,
288 6231,
289 6241,
290 13711,
291 13721,
292 13731,
293 13741,
294 13751,
295 13761,
296 8800,
297 12900,
298 12200,
299 9700,
300 9710,
301 9800,
302 9810,
303 9400,
304 9500,
305 9600,
306 10400,
307 10410,
308 10500,
309 10600,
310 10700,
311 9000,
312 5200,
313 6800,
314 6600,
315 8200,
316 11300,
317 12700,
318 13400,
319 125
320 };
321
322 /**
323 * types
324 */
325
326 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
327
328 /**
329 * globals
330 */
331
332 static unsigned int full01 = 0x01010101;
333 static unsigned int full80 = 0x80808080;
334
335 int SUPPRESS_OUTPUT = 0;
336
337 hc_thread_mutex_t mux_adl;
338 hc_thread_mutex_t mux_counter;
339 hc_thread_mutex_t mux_dispatcher;
340 hc_thread_mutex_t mux_display;
341
342 hc_global_data_t data;
343
344 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
345
346 const char *USAGE_MINI[] =
347 {
348 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
349 "",
350 "Try --help for more help.",
351 NULL
352 };
353
354 const char *USAGE_BIG[] =
355 {
356 "%s, advanced password recovery",
357 "",
358 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
359 "",
360 "- [ Options ] -",
361 "",
362 " Options Short / Long | Type | Description | Example",
363 "===============================|======|======================================================|=======================",
364 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
365 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
366 " -V, --version | | Print version |",
367 " -h, --help | | Print help |",
368 " --quiet | | Suppress output |",
369 " --hex-charset | | Assume charset is given in hex |",
370 " --hex-salt | | Assume salt is given in hex |",
371 " --hex-wordlist | | Assume words in wordlist is given in hex |",
372 " --force | | Ignore warnings |",
373 " --status | | Enable automatic update of the status-screen |",
374 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
375 " --machine-readable | | Display the status view in a machine readable format |",
376 " --loopback | | Add new plains to induct directory |",
377 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
378 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
379 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
380 " --markov-classic | | Enables classic markov-chains, no per-position |",
381 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
382 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
383 " --session | Str | Define specific session name | --session=mysession",
384 " --restore | | Restore session from --session |",
385 " --restore-disable | | Do not write restore file |",
386 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
387 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
388 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
389 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
390 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
391 " --show | | Show cracked passwords only |",
392 " --left | | Show un-cracked passwords only |",
393 " --username | | Enable ignoring of usernames in hashfile |",
394 " --remove | | Enable remove of hash once it is cracked |",
395 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
396 " --potfile-disable | | Do not write potfile |",
397 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
398 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
399 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
400 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
401 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
402 " --logfile-disable | | Disable the logfile |",
403 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
404 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
405 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
406 " -b, --benchmark | | Run benchmark |",
407 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
408 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
409 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
410 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
411 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
412 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
413 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
414 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
415 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
416 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
417 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
418 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
419 #ifdef HAVE_HWMON
420 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
421 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
422 " --powertune-enable | | Enable power tuning, restores settings when finished |",
423 #endif
424 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
425 " -s, --skip | Num | Skip X words from the start | -s 1000000",
426 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
427 " --keyspace | | Show keyspace base:mod values and quit |",
428 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
429 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
430 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
431 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
432 " --generate-rules-func-min | Num | Force min X funcs per rule |",
433 " --generate-rules-func-max | Num | Force max X funcs per rule |",
434 " --generate-rules-seed | Num | Force RNG seed set to X |",
435 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
436 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
437 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
438 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
439 " -i, --increment | | Enable mask increment mode |",
440 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
441 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
442 "",
443 "- [ Hash modes ] -",
444 "",
445 " # | Name | Category",
446 " ======+==================================================+======================================",
447 " 900 | MD4 | Raw Hash",
448 " 0 | MD5 | Raw Hash",
449 " 5100 | Half MD5 | Raw Hash",
450 " 100 | SHA1 | Raw Hash",
451 " 10800 | SHA-384 | Raw Hash",
452 " 1400 | SHA-256 | Raw Hash",
453 " 1700 | SHA-512 | Raw Hash",
454 " 5000 | SHA-3(Keccak) | Raw Hash",
455 " 10100 | SipHash | Raw Hash",
456 " 6000 | RipeMD160 | Raw Hash",
457 " 6100 | Whirlpool | Raw Hash",
458 " 6900 | GOST R 34.11-94 | Raw Hash",
459 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
460 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
461 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
462 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
463 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
464 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
465 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
466 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
467 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
468 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
469 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
470 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
471 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
472 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
473 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
474 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
475 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
476 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
477 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
478 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
479 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
480 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
481 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
482 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
483 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
484 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
485 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
486 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
487 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
488 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
489 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
490 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
491 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
492 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
493 " 400 | phpass | Generic KDF",
494 " 8900 | scrypt | Generic KDF",
495 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
496 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
497 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
498 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
499 " 23 | Skype | Network protocols",
500 " 2500 | WPA/WPA2 | Network protocols",
501 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
502 " 5300 | IKE-PSK MD5 | Network protocols",
503 " 5400 | IKE-PSK SHA1 | Network protocols",
504 " 5500 | NetNTLMv1 | Network protocols",
505 " 5500 | NetNTLMv1 + ESS | Network protocols",
506 " 5600 | NetNTLMv2 | Network protocols",
507 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
508 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
509 " 8300 | DNSSEC (NSEC3) | Network protocols",
510 " 10200 | Cram MD5 | Network protocols",
511 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
512 " 11200 | MySQL CRAM (SHA1) | Network protocols",
513 " 11400 | SIP digest authentication (MD5) | Network protocols",
514 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
515 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
516 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
517 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
518 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
519 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
520 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
521 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
522 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
523 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
524 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
525 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
526 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
527 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
528 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
529 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
530 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
531 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
532 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
533 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
534 " 12 | PostgreSQL | Database Server",
535 " 131 | MSSQL(2000) | Database Server",
536 " 132 | MSSQL(2005) | Database Server",
537 " 1731 | MSSQL(2012) | Database Server",
538 " 1731 | MSSQL(2014) | Database Server",
539 " 200 | MySQL323 | Database Server",
540 " 300 | MySQL4.1/MySQL5 | Database Server",
541 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
542 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
543 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
544 " 8000 | Sybase ASE | Database Server",
545 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
546 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
547 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
548 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
549 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
550 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
551 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
552 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
553 " 11500 | CRC32 | Checksums",
554 " 3000 | LM | Operating-Systems",
555 " 1000 | NTLM | Operating-Systems",
556 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
557 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
558 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
559 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
560 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
561 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
562 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
563 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
564 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
565 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
566 " 1722 | OSX v10.7 | Operating-Systems",
567 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
568 " 6300 | AIX {smd5} | Operating-Systems",
569 " 6700 | AIX {ssha1} | Operating-Systems",
570 " 6400 | AIX {ssha256} | Operating-Systems",
571 " 6500 | AIX {ssha512} | Operating-Systems",
572 " 2400 | Cisco-PIX | Operating-Systems",
573 " 2410 | Cisco-ASA | Operating-Systems",
574 " 500 | Cisco-IOS $1$ | Operating-Systems",
575 " 5700 | Cisco-IOS $4$ | Operating-Systems",
576 " 9200 | Cisco-IOS $8$ | Operating-Systems",
577 " 9300 | Cisco-IOS $9$ | Operating-Systems",
578 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
579 " 501 | Juniper IVE | Operating-Systems",
580 " 5800 | Android PIN | Operating-Systems",
581 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
582 " 8100 | Citrix Netscaler | Operating-Systems",
583 " 8500 | RACF | Operating-Systems",
584 " 7200 | GRUB 2 | Operating-Systems",
585 " 9900 | Radmin2 | Operating-Systems",
586 " 125 | ArubaOS | Operating-Systems",
587 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
588 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
589 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
590 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
591 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
592 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
593 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
594 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
595 " 11600 | 7-Zip | Archives",
596 " 12500 | RAR3-hp | Archives",
597 " 13000 | RAR5 | Archives",
598 " 13200 | AxCrypt | Archives",
599 " 13300 | AxCrypt in memory SHA1 | Archives",
600 " 13600 | WinZip | Archives",
601 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
602 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
603 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
604 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
605 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
606 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
607 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
608 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
609 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
610 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
611 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
612 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
613 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
614 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
615 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
616 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
617 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
618 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
619 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
620 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
621 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
622 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
623 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
624 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
625 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
626 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
627 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
628 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
629 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
630 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
631 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
632 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
633 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
634 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
635 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
636 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
637 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
638 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
639 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
640 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
641 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
642 " 9400 | MS Office 2007 | Documents",
643 " 9500 | MS Office 2010 | Documents",
644 " 9600 | MS Office 2013 | Documents",
645 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
646 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
647 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
648 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
649 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
650 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
651 " 9000 | Password Safe v2 | Password Managers",
652 " 5200 | Password Safe v3 | Password Managers",
653 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
654 " 6600 | 1Password, agilekeychain | Password Managers",
655 " 8200 | 1Password, cloudkeychain | Password Managers",
656 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
657 " 12700 | Blockchain, My Wallet | Password Managers",
658 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
659 "",
660 "- [ Outfile Formats ] -",
661 "",
662 " # | Format",
663 " ===+========",
664 " 1 | hash[:salt]",
665 " 2 | plain",
666 " 3 | hash[:salt]:plain",
667 " 4 | hex_plain",
668 " 5 | hash[:salt]:hex_plain",
669 " 6 | plain:hex_plain",
670 " 7 | hash[:salt]:plain:hex_plain",
671 " 8 | crackpos",
672 " 9 | hash[:salt]:crack_pos",
673 " 10 | plain:crack_pos",
674 " 11 | hash[:salt]:plain:crack_pos",
675 " 12 | hex_plain:crack_pos",
676 " 13 | hash[:salt]:hex_plain:crack_pos",
677 " 14 | plain:hex_plain:crack_pos",
678 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
679 "",
680 "- [ Rule Debugging Modes ] -",
681 "",
682 " # | Format",
683 " ===+========",
684 " 1 | Finding-Rule",
685 " 2 | Original-Word",
686 " 3 | Original-Word:Finding-Rule",
687 " 4 | Original-Word:Finding-Rule:Processed-Word",
688 "",
689 "- [ Attack Modes ] -",
690 "",
691 " # | Mode",
692 " ===+======",
693 " 0 | Straight",
694 " 1 | Combination",
695 " 3 | Brute-force",
696 " 6 | Hybrid Wordlist + Mask",
697 " 7 | Hybrid Mask + Wordlist",
698 "",
699 "- [ Built-in Charsets ] -",
700 "",
701 " ? | Charset",
702 " ===+=========",
703 " l | abcdefghijklmnopqrstuvwxyz",
704 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
705 " d | 0123456789",
706 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
707 " a | ?l?u?d?s",
708 " b | 0x00 - 0xff",
709 "",
710 "- [ OpenCL Device Types ] -",
711 "",
712 " # | Device Type",
713 " ===+=============",
714 " 1 | CPU",
715 " 2 | GPU",
716 " 3 | FPGA, DSP, Co-Processor",
717 "",
718 "- [ Workload Profiles ] -",
719 "",
720 " # | Performance | Runtime | Power Consumption | Desktop Impact",
721 " ===+=============+=========+===================+=================",
722 " 1 | Low | 2 ms | Low | Minimal",
723 " 2 | Default | 12 ms | Economic | Noticeable",
724 " 3 | High | 96 ms | High | Unresponsive",
725 " 4 | Nightmare | 480 ms | Insane | Headless",
726 "",
727 "If you have no idea what just happened then visit the following pages:",
728 "",
729 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
730 "* https://hashcat.net/wiki/#frequently_asked_questions",
731 "",
732 NULL
733 };
734
735 /**
736 * hashcat specific functions
737 */
738
739 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
740 {
741 int exec_pos = (int) device_param->exec_pos - last_num_entries;
742
743 if (exec_pos < 0) exec_pos += EXEC_CACHE;
744
745 double exec_ms_sum = 0;
746
747 int exec_ms_cnt = 0;
748
749 for (int i = 0; i < last_num_entries; i++)
750 {
751 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
752
753 if (exec_ms)
754 {
755 exec_ms_sum += exec_ms;
756
757 exec_ms_cnt++;
758 }
759 }
760
761 if (exec_ms_cnt == 0) return 0;
762
763 return exec_ms_sum / exec_ms_cnt;
764 }
765
766 void status_display_machine_readable ()
767 {
768 FILE *out = stdout;
769
770 fprintf (out, "STATUS\t%u\t", data.devices_status);
771
772 /**
773 * speed new
774 */
775
776 fprintf (out, "SPEED\t");
777
778 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
779 {
780 hc_device_param_t *device_param = &data.devices_param[device_id];
781
782 if (device_param->skipped) continue;
783
784 u64 speed_cnt = 0;
785 double speed_ms = 0;
786
787 for (int i = 0; i < SPEED_CACHE; i++)
788 {
789 speed_cnt += device_param->speed_cnt[i];
790 speed_ms += device_param->speed_ms[i];
791 }
792
793 speed_cnt /= SPEED_CACHE;
794 speed_ms /= SPEED_CACHE;
795
796 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
797 }
798
799 /**
800 * exec time
801 */
802
803 fprintf (out, "EXEC_RUNTIME\t");
804
805 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
806 {
807 hc_device_param_t *device_param = &data.devices_param[device_id];
808
809 if (device_param->skipped) continue;
810
811 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
812
813 fprintf (out, "%f\t", exec_ms_avg);
814 }
815
816 /**
817 * words_cur
818 */
819
820 u64 words_cur = get_lowest_words_done ();
821
822 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
823
824 /**
825 * counter
826 */
827
828 u64 progress_total = data.words_cnt * data.salts_cnt;
829
830 u64 all_done = 0;
831 u64 all_rejected = 0;
832 u64 all_restored = 0;
833
834 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
835 {
836 all_done += data.words_progress_done[salt_pos];
837 all_rejected += data.words_progress_rejected[salt_pos];
838 all_restored += data.words_progress_restored[salt_pos];
839 }
840
841 u64 progress_cur = all_restored + all_done + all_rejected;
842 u64 progress_end = progress_total;
843
844 u64 progress_skip = 0;
845
846 if (data.skip)
847 {
848 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
849
850 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
851 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
852 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
853 }
854
855 if (data.limit)
856 {
857 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
858
859 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
860 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
861 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
862 }
863
864 u64 progress_cur_relative_skip = progress_cur - progress_skip;
865 u64 progress_end_relative_skip = progress_end - progress_skip;
866
867 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
868
869 /**
870 * cracks
871 */
872
873 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
874 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
875
876 /**
877 * temperature
878 */
879
880 #ifdef HAVE_HWMON
881 if (data.gpu_temp_disable == 0)
882 {
883 fprintf (out, "TEMP\t");
884
885 hc_thread_mutex_lock (mux_adl);
886
887 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
888 {
889 hc_device_param_t *device_param = &data.devices_param[device_id];
890
891 if (device_param->skipped) continue;
892
893 int temp = hm_get_temperature_with_device_id (device_id);
894
895 fprintf (out, "%d\t", temp);
896 }
897
898 hc_thread_mutex_unlock (mux_adl);
899 }
900 #endif // HAVE_HWMON
901
902 /**
903 * flush
904 */
905
906 #ifdef _WIN
907 fputc ('\r', out);
908 fputc ('\n', out);
909 #endif
910
911 #ifdef _POSIX
912 fputc ('\n', out);
913 #endif
914
915 fflush (out);
916 }
917
918 void status_display ()
919 {
920 if (data.devices_status == STATUS_INIT) return;
921 if (data.devices_status == STATUS_STARTING) return;
922 if (data.devices_status == STATUS_BYPASS) return;
923
924 if (data.machine_readable == 1)
925 {
926 status_display_machine_readable ();
927
928 return;
929 }
930
931 char tmp_buf[1000] = { 0 };
932
933 uint tmp_len = 0;
934
935 log_info ("Session.Name...: %s", data.session);
936
937 char *status_type = strstatus (data.devices_status);
938
939 uint hash_mode = data.hash_mode;
940
941 char *hash_type = strhashtype (hash_mode); // not a bug
942
943 log_info ("Status.........: %s", status_type);
944
945 /**
946 * show rules
947 */
948
949 if (data.rp_files_cnt)
950 {
951 uint i;
952
953 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
954 {
955 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
956 }
957
958 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
959
960 log_info ("Rules.Type.....: %s", tmp_buf);
961
962 tmp_len = 0;
963 }
964
965 if (data.rp_gen)
966 {
967 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
968
969 if (data.rp_gen_seed)
970 {
971 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
972 }
973 }
974
975 /**
976 * show input
977 */
978
979 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
980 {
981 if (data.wordlist_mode == WL_MODE_FILE)
982 {
983 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
984 }
985 else if (data.wordlist_mode == WL_MODE_STDIN)
986 {
987 log_info ("Input.Mode.....: Pipe");
988 }
989 }
990 else if (data.attack_mode == ATTACK_MODE_COMBI)
991 {
992 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
993 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
994 }
995 else if (data.attack_mode == ATTACK_MODE_BF)
996 {
997 char *mask = data.mask;
998
999 if (mask != NULL)
1000 {
1001 uint mask_len = data.css_cnt;
1002
1003 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1004
1005 if (mask_len > 0)
1006 {
1007 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1008 {
1009 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1010 {
1011 mask_len -= data.salts_buf[0].salt_len;
1012 }
1013 }
1014
1015 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1016
1017 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1018 }
1019
1020 if (data.maskcnt > 1)
1021 {
1022 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1023
1024 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1025 }
1026
1027 log_info ("Input.Mode.....: %s", tmp_buf);
1028 }
1029
1030 tmp_len = 0;
1031 }
1032 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1033 {
1034 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1035 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1036 }
1037 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1038 {
1039 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1040 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1041 }
1042
1043 if (data.digests_cnt == 1)
1044 {
1045 if (data.hash_mode == 2500)
1046 {
1047 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1048
1049 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1050 (char *) data.salts_buf[0].salt_buf,
1051 wpa->orig_mac1[0],
1052 wpa->orig_mac1[1],
1053 wpa->orig_mac1[2],
1054 wpa->orig_mac1[3],
1055 wpa->orig_mac1[4],
1056 wpa->orig_mac1[5],
1057 wpa->orig_mac2[0],
1058 wpa->orig_mac2[1],
1059 wpa->orig_mac2[2],
1060 wpa->orig_mac2[3],
1061 wpa->orig_mac2[4],
1062 wpa->orig_mac2[5]);
1063 }
1064 else if (data.hash_mode == 5200)
1065 {
1066 log_info ("Hash.Target....: File (%s)", data.hashfile);
1067 }
1068 else if (data.hash_mode == 9000)
1069 {
1070 log_info ("Hash.Target....: File (%s)", data.hashfile);
1071 }
1072 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1073 {
1074 log_info ("Hash.Target....: File (%s)", data.hashfile);
1075 }
1076 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1077 {
1078 log_info ("Hash.Target....: File (%s)", data.hashfile);
1079 }
1080 else
1081 {
1082 char out_buf[HCBUFSIZ] = { 0 };
1083
1084 ascii_digest (out_buf, 0, 0);
1085
1086 // limit length
1087 if (strlen (out_buf) > 40)
1088 {
1089 out_buf[41] = '.';
1090 out_buf[42] = '.';
1091 out_buf[43] = '.';
1092 out_buf[44] = 0;
1093 }
1094
1095 log_info ("Hash.Target....: %s", out_buf);
1096 }
1097 }
1098 else
1099 {
1100 if (data.hash_mode == 3000)
1101 {
1102 char out_buf1[32] = { 0 };
1103 char out_buf2[32] = { 0 };
1104
1105 ascii_digest (out_buf1, 0, 0);
1106 ascii_digest (out_buf2, 0, 1);
1107
1108 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1109 }
1110 else
1111 {
1112 log_info ("Hash.Target....: File (%s)", data.hashfile);
1113 }
1114 }
1115
1116 log_info ("Hash.Type......: %s", hash_type);
1117
1118 /**
1119 * speed new
1120 */
1121
1122 u64 speed_cnt[DEVICES_MAX] = { 0 };
1123 double speed_ms[DEVICES_MAX] = { 0 };
1124
1125 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1126 {
1127 hc_device_param_t *device_param = &data.devices_param[device_id];
1128
1129 if (device_param->skipped) continue;
1130
1131 speed_cnt[device_id] = 0;
1132 speed_ms[device_id] = 0;
1133
1134 for (int i = 0; i < SPEED_CACHE; i++)
1135 {
1136 speed_cnt[device_id] += device_param->speed_cnt[i];
1137 speed_ms[device_id] += device_param->speed_ms[i];
1138 }
1139
1140 speed_cnt[device_id] /= SPEED_CACHE;
1141 speed_ms[device_id] /= SPEED_CACHE;
1142 }
1143
1144 double hashes_all_ms = 0;
1145
1146 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1147
1148 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1149 {
1150 hc_device_param_t *device_param = &data.devices_param[device_id];
1151
1152 if (device_param->skipped) continue;
1153
1154 hashes_dev_ms[device_id] = 0;
1155
1156 if (speed_ms[device_id])
1157 {
1158 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1159
1160 hashes_all_ms += hashes_dev_ms[device_id];
1161 }
1162 }
1163
1164 /**
1165 * exec time
1166 */
1167
1168 double exec_all_ms[DEVICES_MAX] = { 0 };
1169
1170 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1171 {
1172 hc_device_param_t *device_param = &data.devices_param[device_id];
1173
1174 if (device_param->skipped) continue;
1175
1176 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1177
1178 exec_all_ms[device_id] = exec_ms_avg;
1179 }
1180
1181 /**
1182 * timers
1183 */
1184
1185 double ms_running = 0;
1186
1187 hc_timer_get (data.timer_running, ms_running);
1188
1189 double ms_paused = data.ms_paused;
1190
1191 if (data.devices_status == STATUS_PAUSED)
1192 {
1193 double ms_paused_tmp = 0;
1194
1195 hc_timer_get (data.timer_paused, ms_paused_tmp);
1196
1197 ms_paused += ms_paused_tmp;
1198 }
1199
1200 #ifdef WIN
1201
1202 __time64_t sec_run = ms_running / 1000;
1203
1204 #else
1205
1206 time_t sec_run = ms_running / 1000;
1207
1208 #endif
1209
1210 if (sec_run)
1211 {
1212 char display_run[32] = { 0 };
1213
1214 struct tm tm_run;
1215
1216 struct tm *tmp = NULL;
1217
1218 #ifdef WIN
1219
1220 tmp = _gmtime64 (&sec_run);
1221
1222 #else
1223
1224 tmp = gmtime (&sec_run);
1225
1226 #endif
1227
1228 if (tmp != NULL)
1229 {
1230 memset (&tm_run, 0, sizeof (tm_run));
1231
1232 memcpy (&tm_run, tmp, sizeof (tm_run));
1233
1234 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1235
1236 char *start = ctime (&data.proc_start);
1237
1238 size_t start_len = strlen (start);
1239
1240 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1241 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1242
1243 log_info ("Time.Started...: %s (%s)", start, display_run);
1244 }
1245 }
1246 else
1247 {
1248 log_info ("Time.Started...: 0 secs");
1249 }
1250
1251 /**
1252 * counters
1253 */
1254
1255 u64 progress_total = data.words_cnt * data.salts_cnt;
1256
1257 u64 all_done = 0;
1258 u64 all_rejected = 0;
1259 u64 all_restored = 0;
1260
1261 u64 progress_noneed = 0;
1262
1263 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1264 {
1265 all_done += data.words_progress_done[salt_pos];
1266 all_rejected += data.words_progress_rejected[salt_pos];
1267 all_restored += data.words_progress_restored[salt_pos];
1268
1269 // Important for ETA only
1270
1271 if (data.salts_shown[salt_pos] == 1)
1272 {
1273 const u64 all = data.words_progress_done[salt_pos]
1274 + data.words_progress_rejected[salt_pos]
1275 + data.words_progress_restored[salt_pos];
1276
1277 const u64 left = data.words_cnt - all;
1278
1279 progress_noneed += left;
1280 }
1281 }
1282
1283 u64 progress_cur = all_restored + all_done + all_rejected;
1284 u64 progress_end = progress_total;
1285
1286 u64 progress_skip = 0;
1287
1288 if (data.skip)
1289 {
1290 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1291
1292 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1293 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1294 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1295 }
1296
1297 if (data.limit)
1298 {
1299 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1300
1301 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1302 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1303 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1304 }
1305
1306 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1307 u64 progress_end_relative_skip = progress_end - progress_skip;
1308
1309 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1310 {
1311 if (data.devices_status != STATUS_CRACKED)
1312 {
1313 #ifdef WIN
1314 __time64_t sec_etc = 0;
1315 #else
1316 time_t sec_etc = 0;
1317 #endif
1318
1319 if (hashes_all_ms)
1320 {
1321 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1322
1323 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1324
1325 sec_etc = ms_left / 1000;
1326 }
1327
1328 if (sec_etc == 0)
1329 {
1330 //log_info ("Time.Estimated.: 0 secs");
1331 }
1332 else if ((u64) sec_etc > ETC_MAX)
1333 {
1334 log_info ("Time.Estimated.: > 10 Years");
1335 }
1336 else
1337 {
1338 char display_etc[32] = { 0 };
1339
1340 struct tm tm_etc;
1341
1342 struct tm *tmp = NULL;
1343
1344 #ifdef WIN
1345
1346 tmp = _gmtime64 (&sec_etc);
1347
1348 #else
1349
1350 tmp = gmtime (&sec_etc);
1351
1352 #endif
1353
1354 if (tmp != NULL)
1355 {
1356 memset (&tm_etc, 0, sizeof (tm_etc));
1357
1358 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1359
1360 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1361
1362 time_t now;
1363
1364 time (&now);
1365
1366 now += sec_etc;
1367
1368 char *etc = ctime (&now);
1369
1370 size_t etc_len = strlen (etc);
1371
1372 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1373 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1374
1375 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1376 }
1377 }
1378 }
1379 }
1380
1381 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1382 {
1383 hc_device_param_t *device_param = &data.devices_param[device_id];
1384
1385 if (device_param->skipped) continue;
1386
1387 char display_dev_cur[16] = { 0 };
1388
1389 strncpy (display_dev_cur, "0.00", 4);
1390
1391 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1392
1393 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1394 }
1395
1396 char display_all_cur[16] = { 0 };
1397
1398 strncpy (display_all_cur, "0.00", 4);
1399
1400 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1401
1402 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1403
1404 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1405 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1406
1407 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1408
1409 // crack-per-time
1410
1411 if (data.digests_cnt > 100)
1412 {
1413 time_t now = time (NULL);
1414
1415 int cpt_cur_min = 0;
1416 int cpt_cur_hour = 0;
1417 int cpt_cur_day = 0;
1418
1419 for (int i = 0; i < CPT_BUF; i++)
1420 {
1421 const uint cracked = data.cpt_buf[i].cracked;
1422 const time_t timestamp = data.cpt_buf[i].timestamp;
1423
1424 if ((timestamp + 60) > now)
1425 {
1426 cpt_cur_min += cracked;
1427 }
1428
1429 if ((timestamp + 3600) > now)
1430 {
1431 cpt_cur_hour += cracked;
1432 }
1433
1434 if ((timestamp + 86400) > now)
1435 {
1436 cpt_cur_day += cracked;
1437 }
1438 }
1439
1440 double ms_real = ms_running - ms_paused;
1441
1442 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1443 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1444 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1445
1446 if ((data.cpt_start + 86400) < now)
1447 {
1448 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1449 cpt_cur_min,
1450 cpt_cur_hour,
1451 cpt_cur_day,
1452 cpt_avg_min,
1453 cpt_avg_hour,
1454 cpt_avg_day);
1455 }
1456 else if ((data.cpt_start + 3600) < now)
1457 {
1458 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1459 cpt_cur_min,
1460 cpt_cur_hour,
1461 cpt_avg_min,
1462 cpt_avg_hour,
1463 cpt_avg_day);
1464 }
1465 else if ((data.cpt_start + 60) < now)
1466 {
1467 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1468 cpt_cur_min,
1469 cpt_avg_min,
1470 cpt_avg_hour,
1471 cpt_avg_day);
1472 }
1473 else
1474 {
1475 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1476 cpt_avg_min,
1477 cpt_avg_hour,
1478 cpt_avg_day);
1479 }
1480 }
1481
1482 // Restore point
1483
1484 u64 restore_point = get_lowest_words_done ();
1485
1486 u64 restore_total = data.words_base;
1487
1488 float percent_restore = 0;
1489
1490 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1491
1492 if (progress_end_relative_skip)
1493 {
1494 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1495 {
1496 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1497 float percent_rejected = 0.0;
1498
1499 if (progress_cur)
1500 {
1501 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1502 }
1503
1504 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1505 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1506
1507 if (data.restore_disable == 0)
1508 {
1509 if (percent_finished != 1)
1510 {
1511 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1512 }
1513 }
1514 }
1515 }
1516 else
1517 {
1518 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1519 {
1520 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1521 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1522
1523 if (data.restore_disable == 0)
1524 {
1525 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1526 }
1527 }
1528 else
1529 {
1530 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1531 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1532
1533 // --restore not allowed if stdin is used -- really? why?
1534
1535 //if (data.restore_disable == 0)
1536 //{
1537 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1538 //}
1539 }
1540 }
1541
1542 #ifdef HAVE_HWMON
1543
1544 if (data.devices_status == STATUS_EXHAUSTED) return;
1545 if (data.devices_status == STATUS_CRACKED) return;
1546 if (data.devices_status == STATUS_ABORTED) return;
1547 if (data.devices_status == STATUS_QUIT) return;
1548
1549 if (data.gpu_temp_disable == 0)
1550 {
1551 hc_thread_mutex_lock (mux_adl);
1552
1553 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1554 {
1555 hc_device_param_t *device_param = &data.devices_param[device_id];
1556
1557 if (device_param->skipped) continue;
1558
1559 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1560 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1561 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1562 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1563 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1564 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1565 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1566
1567 char output_buf[256] = { 0 };
1568
1569 int output_len = 0;
1570
1571 if (num_temperature >= 0)
1572 {
1573 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1574
1575 output_len = strlen (output_buf);
1576 }
1577
1578 if (num_fanspeed >= 0)
1579 {
1580 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1581
1582 output_len = strlen (output_buf);
1583 }
1584
1585 if (num_utilization >= 0)
1586 {
1587 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1588
1589 output_len = strlen (output_buf);
1590 }
1591
1592 if (num_corespeed >= 0)
1593 {
1594 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1595
1596 output_len = strlen (output_buf);
1597 }
1598
1599 if (num_memoryspeed >= 0)
1600 {
1601 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1602
1603 output_len = strlen (output_buf);
1604 }
1605
1606 if (num_buslanes >= 0)
1607 {
1608 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1609
1610 output_len = strlen (output_buf);
1611 }
1612
1613 if (num_throttle == 1)
1614 {
1615 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1616
1617 output_len = strlen (output_buf);
1618 }
1619
1620 if (output_len == 0)
1621 {
1622 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1623
1624 output_len = strlen (output_buf);
1625 }
1626
1627 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1628 }
1629
1630 hc_thread_mutex_unlock (mux_adl);
1631 }
1632
1633 #endif // HAVE_HWMON
1634 }
1635
1636 static void status_benchmark_automate ()
1637 {
1638 u64 speed_cnt[DEVICES_MAX] = { 0 };
1639 double speed_ms[DEVICES_MAX] = { 0 };
1640
1641 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1642 {
1643 hc_device_param_t *device_param = &data.devices_param[device_id];
1644
1645 if (device_param->skipped) continue;
1646
1647 speed_cnt[device_id] = device_param->speed_cnt[0];
1648 speed_ms[device_id] = device_param->speed_ms[0];
1649 }
1650
1651 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1652
1653 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1654 {
1655 hc_device_param_t *device_param = &data.devices_param[device_id];
1656
1657 if (device_param->skipped) continue;
1658
1659 hashes_dev_ms[device_id] = 0;
1660
1661 if (speed_ms[device_id])
1662 {
1663 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1664 }
1665 }
1666
1667 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1668 {
1669 hc_device_param_t *device_param = &data.devices_param[device_id];
1670
1671 if (device_param->skipped) continue;
1672
1673 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1674 }
1675 }
1676
1677 static void status_benchmark ()
1678 {
1679 if (data.devices_status == STATUS_INIT) return;
1680 if (data.devices_status == STATUS_STARTING) return;
1681 if (data.devices_status == STATUS_BYPASS) return;
1682
1683 if (data.machine_readable == 1)
1684 {
1685 status_benchmark_automate ();
1686
1687 return;
1688 }
1689
1690 u64 speed_cnt[DEVICES_MAX] = { 0 };
1691 double speed_ms[DEVICES_MAX] = { 0 };
1692
1693 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1694 {
1695 hc_device_param_t *device_param = &data.devices_param[device_id];
1696
1697 if (device_param->skipped) continue;
1698
1699 speed_cnt[device_id] = device_param->speed_cnt[0];
1700 speed_ms[device_id] = device_param->speed_ms[0];
1701 }
1702
1703 double hashes_all_ms = 0;
1704
1705 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1706
1707 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1708 {
1709 hc_device_param_t *device_param = &data.devices_param[device_id];
1710
1711 if (device_param->skipped) continue;
1712
1713 hashes_dev_ms[device_id] = 0;
1714
1715 if (speed_ms[device_id])
1716 {
1717 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1718
1719 hashes_all_ms += hashes_dev_ms[device_id];
1720 }
1721 }
1722
1723 /**
1724 * exec time
1725 */
1726
1727 double exec_all_ms[DEVICES_MAX] = { 0 };
1728
1729 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1730 {
1731 hc_device_param_t *device_param = &data.devices_param[device_id];
1732
1733 if (device_param->skipped) continue;
1734
1735 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1736
1737 exec_all_ms[device_id] = exec_ms_avg;
1738 }
1739
1740 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1741 {
1742 hc_device_param_t *device_param = &data.devices_param[device_id];
1743
1744 if (device_param->skipped) continue;
1745
1746 char display_dev_cur[16] = { 0 };
1747
1748 strncpy (display_dev_cur, "0.00", 4);
1749
1750 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1751
1752 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1753 }
1754
1755 char display_all_cur[16] = { 0 };
1756
1757 strncpy (display_all_cur, "0.00", 4);
1758
1759 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1760
1761 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1762 }
1763
1764 /**
1765 * hashcat -only- functions
1766 */
1767
1768 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1769 {
1770 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1771 {
1772 if (attack_kern == ATTACK_KERN_STRAIGHT)
1773 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1774 else if (attack_kern == ATTACK_KERN_COMBI)
1775 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1776 else if (attack_kern == ATTACK_KERN_BF)
1777 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1778 }
1779 else
1780 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1781 }
1782
1783 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1784 {
1785 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1786 {
1787 if (attack_kern == ATTACK_KERN_STRAIGHT)
1788 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1789 else if (attack_kern == ATTACK_KERN_COMBI)
1790 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1791 else if (attack_kern == ATTACK_KERN_BF)
1792 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1793 }
1794 else
1795 {
1796 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1797 }
1798 }
1799
1800 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1801 {
1802 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1803 {
1804 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1805 }
1806 else
1807 {
1808 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1809 }
1810 }
1811
1812 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1813 {
1814 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1815 {
1816 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1817 }
1818 else
1819 {
1820 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1821 }
1822 }
1823
1824 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1825 {
1826 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1827 }
1828
1829 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1830 {
1831 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1832 }
1833
1834 static uint convert_from_hex (char *line_buf, const uint line_len)
1835 {
1836 if (line_len & 1) return (line_len); // not in hex
1837
1838 if (data.hex_wordlist == 1)
1839 {
1840 uint i;
1841 uint j;
1842
1843 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1844 {
1845 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1846 }
1847
1848 memset (line_buf + i, 0, line_len - i);
1849
1850 return (i);
1851 }
1852 else if (line_len >= 6) // $HEX[] = 6
1853 {
1854 if (line_buf[0] != '$') return (line_len);
1855 if (line_buf[1] != 'H') return (line_len);
1856 if (line_buf[2] != 'E') return (line_len);
1857 if (line_buf[3] != 'X') return (line_len);
1858 if (line_buf[4] != '[') return (line_len);
1859 if (line_buf[line_len - 1] != ']') return (line_len);
1860
1861 uint i;
1862 uint j;
1863
1864 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1865 {
1866 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1867 }
1868
1869 memset (line_buf + i, 0, line_len - i);
1870
1871 return (i);
1872 }
1873
1874 return (line_len);
1875 }
1876
1877 static void clear_prompt ()
1878 {
1879 fputc ('\r', stdout);
1880
1881 for (size_t i = 0; i < strlen (PROMPT); i++)
1882 {
1883 fputc (' ', stdout);
1884 }
1885
1886 fputc ('\r', stdout);
1887
1888 fflush (stdout);
1889 }
1890
1891 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1892 {
1893 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1894 }
1895
1896 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1897 {
1898 char *outfile = data.outfile;
1899 uint quiet = data.quiet;
1900 FILE *pot_fp = data.pot_fp;
1901 uint loopback = data.loopback;
1902 uint debug_mode = data.debug_mode;
1903 char *debug_file = data.debug_file;
1904
1905 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1906 int debug_rule_len = 0; // -1 error
1907 uint debug_plain_len = 0;
1908
1909 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1910
1911 // hash
1912
1913 char out_buf[HCBUFSIZ] = { 0 };
1914
1915 const u32 salt_pos = plain->salt_pos;
1916 const u32 digest_pos = plain->digest_pos; // relative
1917 const u32 gidvid = plain->gidvid;
1918 const u32 il_pos = plain->il_pos;
1919
1920 ascii_digest (out_buf, salt_pos, digest_pos);
1921
1922 // plain
1923
1924 u64 crackpos = device_param->words_off;
1925
1926 uint plain_buf[16] = { 0 };
1927
1928 u8 *plain_ptr = (u8 *) plain_buf;
1929
1930 unsigned int plain_len = 0;
1931
1932 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1933 {
1934 pw_t pw;
1935
1936 gidd_to_pw_t (device_param, gidvid, &pw);
1937
1938 for (int i = 0; i < 16; i++)
1939 {
1940 plain_buf[i] = pw.i[i];
1941 }
1942
1943 plain_len = pw.pw_len;
1944
1945 const uint off = device_param->innerloop_pos + il_pos;
1946
1947 if (debug_mode > 0)
1948 {
1949 debug_rule_len = 0;
1950
1951 // save rule
1952 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1953 {
1954 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1955
1956 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1957 }
1958
1959 // save plain
1960 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1961 {
1962 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1963
1964 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1965
1966 debug_plain_len = plain_len;
1967 }
1968 }
1969
1970 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1971
1972 crackpos += gidvid;
1973 crackpos *= data.kernel_rules_cnt;
1974 crackpos += device_param->innerloop_pos + il_pos;
1975
1976 if (plain_len > data.pw_max) plain_len = data.pw_max;
1977 }
1978 else if (data.attack_mode == ATTACK_MODE_COMBI)
1979 {
1980 pw_t pw;
1981
1982 gidd_to_pw_t (device_param, gidvid, &pw);
1983
1984 for (int i = 0; i < 16; i++)
1985 {
1986 plain_buf[i] = pw.i[i];
1987 }
1988
1989 plain_len = pw.pw_len;
1990
1991 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1992 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1993
1994 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1995 {
1996 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1997 }
1998 else
1999 {
2000 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2001
2002 memcpy (plain_ptr, comb_buf, comb_len);
2003 }
2004
2005 plain_len += comb_len;
2006
2007 crackpos += gidvid;
2008 crackpos *= data.combs_cnt;
2009 crackpos += device_param->innerloop_pos + il_pos;
2010
2011 if (data.pw_max != PW_DICTMAX1)
2012 {
2013 if (plain_len > data.pw_max) plain_len = data.pw_max;
2014 }
2015 }
2016 else if (data.attack_mode == ATTACK_MODE_BF)
2017 {
2018 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2019 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2020
2021 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2022 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2023
2024 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2025 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2026
2027 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2028 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2029
2030 plain_len = data.css_cnt;
2031
2032 crackpos += gidvid;
2033 crackpos *= data.bfs_cnt;
2034 crackpos += device_param->innerloop_pos + il_pos;
2035 }
2036 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2037 {
2038 pw_t pw;
2039
2040 gidd_to_pw_t (device_param, gidvid, &pw);
2041
2042 for (int i = 0; i < 16; i++)
2043 {
2044 plain_buf[i] = pw.i[i];
2045 }
2046
2047 plain_len = pw.pw_len;
2048
2049 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2050
2051 uint start = 0;
2052 uint stop = device_param->kernel_params_mp_buf32[4];
2053
2054 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2055
2056 plain_len += start + stop;
2057
2058 crackpos += gidvid;
2059 crackpos *= data.combs_cnt;
2060 crackpos += device_param->innerloop_pos + il_pos;
2061
2062 if (data.pw_max != PW_DICTMAX1)
2063 {
2064 if (plain_len > data.pw_max) plain_len = data.pw_max;
2065 }
2066 }
2067 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2068 {
2069 pw_t pw;
2070
2071 gidd_to_pw_t (device_param, gidvid, &pw);
2072
2073 for (int i = 0; i < 16; i++)
2074 {
2075 plain_buf[i] = pw.i[i];
2076 }
2077
2078 plain_len = pw.pw_len;
2079
2080 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2081
2082 uint start = 0;
2083 uint stop = device_param->kernel_params_mp_buf32[4];
2084
2085 memmove (plain_ptr + stop, plain_ptr, plain_len);
2086
2087 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2088
2089 plain_len += start + stop;
2090
2091 crackpos += gidvid;
2092 crackpos *= data.combs_cnt;
2093 crackpos += device_param->innerloop_pos + il_pos;
2094
2095 if (data.pw_max != PW_DICTMAX1)
2096 {
2097 if (plain_len > data.pw_max) plain_len = data.pw_max;
2098 }
2099 }
2100
2101 if (data.attack_mode == ATTACK_MODE_BF)
2102 {
2103 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2104 {
2105 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2106 {
2107 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2108 {
2109 plain_len = plain_len - data.salts_buf[0].salt_len;
2110 }
2111 }
2112
2113 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2114 {
2115 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2116 {
2117 plain_ptr[j] = plain_ptr[i];
2118 }
2119
2120 plain_len = plain_len / 2;
2121 }
2122 }
2123 }
2124
2125 // if enabled, update also the potfile
2126
2127 if (pot_fp)
2128 {
2129 lock_file (pot_fp);
2130
2131 fprintf (pot_fp, "%s:", out_buf);
2132
2133 format_plain (pot_fp, plain_ptr, plain_len, 1);
2134
2135 fputc ('\n', pot_fp);
2136
2137 fflush (pot_fp);
2138
2139 unlock_file (pot_fp);
2140 }
2141
2142 // outfile
2143
2144 FILE *out_fp = NULL;
2145
2146 if (outfile != NULL)
2147 {
2148 if ((out_fp = fopen (outfile, "ab")) == NULL)
2149 {
2150 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2151
2152 out_fp = stdout;
2153 }
2154
2155 lock_file (out_fp);
2156 }
2157 else
2158 {
2159 out_fp = stdout;
2160
2161 if (quiet == 0) clear_prompt ();
2162 }
2163
2164 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2165
2166 if (outfile != NULL)
2167 {
2168 if (out_fp != stdout)
2169 {
2170 fclose (out_fp);
2171 }
2172 }
2173 else
2174 {
2175 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2176 {
2177 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2178 {
2179 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2180 if (quiet == 0) fflush (stdout);
2181 }
2182 }
2183 }
2184
2185 // loopback
2186
2187 if (loopback)
2188 {
2189 char *loopback_file = data.loopback_file;
2190
2191 FILE *fb_fp = NULL;
2192
2193 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2194 {
2195 lock_file (fb_fp);
2196
2197 format_plain (fb_fp, plain_ptr, plain_len, 1);
2198
2199 fputc ('\n', fb_fp);
2200
2201 fclose (fb_fp);
2202 }
2203 }
2204
2205 // (rule) debug mode
2206
2207 // the next check implies that:
2208 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2209 // - debug_mode > 0
2210
2211 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2212 {
2213 if (debug_rule_len < 0) debug_rule_len = 0;
2214
2215 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2216
2217 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2218
2219 if ((quiet == 0) && (debug_file == NULL))
2220 {
2221 fprintf (stdout, "%s", PROMPT);
2222
2223 fflush (stdout);
2224 }
2225 }
2226 }
2227
2228 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2229 {
2230 salt_t *salt_buf = &data.salts_buf[salt_pos];
2231
2232 u32 num_cracked;
2233
2234 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2235
2236 if (num_cracked)
2237 {
2238 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2239
2240 log_info_nn ("");
2241
2242 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2243
2244 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, 0, num_cracked * sizeof (plain_t), cracked, 0, NULL, NULL);
2245
2246 uint cpt_cracked = 0;
2247
2248 for (uint i = 0; i < num_cracked; i++)
2249 {
2250 const uint hash_pos = cracked[i].hash_pos;
2251
2252 if (data.digests_shown[hash_pos] == 1) continue;
2253
2254 hc_thread_mutex_lock (mux_display);
2255
2256 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2257 {
2258 data.digests_shown[hash_pos] = 1;
2259
2260 data.digests_done++;
2261
2262 cpt_cracked++;
2263
2264 salt_buf->digests_done++;
2265
2266 if (salt_buf->digests_done == salt_buf->digests_cnt)
2267 {
2268 data.salts_shown[salt_pos] = 1;
2269
2270 data.salts_done++;
2271 }
2272 }
2273
2274 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2275
2276 hc_thread_mutex_unlock (mux_display);
2277
2278 check_hash (device_param, &cracked[i]);
2279 }
2280
2281 myfree (cracked);
2282
2283 if (cpt_cracked > 0)
2284 {
2285 hc_thread_mutex_lock (mux_display);
2286
2287 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2288 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2289
2290 data.cpt_pos++;
2291
2292 data.cpt_total += cpt_cracked;
2293
2294 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2295
2296 hc_thread_mutex_unlock (mux_display);
2297 }
2298
2299 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2300 {
2301 // we need to reset cracked state on the device
2302 // otherwise host thinks again and again the hash was cracked
2303 // and returns invalid password each time
2304
2305 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2306
2307 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2308 }
2309
2310 num_cracked = 0;
2311
2312 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2313 }
2314 }
2315
2316 static void save_hash ()
2317 {
2318 char *hashfile = data.hashfile;
2319
2320 char new_hashfile[256] = { 0 };
2321 char old_hashfile[256] = { 0 };
2322
2323 snprintf (new_hashfile, 255, "%s.new", hashfile);
2324 snprintf (old_hashfile, 255, "%s.old", hashfile);
2325
2326 unlink (new_hashfile);
2327
2328 char separator = data.separator;
2329
2330 FILE *fp = fopen (new_hashfile, "wb");
2331
2332 if (fp == NULL)
2333 {
2334 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2335
2336 exit (-1);
2337 }
2338
2339 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2340 {
2341 if (data.salts_shown[salt_pos] == 1) continue;
2342
2343 salt_t *salt_buf = &data.salts_buf[salt_pos];
2344
2345 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2346 {
2347 uint idx = salt_buf->digests_offset + digest_pos;
2348
2349 if (data.digests_shown[idx] == 1) continue;
2350
2351 if (data.hash_mode != 2500)
2352 {
2353 char out_buf[HCBUFSIZ] = { 0 };
2354
2355 if (data.username == 1)
2356 {
2357 user_t *user = data.hash_info[idx]->user;
2358
2359 uint i;
2360
2361 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2362
2363 fputc (separator, fp);
2364 }
2365
2366 ascii_digest (out_buf, salt_pos, digest_pos);
2367
2368 fputs (out_buf, fp);
2369
2370 log_out (fp, "");
2371 }
2372 else
2373 {
2374 hccap_t hccap;
2375
2376 to_hccap_t (&hccap, salt_pos, digest_pos);
2377
2378 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2379 }
2380 }
2381 }
2382
2383 fflush (fp);
2384
2385 fclose (fp);
2386
2387 unlink (old_hashfile);
2388
2389 if (rename (hashfile, old_hashfile) != 0)
2390 {
2391 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2392
2393 exit (-1);
2394 }
2395
2396 unlink (hashfile);
2397
2398 if (rename (new_hashfile, hashfile) != 0)
2399 {
2400 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2401
2402 exit (-1);
2403 }
2404
2405 unlink (old_hashfile);
2406 }
2407
2408 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2409 {
2410 uint num_elements = num;
2411
2412 device_param->kernel_params_buf32[30] = data.combs_mode;
2413 device_param->kernel_params_buf32[31] = num;
2414
2415 uint kernel_threads = device_param->kernel_threads;
2416
2417 while (num_elements % kernel_threads) num_elements++;
2418
2419 cl_kernel kernel = NULL;
2420
2421 switch (kern_run)
2422 {
2423 case KERN_RUN_1: kernel = device_param->kernel1; break;
2424 case KERN_RUN_12: kernel = device_param->kernel12; break;
2425 case KERN_RUN_2: kernel = device_param->kernel2; break;
2426 case KERN_RUN_23: kernel = device_param->kernel23; break;
2427 case KERN_RUN_3: kernel = device_param->kernel3; break;
2428 }
2429
2430 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2431 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2432 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2433 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2434 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2435 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2436 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2437 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2438 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2439 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2440 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2441
2442 cl_event event;
2443
2444 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2445 {
2446 const size_t global_work_size[3] = { num_elements, 32, 1 };
2447 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2448
2449 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2450 }
2451 else
2452 {
2453 if (kern_run == KERN_RUN_2)
2454 {
2455 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2456 {
2457 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2458 }
2459 }
2460
2461 while (num_elements % kernel_threads) num_elements++;
2462
2463 const size_t global_work_size[3] = { num_elements, 1, 1 };
2464 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2465
2466 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2467 }
2468
2469 hc_clFlush (data.ocl, device_param->command_queue);
2470
2471 hc_clWaitForEvents (data.ocl, 1, &event);
2472
2473 if (event_update)
2474 {
2475 cl_ulong time_start;
2476 cl_ulong time_end;
2477
2478 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2479 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2480
2481 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2482
2483 uint exec_pos = device_param->exec_pos;
2484
2485 device_param->exec_ms[exec_pos] = exec_time;
2486
2487 exec_pos++;
2488
2489 if (exec_pos == EXEC_CACHE)
2490 {
2491 exec_pos = 0;
2492 }
2493
2494 device_param->exec_pos = exec_pos;
2495 }
2496
2497 hc_clReleaseEvent (data.ocl, event);
2498
2499 hc_clFinish (data.ocl, device_param->command_queue);
2500 }
2501
2502 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2503 {
2504 uint num_elements = num;
2505
2506 switch (kern_run)
2507 {
2508 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2509 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2510 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2511 }
2512
2513 // causes problems with special threads like in bcrypt
2514 // const uint kernel_threads = device_param->kernel_threads;
2515
2516 uint kernel_threads = device_param->kernel_threads;
2517
2518 while (num_elements % kernel_threads) num_elements++;
2519
2520 cl_kernel kernel = NULL;
2521
2522 switch (kern_run)
2523 {
2524 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2525 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2526 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2527 }
2528
2529 switch (kern_run)
2530 {
2531 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2532 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2533 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2534 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2535 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2536 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2537 break;
2538 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2539 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2540 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2541 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2542 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2543 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2544 break;
2545 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2546 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2547 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2548 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2549 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2550 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2551 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2552 break;
2553 }
2554
2555 const size_t global_work_size[3] = { num_elements, 1, 1 };
2556 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2557
2558 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2559
2560 hc_clFlush (data.ocl, device_param->command_queue);
2561
2562 hc_clFinish (data.ocl, device_param->command_queue);
2563 }
2564
2565 static void run_kernel_tm (hc_device_param_t *device_param)
2566 {
2567 const uint num_elements = 1024; // fixed
2568
2569 uint kernel_threads = 32;
2570
2571 cl_kernel kernel = device_param->kernel_tm;
2572
2573 const size_t global_work_size[3] = { num_elements, 1, 1 };
2574 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2575
2576 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2577
2578 hc_clFlush (data.ocl, device_param->command_queue);
2579
2580 hc_clFinish (data.ocl, device_param->command_queue);
2581 }
2582
2583 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2584 {
2585 uint num_elements = num;
2586
2587 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2588 device_param->kernel_params_amp_buf32[6] = num_elements;
2589
2590 // causes problems with special threads like in bcrypt
2591 // const uint kernel_threads = device_param->kernel_threads;
2592
2593 uint kernel_threads = device_param->kernel_threads;
2594
2595 while (num_elements % kernel_threads) num_elements++;
2596
2597 cl_kernel kernel = device_param->kernel_amp;
2598
2599 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2600 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2601
2602 const size_t global_work_size[3] = { num_elements, 1, 1 };
2603 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2604
2605 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2606
2607 hc_clFlush (data.ocl, device_param->command_queue);
2608
2609 hc_clFinish (data.ocl, device_param->command_queue);
2610 }
2611
2612 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2613 {
2614 const u32 num16d = num / 16;
2615 const u32 num16m = num % 16;
2616
2617 if (num16d)
2618 {
2619 device_param->kernel_params_memset_buf32[1] = value;
2620 device_param->kernel_params_memset_buf32[2] = num16d;
2621
2622 uint kernel_threads = device_param->kernel_threads;
2623
2624 uint num_elements = num16d;
2625
2626 while (num_elements % kernel_threads) num_elements++;
2627
2628 cl_kernel kernel = device_param->kernel_memset;
2629
2630 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2631 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2632 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2633
2634 const size_t global_work_size[3] = { num_elements, 1, 1 };
2635 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2636
2637 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2638
2639 hc_clFlush (data.ocl, device_param->command_queue);
2640
2641 hc_clFinish (data.ocl, device_param->command_queue);
2642 }
2643
2644 if (num16m)
2645 {
2646 u32 tmp[4];
2647
2648 tmp[0] = value;
2649 tmp[1] = value;
2650 tmp[2] = value;
2651 tmp[3] = value;
2652
2653 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2654 }
2655 }
2656
2657 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2658 {
2659 run_kernel_memset (device_param, buf, 0, size);
2660
2661 /*
2662 int rc = -1;
2663
2664 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2665 {
2666 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2667
2668 const cl_uchar zero = 0;
2669
2670 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2671 }
2672
2673 if (rc != 0)
2674 {
2675 // NOTE: clEnqueueFillBuffer () always fails with -59
2676 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2677 // How's that possible, OpenCL 1.2 support is advertised??
2678 // We need to workaround...
2679
2680 #define FILLSZ 0x100000
2681
2682 char *tmp = (char *) mymalloc (FILLSZ);
2683
2684 for (size_t i = 0; i < size; i += FILLSZ)
2685 {
2686 const size_t left = size - i;
2687
2688 const size_t fillsz = MIN (FILLSZ, left);
2689
2690 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2691 }
2692
2693 myfree (tmp);
2694 }
2695 */
2696 }
2697
2698 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2699 {
2700 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2701 {
2702 if (attack_mode == ATTACK_MODE_BF)
2703 {
2704 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2705 {
2706 const uint size_tm = 32 * sizeof (bs_word_t);
2707
2708 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2709
2710 run_kernel_tm (device_param);
2711
2712 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2713 }
2714 }
2715
2716 if (highest_pw_len < 16)
2717 {
2718 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2719 }
2720 else if (highest_pw_len < 32)
2721 {
2722 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2723 }
2724 else
2725 {
2726 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2727 }
2728 }
2729 else
2730 {
2731 run_kernel_amp (device_param, pws_cnt);
2732
2733 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2734
2735 if (opts_type & OPTS_TYPE_HOOK12)
2736 {
2737 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2738 }
2739
2740 uint iter = salt_buf->salt_iter;
2741
2742 uint loop_step = device_param->kernel_loops;
2743
2744 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2745 {
2746 uint loop_left = iter - loop_pos;
2747
2748 loop_left = MIN (loop_left, loop_step);
2749
2750 device_param->kernel_params_buf32[25] = loop_pos;
2751 device_param->kernel_params_buf32[26] = loop_left;
2752
2753 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2754
2755 if (data.devices_status == STATUS_CRACKED) break;
2756 if (data.devices_status == STATUS_ABORTED) break;
2757 if (data.devices_status == STATUS_QUIT) break;
2758
2759 /**
2760 * speed
2761 */
2762
2763 const float iter_part = (float) (loop_pos + loop_left) / iter;
2764
2765 const u64 perf_sum_all = pws_cnt * iter_part;
2766
2767 double speed_ms;
2768
2769 hc_timer_get (device_param->timer_speed, speed_ms);
2770
2771 const u32 speed_pos = device_param->speed_pos;
2772
2773 device_param->speed_cnt[speed_pos] = perf_sum_all;
2774
2775 device_param->speed_ms[speed_pos] = speed_ms;
2776
2777 if (data.benchmark == 1)
2778 {
2779 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2780 }
2781 }
2782
2783 if (opts_type & OPTS_TYPE_HOOK23)
2784 {
2785 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2786
2787 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2788
2789 // do something with data
2790
2791 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2792 }
2793
2794 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2795 }
2796 }
2797
2798 static int run_rule_engine (const int rule_len, const char *rule_buf)
2799 {
2800 if (rule_len == 0)
2801 {
2802 return 0;
2803 }
2804 else if (rule_len == 1)
2805 {
2806 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2807 }
2808
2809 return 1;
2810 }
2811
2812 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2813 {
2814 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2815 {
2816 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2817 }
2818 else if (data.attack_kern == ATTACK_KERN_COMBI)
2819 {
2820 if (data.attack_mode == ATTACK_MODE_COMBI)
2821 {
2822 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2823 {
2824 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2825 {
2826 for (u32 i = 0; i < pws_cnt; i++)
2827 {
2828 const u32 pw_len = device_param->pws_buf[i].pw_len;
2829
2830 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2831
2832 ptr[pw_len] = 0x01;
2833 }
2834 }
2835 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2836 {
2837 for (u32 i = 0; i < pws_cnt; i++)
2838 {
2839 const u32 pw_len = device_param->pws_buf[i].pw_len;
2840
2841 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2842
2843 ptr[pw_len] = 0x80;
2844 }
2845 }
2846 }
2847 }
2848 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2849 {
2850 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2851 {
2852 for (u32 i = 0; i < pws_cnt; i++)
2853 {
2854 const u32 pw_len = device_param->pws_buf[i].pw_len;
2855
2856 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2857
2858 ptr[pw_len] = 0x01;
2859 }
2860 }
2861 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2862 {
2863 for (u32 i = 0; i < pws_cnt; i++)
2864 {
2865 const u32 pw_len = device_param->pws_buf[i].pw_len;
2866
2867 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2868
2869 ptr[pw_len] = 0x80;
2870 }
2871 }
2872 }
2873
2874 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2875 }
2876 else if (data.attack_kern == ATTACK_KERN_BF)
2877 {
2878 const u64 off = device_param->words_off;
2879
2880 device_param->kernel_params_mp_l_buf64[3] = off;
2881
2882 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2883 }
2884 }
2885
2886 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2887 {
2888 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2889
2890 device_param->kernel_params_buf32[25] = 0;
2891 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2892 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2893
2894 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2895 {
2896 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true);
2897 }
2898 else
2899 {
2900 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true);
2901 }
2902
2903 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2904
2905 return exec_ms_prev;
2906 }
2907
2908 static void autotune (hc_device_param_t *device_param)
2909 {
2910 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2911
2912 const u32 kernel_accel_min = device_param->kernel_accel_min;
2913 const u32 kernel_accel_max = device_param->kernel_accel_max;
2914
2915 const u32 kernel_loops_min = device_param->kernel_loops_min;
2916 const u32 kernel_loops_max = device_param->kernel_loops_max;
2917
2918 u32 kernel_accel = kernel_accel_min;
2919 u32 kernel_loops = kernel_loops_min;
2920
2921 // in this case the user specified a fixed -u and -n on the commandline
2922 // no way to tune anything
2923 // but we need to run a few caching rounds
2924
2925 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2926 {
2927 try_run (device_param, kernel_accel, kernel_loops);
2928 try_run (device_param, kernel_accel, kernel_loops);
2929 try_run (device_param, kernel_accel, kernel_loops);
2930 try_run (device_param, kernel_accel, kernel_loops);
2931
2932 device_param->kernel_accel = kernel_accel;
2933 device_param->kernel_loops = kernel_loops;
2934
2935 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2936
2937 device_param->kernel_power = kernel_power;
2938
2939 return;
2940 }
2941
2942 // from here it's clear we are allowed to autotune
2943 // so let's init some fake words
2944
2945 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2946
2947 if (data.attack_kern == ATTACK_KERN_BF)
2948 {
2949 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2950 }
2951 else
2952 {
2953 for (u32 i = 0; i < kernel_power_max; i++)
2954 {
2955 device_param->pws_buf[i].i[0] = i;
2956 device_param->pws_buf[i].i[1] = 0x01234567;
2957 device_param->pws_buf[i].pw_len = 7 + (i & 7);
2958 }
2959
2960 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2961 }
2962
2963 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2964 {
2965 if (data.kernel_rules_cnt > 1)
2966 {
2967 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, 0, 0, MIN (kernel_loops_max, KERNEL_RULES) * sizeof (kernel_rule_t), 0, NULL, NULL);
2968 }
2969 }
2970 else
2971 {
2972 run_kernel_amp (device_param, kernel_power_max);
2973 }
2974
2975 #define VERIFIER_CNT 1
2976
2977 // first find out highest kernel-loops that stays below target_ms
2978
2979 if (kernel_loops_min < kernel_loops_max)
2980 {
2981 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2982 {
2983 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2984
2985 for (int i = 0; i < VERIFIER_CNT; i++)
2986 {
2987 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
2988
2989 exec_ms = MIN (exec_ms, exec_ms_v);
2990 }
2991
2992 if (exec_ms < target_ms) break;
2993 }
2994 }
2995
2996 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2997
2998 #define STEPS_CNT 10
2999
3000 if (kernel_accel_min < kernel_accel_max)
3001 {
3002 for (int i = 0; i < STEPS_CNT; i++)
3003 {
3004 const u32 kernel_accel_try = 1 << i;
3005
3006 if (kernel_accel_try < kernel_accel_min) continue;
3007 if (kernel_accel_try > kernel_accel_max) break;
3008
3009 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3010
3011 for (int i = 0; i < VERIFIER_CNT; i++)
3012 {
3013 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3014
3015 exec_ms = MIN (exec_ms, exec_ms_v);
3016 }
3017
3018 if (exec_ms > target_ms) break;
3019
3020 kernel_accel = kernel_accel_try;
3021 }
3022 }
3023
3024 // at this point we want to know the actual runtime for the following reason:
3025 // we need a reference for the balancing loop following up, and this
3026 // the balancing loop can have an effect that the creates a new opportunity, for example:
3027 // if the target is 95 ms and the current runtime is 48ms the above loop
3028 // stopped the execution because the previous exec_ms was > 95ms
3029 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3030 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3031
3032 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3033
3034 for (int i = 0; i < VERIFIER_CNT; i++)
3035 {
3036 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3037
3038 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3039 }
3040
3041 u32 diff = kernel_loops - kernel_accel;
3042
3043 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3044 {
3045 u32 kernel_accel_orig = kernel_accel;
3046 u32 kernel_loops_orig = kernel_loops;
3047
3048 for (u32 f = 1; f < 1024; f++)
3049 {
3050 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3051 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3052
3053 if (kernel_accel_try > kernel_accel_max) break;
3054 if (kernel_loops_try < kernel_loops_min) break;
3055
3056 u32 diff_new = kernel_loops_try - kernel_accel_try;
3057
3058 if (diff_new > diff) break;
3059
3060 diff_new = diff;
3061
3062 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3063
3064 for (int i = 0; i < VERIFIER_CNT; i++)
3065 {
3066 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3067
3068 exec_ms = MIN (exec_ms, exec_ms_v);
3069 }
3070
3071 if (exec_ms < exec_ms_pre_final)
3072 {
3073 exec_ms_pre_final = exec_ms;
3074
3075 kernel_accel = kernel_accel_try;
3076 kernel_loops = kernel_loops_try;
3077 }
3078 }
3079 }
3080
3081 const double exec_left = target_ms / exec_ms_pre_final;
3082
3083 const double accel_left = kernel_accel_max / kernel_accel;
3084
3085 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3086
3087 if (exec_accel_min >= 1.0)
3088 {
3089 // this is safe to not overflow kernel_accel_max because of accel_left
3090
3091 kernel_accel = (double) kernel_accel * exec_accel_min;
3092 }
3093
3094 // reset them fake words
3095
3096 /*
3097 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3098
3099 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3100 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3101 */
3102
3103 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3104
3105 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3106 {
3107 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3108 }
3109
3110 // reset timer
3111
3112 device_param->exec_pos = 0;
3113
3114 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3115
3116 // store
3117
3118 device_param->kernel_accel = kernel_accel;
3119 device_param->kernel_loops = kernel_loops;
3120
3121 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3122
3123 device_param->kernel_power = kernel_power;
3124
3125 #ifdef DEBUG
3126
3127 if (data.quiet == 0)
3128 {
3129 clear_prompt ();
3130
3131 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3132 "Device #%u: autotuned kernel-loops to %u\n",
3133 device_param->device_id + 1, kernel_accel,
3134 device_param->device_id + 1, kernel_loops);
3135
3136 fprintf (stdout, "%s", PROMPT);
3137
3138 fflush (stdout);
3139 }
3140
3141 #endif
3142 }
3143
3144 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3145 {
3146 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3147
3148 // init speed timer
3149
3150 uint speed_pos = device_param->speed_pos;
3151
3152 #ifdef _POSIX
3153 if (device_param->timer_speed.tv_sec == 0)
3154 {
3155 hc_timer_set (&device_param->timer_speed);
3156 }
3157 #endif
3158
3159 #ifdef _WIN
3160 if (device_param->timer_speed.QuadPart == 0)
3161 {
3162 hc_timer_set (&device_param->timer_speed);
3163 }
3164 #endif
3165
3166 // find higest password length, this is for optimization stuff
3167
3168 uint highest_pw_len = 0;
3169
3170 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3171 {
3172 }
3173 else if (data.attack_kern == ATTACK_KERN_COMBI)
3174 {
3175 }
3176 else if (data.attack_kern == ATTACK_KERN_BF)
3177 {
3178 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3179 + device_param->kernel_params_mp_l_buf32[5];
3180 }
3181
3182 // iteration type
3183
3184 uint innerloop_step = 0;
3185 uint innerloop_cnt = 0;
3186
3187 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3188 else innerloop_step = 1;
3189
3190 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3191 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3192 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3193
3194 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3195
3196 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3197 {
3198 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3199
3200 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3201
3202 if (data.devices_status == STATUS_CRACKED) break;
3203 if (data.devices_status == STATUS_ABORTED) break;
3204 if (data.devices_status == STATUS_QUIT) break;
3205 if (data.devices_status == STATUS_BYPASS) break;
3206
3207 salt_t *salt_buf = &data.salts_buf[salt_pos];
3208
3209 device_param->kernel_params_buf32[24] = salt_pos;
3210 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3211 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3212
3213 FILE *combs_fp = device_param->combs_fp;
3214
3215 if (data.attack_mode == ATTACK_MODE_COMBI)
3216 {
3217 rewind (combs_fp);
3218 }
3219
3220 // innerloops
3221
3222 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3223 {
3224 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3225
3226 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3227
3228 if (data.devices_status == STATUS_CRACKED) break;
3229 if (data.devices_status == STATUS_ABORTED) break;
3230 if (data.devices_status == STATUS_QUIT) break;
3231 if (data.devices_status == STATUS_BYPASS) break;
3232
3233 uint innerloop_left = innerloop_cnt - innerloop_pos;
3234
3235 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3236
3237 device_param->innerloop_pos = innerloop_pos;
3238 device_param->innerloop_left = innerloop_left;
3239
3240 device_param->kernel_params_buf32[27] = innerloop_left;
3241
3242 // i think we can get rid of this
3243 if (innerloop_left == 0)
3244 {
3245 puts ("bug, how should this happen????\n");
3246
3247 continue;
3248 }
3249
3250 if (data.salts_shown[salt_pos] == 1)
3251 {
3252 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3253
3254 continue;
3255 }
3256
3257 // initialize amplifiers
3258
3259 if (data.attack_mode == ATTACK_MODE_COMBI)
3260 {
3261 uint i = 0;
3262
3263 while (i < innerloop_left)
3264 {
3265 if (feof (combs_fp)) break;
3266
3267 int line_len = fgetl (combs_fp, line_buf);
3268
3269 if (line_len >= PW_MAX1) continue;
3270
3271 line_len = convert_from_hex (line_buf, line_len);
3272
3273 char *line_buf_new = line_buf;
3274
3275 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3276 {
3277 char rule_buf_out[BLOCK_SIZE] = { 0 };
3278
3279 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3280
3281 if (rule_len_out < 0)
3282 {
3283 data.words_progress_rejected[salt_pos] += pws_cnt;
3284
3285 continue;
3286 }
3287
3288 line_len = rule_len_out;
3289
3290 line_buf_new = rule_buf_out;
3291 }
3292
3293 line_len = MIN (line_len, PW_DICTMAX);
3294
3295 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3296
3297 memcpy (ptr, line_buf_new, line_len);
3298
3299 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3300
3301 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3302 {
3303 uppercase (ptr, line_len);
3304 }
3305
3306 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3307 {
3308 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3309 {
3310 ptr[line_len] = 0x80;
3311 }
3312
3313 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3314 {
3315 ptr[line_len] = 0x01;
3316 }
3317 }
3318
3319 device_param->combs_buf[i].pw_len = line_len;
3320
3321 i++;
3322 }
3323
3324 for (uint j = i; j < innerloop_left; j++)
3325 {
3326 device_param->combs_buf[j].i[0] = 0;
3327 device_param->combs_buf[j].i[1] = 0;
3328 device_param->combs_buf[j].i[2] = 0;
3329 device_param->combs_buf[j].i[3] = 0;
3330 device_param->combs_buf[j].i[4] = 0;
3331 device_param->combs_buf[j].i[5] = 0;
3332 device_param->combs_buf[j].i[6] = 0;
3333 device_param->combs_buf[j].i[7] = 0;
3334
3335 device_param->combs_buf[j].pw_len = 0;
3336 }
3337
3338 innerloop_left = i;
3339 }
3340 else if (data.attack_mode == ATTACK_MODE_BF)
3341 {
3342 u64 off = innerloop_pos;
3343
3344 device_param->kernel_params_mp_r_buf64[3] = off;
3345
3346 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3347 }
3348 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3349 {
3350 u64 off = innerloop_pos;
3351
3352 device_param->kernel_params_mp_buf64[3] = off;
3353
3354 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3355 }
3356 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3357 {
3358 u64 off = innerloop_pos;
3359
3360 device_param->kernel_params_mp_buf64[3] = off;
3361
3362 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3363 }
3364
3365 // copy amplifiers
3366
3367 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3368 {
3369 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
3370 }
3371 else if (data.attack_mode == ATTACK_MODE_COMBI)
3372 {
3373 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
3374 }
3375 else if (data.attack_mode == ATTACK_MODE_BF)
3376 {
3377 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
3378 }
3379 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3380 {
3381 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3382 }
3383 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3384 {
3385 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3386 }
3387
3388 if (data.benchmark == 1)
3389 {
3390 hc_timer_set (&device_param->timer_speed);
3391 }
3392
3393 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3394
3395 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3396
3397 if (data.devices_status == STATUS_CRACKED) break;
3398 if (data.devices_status == STATUS_ABORTED) break;
3399 if (data.devices_status == STATUS_QUIT) break;
3400
3401 /**
3402 * result
3403 */
3404
3405 if (data.benchmark == 0)
3406 {
3407 check_cracked (device_param, salt_pos);
3408 }
3409
3410 /**
3411 * progress
3412 */
3413
3414 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3415
3416 hc_thread_mutex_lock (mux_counter);
3417
3418 data.words_progress_done[salt_pos] += perf_sum_all;
3419
3420 hc_thread_mutex_unlock (mux_counter);
3421
3422 /**
3423 * speed
3424 */
3425
3426 double speed_ms;
3427
3428 hc_timer_get (device_param->timer_speed, speed_ms);
3429
3430 hc_timer_set (&device_param->timer_speed);
3431
3432 // current speed
3433
3434 //hc_thread_mutex_lock (mux_display);
3435
3436 device_param->speed_cnt[speed_pos] = perf_sum_all;
3437
3438 device_param->speed_ms[speed_pos] = speed_ms;
3439
3440 //hc_thread_mutex_unlock (mux_display);
3441
3442 speed_pos++;
3443
3444 if (speed_pos == SPEED_CACHE)
3445 {
3446 speed_pos = 0;
3447 }
3448
3449 /**
3450 * benchmark
3451 */
3452
3453 if (data.benchmark == 1) break;
3454 }
3455 }
3456
3457 device_param->speed_pos = speed_pos;
3458
3459 myfree (line_buf);
3460 }
3461
3462 static void load_segment (wl_data_t *wl_data, FILE *fd)
3463 {
3464 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3465
3466 wl_data->pos = 0;
3467
3468 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3469
3470 wl_data->buf[wl_data->cnt] = 0;
3471
3472 if (wl_data->cnt == 0) return;
3473
3474 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3475
3476 while (!feof (fd))
3477 {
3478 if (wl_data->cnt == wl_data->avail)
3479 {
3480 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3481
3482 wl_data->avail += wl_data->incr;
3483 }
3484
3485 const int c = fgetc (fd);
3486
3487 if (c == EOF) break;
3488
3489 wl_data->buf[wl_data->cnt] = (char) c;
3490
3491 wl_data->cnt++;
3492
3493 if (c == '\n') break;
3494 }
3495
3496 // ensure stream ends with a newline
3497
3498 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3499 {
3500 wl_data->cnt++;
3501
3502 wl_data->buf[wl_data->cnt - 1] = '\n';
3503 }
3504
3505 return;
3506 }
3507
3508 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3509 {
3510 char *ptr = buf;
3511
3512 for (u32 i = 0; i < sz; i++, ptr++)
3513 {
3514 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3515
3516 if (i == 7)
3517 {
3518 *off = i;
3519 *len = i;
3520
3521 return;
3522 }
3523
3524 if (*ptr != '\n') continue;
3525
3526 *off = i + 1;
3527
3528 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3529
3530 *len = i;
3531
3532 return;
3533 }
3534
3535 *off = sz;
3536 *len = sz;
3537 }
3538
3539 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3540 {
3541 char *ptr = buf;
3542
3543 for (u32 i = 0; i < sz; i++, ptr++)
3544 {
3545 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3546
3547 if (*ptr != '\n') continue;
3548
3549 *off = i + 1;
3550
3551 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3552
3553 *len = i;
3554
3555 return;
3556 }
3557
3558 *off = sz;
3559 *len = sz;
3560 }
3561
3562 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3563 {
3564 char *ptr = buf;
3565
3566 for (u32 i = 0; i < sz; i++, ptr++)
3567 {
3568 if (*ptr != '\n') continue;
3569
3570 *off = i + 1;
3571
3572 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3573
3574 *len = i;
3575
3576 return;
3577 }
3578
3579 *off = sz;
3580 *len = sz;
3581 }
3582
3583 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3584 {
3585 while (wl_data->pos < wl_data->cnt)
3586 {
3587 uint off;
3588 uint len;
3589
3590 char *ptr = wl_data->buf + wl_data->pos;
3591
3592 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3593
3594 wl_data->pos += off;
3595
3596 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3597 {
3598 char rule_buf_out[BLOCK_SIZE] = { 0 };
3599
3600 int rule_len_out = -1;
3601
3602 if (len < BLOCK_SIZE)
3603 {
3604 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3605 }
3606
3607 if (rule_len_out < 0)
3608 {
3609 continue;
3610 }
3611
3612 if (rule_len_out > PW_MAX)
3613 {
3614 continue;
3615 }
3616 }
3617 else
3618 {
3619 if (len > PW_MAX)
3620 {
3621 continue;
3622 }
3623 }
3624
3625 *out_buf = ptr;
3626 *out_len = len;
3627
3628 return;
3629 }
3630
3631 if (feof (fd))
3632 {
3633 fprintf (stderr, "BUG feof()!!\n");
3634
3635 return;
3636 }
3637
3638 load_segment (wl_data, fd);
3639
3640 get_next_word (wl_data, fd, out_buf, out_len);
3641 }
3642
3643 #ifdef _POSIX
3644 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3645 #endif
3646
3647 #ifdef _WIN
3648 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3649 #endif
3650 {
3651 hc_signal (NULL);
3652
3653 dictstat_t d;
3654
3655 d.cnt = 0;
3656
3657 #ifdef _POSIX
3658 fstat (fileno (fd), &d.stat);
3659 #endif
3660
3661 #ifdef _WIN
3662 _fstat64 (fileno (fd), &d.stat);
3663 #endif
3664
3665 d.stat.st_mode = 0;
3666 d.stat.st_nlink = 0;
3667 d.stat.st_uid = 0;
3668 d.stat.st_gid = 0;
3669 d.stat.st_rdev = 0;
3670 d.stat.st_atime = 0;
3671
3672 #ifdef _POSIX
3673 d.stat.st_blksize = 0;
3674 d.stat.st_blocks = 0;
3675 #endif
3676
3677 if (d.stat.st_size == 0) return 0;
3678
3679 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3680
3681 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3682 {
3683 if (d_cache)
3684 {
3685 u64 cnt = d_cache->cnt;
3686
3687 u64 keyspace = cnt;
3688
3689 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3690 {
3691 keyspace *= data.kernel_rules_cnt;
3692 }
3693 else if (data.attack_kern == ATTACK_KERN_COMBI)
3694 {
3695 keyspace *= data.combs_cnt;
3696 }
3697
3698 if (data.quiet == 0) log_info ("Cache-hit dictionary stats %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) d.stat.st_size, (unsigned long long int) cnt, (unsigned long long int) keyspace);
3699 if (data.quiet == 0) log_info ("");
3700
3701 hc_signal (sigHandler_default);
3702
3703 return (keyspace);
3704 }
3705 }
3706
3707 time_t now = 0;
3708 time_t prev = 0;
3709
3710 u64 comp = 0;
3711 u64 cnt = 0;
3712 u64 cnt2 = 0;
3713
3714 while (!feof (fd))
3715 {
3716 load_segment (wl_data, fd);
3717
3718 comp += wl_data->cnt;
3719
3720 u32 i = 0;
3721
3722 while (i < wl_data->cnt)
3723 {
3724 u32 len;
3725 u32 off;
3726
3727 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3728
3729 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3730 {
3731 char rule_buf_out[BLOCK_SIZE] = { 0 };
3732
3733 int rule_len_out = -1;
3734
3735 if (len < BLOCK_SIZE)
3736 {
3737 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3738 }
3739
3740 if (rule_len_out < 0)
3741 {
3742 len = PW_MAX1;
3743 }
3744 else
3745 {
3746 len = rule_len_out;
3747 }
3748 }
3749
3750 if (len < PW_MAX1)
3751 {
3752 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3753 {
3754 cnt += data.kernel_rules_cnt;
3755 }
3756 else if (data.attack_kern == ATTACK_KERN_COMBI)
3757 {
3758 cnt += data.combs_cnt;
3759 }
3760
3761 d.cnt++;
3762 }
3763
3764 i += off;
3765
3766 cnt2++;
3767 }
3768
3769 time (&now);
3770
3771 if ((now - prev) == 0) continue;
3772
3773 float percent = (float) comp / (float) d.stat.st_size;
3774
3775 if (data.quiet == 0) log_info_nn ("Generating dictionary stats for %s: %llu bytes (%.2f%%), %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, percent * 100, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3776
3777 time (&prev);
3778 }
3779
3780 if (data.quiet == 0) log_info ("Generated dictionary stats for %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3781 if (data.quiet == 0) log_info ("");
3782
3783 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3784
3785 hc_signal (sigHandler_default);
3786
3787 return (cnt);
3788 }
3789
3790 static void *thread_monitor (void *p)
3791 {
3792 uint runtime_check = 0;
3793 uint remove_check = 0;
3794 uint status_check = 0;
3795 uint restore_check = 0;
3796
3797 uint restore_left = data.restore_timer;
3798 uint remove_left = data.remove_timer;
3799 uint status_left = data.status_timer;
3800
3801 #ifdef HAVE_HWMON
3802 uint hwmon_check = 0;
3803
3804 int slowdown_warnings = 0;
3805
3806 // these variables are mainly used for fan control
3807
3808 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3809
3810 // temperature controller "loopback" values
3811
3812 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3813 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3814
3815 int temp_threshold = 1; // degrees celcius
3816
3817 int fan_speed_min = 15; // in percentage
3818 int fan_speed_max = 100;
3819
3820 time_t last_temp_check_time;
3821 #endif // HAVE_HWMON
3822
3823 uint sleep_time = 1;
3824
3825 if (data.runtime)
3826 {
3827 runtime_check = 1;
3828 }
3829
3830 if (data.restore_timer)
3831 {
3832 restore_check = 1;
3833 }
3834
3835 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3836 {
3837 remove_check = 1;
3838 }
3839
3840 if (data.status == 1)
3841 {
3842 status_check = 1;
3843 }
3844
3845 #ifdef HAVE_HWMON
3846 if (data.gpu_temp_disable == 0)
3847 {
3848 time (&last_temp_check_time);
3849
3850 hwmon_check = 1;
3851 }
3852 #endif
3853
3854 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3855 {
3856 #ifdef HAVE_HWMON
3857 if (hwmon_check == 0)
3858 #endif
3859 return (p);
3860 }
3861
3862 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3863 {
3864 hc_sleep (sleep_time);
3865
3866 if (data.devices_status != STATUS_RUNNING) continue;
3867
3868 #ifdef HAVE_HWMON
3869
3870 if (hwmon_check == 1)
3871 {
3872 hc_thread_mutex_lock (mux_adl);
3873
3874 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3875 {
3876 hc_device_param_t *device_param = &data.devices_param[device_id];
3877
3878 if (device_param->skipped) continue;
3879
3880 if (device_param->device_vendor_id == VENDOR_ID_NV)
3881 {
3882 if (data.hm_nvapi)
3883 {
3884 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
3885 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
3886
3887 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
3888 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
3889
3890 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
3891
3892 perfPolicies_status.info_value = perfPolicies_info.info_value;
3893
3894 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
3895
3896 if (perfPolicies_status.throttle & 2)
3897 {
3898 if (slowdown_warnings < 3)
3899 {
3900 if (data.quiet == 0) clear_prompt ();
3901
3902 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
3903
3904 if (slowdown_warnings == 2)
3905 {
3906 log_info ("");
3907 }
3908
3909 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
3910 if (data.quiet == 0) fflush (stdout);
3911
3912 slowdown_warnings++;
3913 }
3914 }
3915 else
3916 {
3917 slowdown_warnings = 0;
3918 }
3919 }
3920 }
3921 }
3922
3923 hc_thread_mutex_unlock (mux_adl);
3924 }
3925
3926 if (hwmon_check == 1)
3927 {
3928 hc_thread_mutex_lock (mux_adl);
3929
3930 time_t temp_check_time;
3931
3932 time (&temp_check_time);
3933
3934 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3935
3936 if (Ta == 0) Ta = 1;
3937
3938 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3939 {
3940 hc_device_param_t *device_param = &data.devices_param[device_id];
3941
3942 if (device_param->skipped) continue;
3943
3944 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3945
3946 const int temperature = hm_get_temperature_with_device_id (device_id);
3947
3948 if (temperature > (int) data.gpu_temp_abort)
3949 {
3950 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3951
3952 if (data.devices_status != STATUS_QUIT) myabort ();
3953
3954 break;
3955 }
3956
3957 const int gpu_temp_retain = data.gpu_temp_retain;
3958
3959 if (gpu_temp_retain)
3960 {
3961 if (data.hm_device[device_id].fan_set_supported == 1)
3962 {
3963 int temp_cur = temperature;
3964
3965 int temp_diff_new = gpu_temp_retain - temp_cur;
3966
3967 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3968
3969 // calculate Ta value (time difference in seconds between the last check and this check)
3970
3971 last_temp_check_time = temp_check_time;
3972
3973 float Kp = 1.8;
3974 float Ki = 0.005;
3975 float Kd = 6;
3976
3977 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3978
3979 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
3980
3981 if (abs (fan_diff_required) >= temp_threshold)
3982 {
3983 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3984
3985 int fan_speed_level = fan_speed_cur;
3986
3987 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3988
3989 int fan_speed_new = fan_speed_level - fan_diff_required;
3990
3991 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3992 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3993
3994 if (fan_speed_new != fan_speed_cur)
3995 {
3996 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3997 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3998
3999 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4000 {
4001 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4002 {
4003 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4004 }
4005 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4006 {
4007
4008 }
4009
4010 fan_speed_chgd[device_id] = 1;
4011 }
4012
4013 temp_diff_old[device_id] = temp_diff_new;
4014 }
4015 }
4016 }
4017 }
4018 }
4019
4020 hc_thread_mutex_unlock (mux_adl);
4021 }
4022 #endif // HAVE_HWMON
4023
4024 if (restore_check == 1)
4025 {
4026 restore_left--;
4027
4028 if (restore_left == 0)
4029 {
4030 if (data.restore_disable == 0) cycle_restore ();
4031
4032 restore_left = data.restore_timer;
4033 }
4034 }
4035
4036 if ((runtime_check == 1) && (data.runtime_start > 0))
4037 {
4038 time_t runtime_cur;
4039
4040 time (&runtime_cur);
4041
4042 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4043
4044 if (runtime_left <= 0)
4045 {
4046 if (data.benchmark == 0)
4047 {
4048 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4049 }
4050
4051 if (data.devices_status != STATUS_QUIT) myabort ();
4052 }
4053 }
4054
4055 if (remove_check == 1)
4056 {
4057 remove_left--;
4058
4059 if (remove_left == 0)
4060 {
4061 if (data.digests_saved != data.digests_done)
4062 {
4063 data.digests_saved = data.digests_done;
4064
4065 save_hash ();
4066 }
4067
4068 remove_left = data.remove_timer;
4069 }
4070 }
4071
4072 if (status_check == 1)
4073 {
4074 status_left--;
4075
4076 if (status_left == 0)
4077 {
4078 //hc_thread_mutex_lock (mux_display);
4079
4080 if (data.quiet == 0) clear_prompt ();
4081
4082 if (data.quiet == 0) log_info ("");
4083
4084 status_display ();
4085
4086 if (data.quiet == 0) log_info ("");
4087
4088 //hc_thread_mutex_unlock (mux_display);
4089
4090 status_left = data.status_timer;
4091 }
4092 }
4093 }
4094
4095 #ifdef HAVE_HWMON
4096 myfree (fan_speed_chgd);
4097
4098 myfree (temp_diff_old);
4099 myfree (temp_diff_sum);
4100 #endif
4101
4102 p = NULL;
4103
4104 return (p);
4105 }
4106
4107 static void *thread_outfile_remove (void *p)
4108 {
4109 // some hash-dependent constants
4110 char *outfile_dir = data.outfile_check_directory;
4111 uint dgst_size = data.dgst_size;
4112 uint isSalted = data.isSalted;
4113 uint esalt_size = data.esalt_size;
4114 uint hash_mode = data.hash_mode;
4115
4116 uint outfile_check_timer = data.outfile_check_timer;
4117
4118 char separator = data.separator;
4119
4120 // some hash-dependent functions
4121 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4122 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4123
4124 // buffers
4125 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4126
4127 hash_buf.digest = mymalloc (dgst_size);
4128
4129 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4130
4131 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4132
4133 uint digest_buf[64] = { 0 };
4134
4135 outfile_data_t *out_info = NULL;
4136
4137 char **out_files = NULL;
4138
4139 time_t folder_mtime = 0;
4140
4141 int out_cnt = 0;
4142
4143 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4144
4145 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4146 {
4147 hc_sleep (1);
4148
4149 if (data.devices_status != STATUS_RUNNING) continue;
4150
4151 check_left--;
4152
4153 if (check_left == 0)
4154 {
4155 struct stat outfile_check_stat;
4156
4157 if (stat (outfile_dir, &outfile_check_stat) == 0)
4158 {
4159 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4160
4161 if (is_dir == 1)
4162 {
4163 if (outfile_check_stat.st_mtime > folder_mtime)
4164 {
4165 char **out_files_new = scan_directory (outfile_dir);
4166
4167 int out_cnt_new = count_dictionaries (out_files_new);
4168
4169 outfile_data_t *out_info_new = NULL;
4170
4171 if (out_cnt_new > 0)
4172 {
4173 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4174
4175 for (int i = 0; i < out_cnt_new; i++)
4176 {
4177 out_info_new[i].file_name = out_files_new[i];
4178
4179 // check if there are files that we have seen/checked before (and not changed)
4180
4181 for (int j = 0; j < out_cnt; j++)
4182 {
4183 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4184 {
4185 struct stat outfile_stat;
4186
4187 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4188 {
4189 if (outfile_stat.st_ctime == out_info[j].ctime)
4190 {
4191 out_info_new[i].ctime = out_info[j].ctime;
4192 out_info_new[i].seek = out_info[j].seek;
4193 }
4194 }
4195 }
4196 }
4197 }
4198 }
4199
4200 local_free (out_info);
4201 local_free (out_files);
4202
4203 out_files = out_files_new;
4204 out_cnt = out_cnt_new;
4205 out_info = out_info_new;
4206
4207 folder_mtime = outfile_check_stat.st_mtime;
4208 }
4209
4210 for (int j = 0; j < out_cnt; j++)
4211 {
4212 FILE *fp = fopen (out_info[j].file_name, "rb");
4213
4214 if (fp != NULL)
4215 {
4216 //hc_thread_mutex_lock (mux_display);
4217
4218 #ifdef _POSIX
4219 struct stat outfile_stat;
4220
4221 fstat (fileno (fp), &outfile_stat);
4222 #endif
4223
4224 #ifdef _WIN
4225 struct stat64 outfile_stat;
4226
4227 _fstat64 (fileno (fp), &outfile_stat);
4228 #endif
4229
4230 if (outfile_stat.st_ctime > out_info[j].ctime)
4231 {
4232 out_info[j].ctime = outfile_stat.st_ctime;
4233 out_info[j].seek = 0;
4234 }
4235
4236 fseek (fp, out_info[j].seek, SEEK_SET);
4237
4238 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4239
4240 while (!feof (fp))
4241 {
4242 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4243
4244 if (ptr == NULL) break;
4245
4246 int line_len = strlen (line_buf);
4247
4248 if (line_len <= 0) continue;
4249
4250 int iter = MAX_CUT_TRIES;
4251
4252 for (uint i = line_len - 1; i && iter; i--, line_len--)
4253 {
4254 if (line_buf[i] != separator) continue;
4255
4256 int parser_status = PARSER_OK;
4257
4258 if ((hash_mode != 2500) && (hash_mode != 6800))
4259 {
4260 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4261 }
4262
4263 uint found = 0;
4264
4265 if (parser_status == PARSER_OK)
4266 {
4267 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4268 {
4269 if (data.salts_shown[salt_pos] == 1) continue;
4270
4271 salt_t *salt_buf = &data.salts_buf[salt_pos];
4272
4273 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4274 {
4275 uint idx = salt_buf->digests_offset + digest_pos;
4276
4277 if (data.digests_shown[idx] == 1) continue;
4278
4279 uint cracked = 0;
4280
4281 if (hash_mode == 6800)
4282 {
4283 if (i == salt_buf->salt_len)
4284 {
4285 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4286 }
4287 }
4288 else if (hash_mode == 2500)
4289 {
4290 // BSSID : MAC1 : MAC2 (:plain)
4291 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4292 {
4293 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4294
4295 if (!cracked) continue;
4296
4297 // now compare MAC1 and MAC2 too, since we have this additional info
4298 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4299 char *mac2_pos = mac1_pos + 12 + 1;
4300
4301 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4302 wpa_t *wpa = &wpas[salt_pos];
4303
4304 // compare hex string(s) vs binary MAC address(es)
4305
4306 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4307 {
4308 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4309 {
4310 cracked = 0;
4311
4312 break;
4313 }
4314 }
4315
4316 // early skip ;)
4317 if (!cracked) continue;
4318
4319 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4320 {
4321 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4322 {
4323 cracked = 0;
4324
4325 break;
4326 }
4327 }
4328 }
4329 }
4330 else
4331 {
4332 char *digests_buf_ptr = (char *) data.digests_buf;
4333
4334 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4335
4336 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4337 }
4338
4339 if (cracked == 1)
4340 {
4341 found = 1;
4342
4343 data.digests_shown[idx] = 1;
4344
4345 data.digests_done++;
4346
4347 salt_buf->digests_done++;
4348
4349 if (salt_buf->digests_done == salt_buf->digests_cnt)
4350 {
4351 data.salts_shown[salt_pos] = 1;
4352
4353 data.salts_done++;
4354
4355 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4356 }
4357 }
4358 }
4359
4360 if (data.devices_status == STATUS_CRACKED) break;
4361 }
4362 }
4363
4364 if (found) break;
4365
4366 if (data.devices_status == STATUS_CRACKED) break;
4367
4368 iter--;
4369 }
4370
4371 if (data.devices_status == STATUS_CRACKED) break;
4372 }
4373
4374 myfree (line_buf);
4375
4376 out_info[j].seek = ftell (fp);
4377
4378 //hc_thread_mutex_unlock (mux_display);
4379
4380 fclose (fp);
4381 }
4382 }
4383 }
4384 }
4385
4386 check_left = outfile_check_timer;
4387 }
4388 }
4389
4390 if (esalt_size) local_free (hash_buf.esalt);
4391
4392 if (isSalted) local_free (hash_buf.salt);
4393
4394 local_free (hash_buf.digest);
4395
4396 local_free (out_info);
4397
4398 local_free (out_files);
4399
4400 p = NULL;
4401
4402 return (p);
4403 }
4404
4405 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4406 {
4407 //if (device_param->pws_cnt < device_param->kernel_power)
4408 //{
4409 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4410
4411 u8 *ptr = (u8 *) pw->i;
4412
4413 memcpy (ptr, pw_buf, pw_len);
4414
4415 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4416
4417 pw->pw_len = pw_len;
4418
4419 device_param->pws_cnt++;
4420 //}
4421 //else
4422 //{
4423 // fprintf (stderr, "BUG pw_add()!!\n");
4424 //
4425 // return;
4426 //}
4427 }
4428
4429 static void set_kernel_power_final (const u64 kernel_power_final)
4430 {
4431 if (data.quiet == 0)
4432 {
4433 clear_prompt ();
4434
4435 //log_info ("");
4436
4437 log_info ("INFO: approaching final keyspace, workload adjusted");
4438 log_info ("");
4439
4440 fprintf (stdout, "%s", PROMPT);
4441
4442 fflush (stdout);
4443 }
4444
4445 data.kernel_power_final = kernel_power_final;
4446 }
4447
4448 static u32 get_power (hc_device_param_t *device_param)
4449 {
4450 const u64 kernel_power_final = data.kernel_power_final;
4451
4452 if (kernel_power_final)
4453 {
4454 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4455
4456 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4457
4458 // work should be at least the hardware power available without any accelerator
4459
4460 const u64 work = MAX (words_left_device, device_param->hardware_power);
4461
4462 return work;
4463 }
4464
4465 return device_param->kernel_power;
4466 }
4467
4468 static uint get_work (hc_device_param_t *device_param, const u64 max)
4469 {
4470 hc_thread_mutex_lock (mux_dispatcher);
4471
4472 const u64 words_cur = data.words_cur;
4473 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4474
4475 device_param->words_off = words_cur;
4476
4477 const u64 kernel_power_all = data.kernel_power_all;
4478
4479 const u64 words_left = words_base - words_cur;
4480
4481 if (words_left < kernel_power_all)
4482 {
4483 if (data.kernel_power_final == 0)
4484 {
4485 set_kernel_power_final (words_left);
4486 }
4487 }
4488
4489 const u32 kernel_power = get_power (device_param);
4490
4491 uint work = MIN (words_left, kernel_power);
4492
4493 work = MIN (work, max);
4494
4495 data.words_cur += work;
4496
4497 hc_thread_mutex_unlock (mux_dispatcher);
4498
4499 return work;
4500 }
4501
4502 static void *thread_autotune (void *p)
4503 {
4504 hc_device_param_t *device_param = (hc_device_param_t *) p;
4505
4506 if (device_param->skipped) return NULL;
4507
4508 autotune (device_param);
4509
4510 return NULL;
4511 }
4512
4513 static void *thread_calc_stdin (void *p)
4514 {
4515 hc_device_param_t *device_param = (hc_device_param_t *) p;
4516
4517 if (device_param->skipped) return NULL;
4518
4519 char *buf = (char *) mymalloc (HCBUFSIZ);
4520
4521 const uint attack_kern = data.attack_kern;
4522
4523 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4524 {
4525 hc_thread_mutex_lock (mux_dispatcher);
4526
4527 if (feof (stdin) != 0)
4528 {
4529 hc_thread_mutex_unlock (mux_dispatcher);
4530
4531 break;
4532 }
4533
4534 uint words_cur = 0;
4535
4536 while (words_cur < device_param->kernel_power)
4537 {
4538 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4539
4540 if (line_buf == NULL) break;
4541
4542 uint line_len = in_superchop (line_buf);
4543
4544 line_len = convert_from_hex (line_buf, line_len);
4545
4546 // post-process rule engine
4547
4548 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4549 {
4550 char rule_buf_out[BLOCK_SIZE] = { 0 };
4551
4552 int rule_len_out = -1;
4553
4554 if (line_len < BLOCK_SIZE)
4555 {
4556 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4557 }
4558
4559 if (rule_len_out < 0) continue;
4560
4561 line_buf = rule_buf_out;
4562 line_len = rule_len_out;
4563 }
4564
4565 if (line_len > PW_MAX)
4566 {
4567 continue;
4568 }
4569
4570 // hmm that's always the case, or?
4571
4572 if (attack_kern == ATTACK_KERN_STRAIGHT)
4573 {
4574 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4575 {
4576 hc_thread_mutex_lock (mux_counter);
4577
4578 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4579 {
4580 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4581 }
4582
4583 hc_thread_mutex_unlock (mux_counter);
4584
4585 continue;
4586 }
4587 }
4588
4589 pw_add (device_param, (u8 *) line_buf, line_len);
4590
4591 words_cur++;
4592
4593 if (data.devices_status == STATUS_CRACKED) break;
4594 if (data.devices_status == STATUS_ABORTED) break;
4595 if (data.devices_status == STATUS_QUIT) break;
4596 if (data.devices_status == STATUS_BYPASS) break;
4597 }
4598
4599 hc_thread_mutex_unlock (mux_dispatcher);
4600
4601 if (data.devices_status == STATUS_CRACKED) break;
4602 if (data.devices_status == STATUS_ABORTED) break;
4603 if (data.devices_status == STATUS_QUIT) break;
4604 if (data.devices_status == STATUS_BYPASS) break;
4605
4606 // flush
4607
4608 const uint pws_cnt = device_param->pws_cnt;
4609
4610 if (pws_cnt)
4611 {
4612 run_copy (device_param, pws_cnt);
4613
4614 run_cracker (device_param, pws_cnt);
4615
4616 device_param->pws_cnt = 0;
4617
4618 /*
4619 still required?
4620 if (attack_kern == ATTACK_KERN_STRAIGHT)
4621 {
4622 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4623 }
4624 else if (attack_kern == ATTACK_KERN_COMBI)
4625 {
4626 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4627 }
4628 */
4629 }
4630 }
4631
4632 device_param->kernel_accel = 0;
4633 device_param->kernel_loops = 0;
4634
4635 myfree (buf);
4636
4637 return NULL;
4638 }
4639
4640 static void *thread_calc (void *p)
4641 {
4642 hc_device_param_t *device_param = (hc_device_param_t *) p;
4643
4644 if (device_param->skipped) return NULL;
4645
4646 const uint attack_mode = data.attack_mode;
4647 const uint attack_kern = data.attack_kern;
4648
4649 if (attack_mode == ATTACK_MODE_BF)
4650 {
4651 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4652 {
4653 const uint work = get_work (device_param, -1);
4654
4655 if (work == 0) break;
4656
4657 const u64 words_off = device_param->words_off;
4658 const u64 words_fin = words_off + work;
4659
4660 const uint pws_cnt = work;
4661
4662 device_param->pws_cnt = pws_cnt;
4663
4664 if (pws_cnt)
4665 {
4666 run_copy (device_param, pws_cnt);
4667
4668 run_cracker (device_param, pws_cnt);
4669
4670 device_param->pws_cnt = 0;
4671
4672 /*
4673 still required?
4674 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4675 */
4676 }
4677
4678 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4679
4680 if (data.devices_status == STATUS_CRACKED) break;
4681 if (data.devices_status == STATUS_ABORTED) break;
4682 if (data.devices_status == STATUS_QUIT) break;
4683 if (data.devices_status == STATUS_BYPASS) break;
4684
4685 if (data.benchmark == 1) break;
4686
4687 device_param->words_done = words_fin;
4688 }
4689 }
4690 else
4691 {
4692 const uint segment_size = data.segment_size;
4693
4694 char *dictfile = data.dictfile;
4695
4696 if (attack_mode == ATTACK_MODE_COMBI)
4697 {
4698 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4699 {
4700 dictfile = data.dictfile2;
4701 }
4702 }
4703
4704 FILE *fd = fopen (dictfile, "rb");
4705
4706 if (fd == NULL)
4707 {
4708 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4709
4710 return NULL;
4711 }
4712
4713 if (attack_mode == ATTACK_MODE_COMBI)
4714 {
4715 const uint combs_mode = data.combs_mode;
4716
4717 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4718 {
4719 const char *dictfilec = data.dictfile2;
4720
4721 FILE *combs_fp = fopen (dictfilec, "rb");
4722
4723 if (combs_fp == NULL)
4724 {
4725 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4726
4727 fclose (fd);
4728
4729 return NULL;
4730 }
4731
4732 device_param->combs_fp = combs_fp;
4733 }
4734 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4735 {
4736 const char *dictfilec = data.dictfile;
4737
4738 FILE *combs_fp = fopen (dictfilec, "rb");
4739
4740 if (combs_fp == NULL)
4741 {
4742 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4743
4744 fclose (fd);
4745
4746 return NULL;
4747 }
4748
4749 device_param->combs_fp = combs_fp;
4750 }
4751 }
4752
4753 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4754
4755 wl_data->buf = (char *) mymalloc (segment_size);
4756 wl_data->avail = segment_size;
4757 wl_data->incr = segment_size;
4758 wl_data->cnt = 0;
4759 wl_data->pos = 0;
4760
4761 u64 words_cur = 0;
4762
4763 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4764 {
4765 u64 words_off = 0;
4766 u64 words_fin = 0;
4767
4768 u64 max = -1;
4769
4770 while (max)
4771 {
4772 const uint work = get_work (device_param, max);
4773
4774 if (work == 0) break;
4775
4776 max = 0;
4777
4778 words_off = device_param->words_off;
4779 words_fin = words_off + work;
4780
4781 char *line_buf;
4782 uint line_len;
4783
4784 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4785
4786 for ( ; words_cur < words_fin; words_cur++)
4787 {
4788 get_next_word (wl_data, fd, &line_buf, &line_len);
4789
4790 line_len = convert_from_hex (line_buf, line_len);
4791
4792 // post-process rule engine
4793
4794 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4795 {
4796 char rule_buf_out[BLOCK_SIZE] = { 0 };
4797
4798 int rule_len_out = -1;
4799
4800 if (line_len < BLOCK_SIZE)
4801 {
4802 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4803 }
4804
4805 if (rule_len_out < 0) continue;
4806
4807 line_buf = rule_buf_out;
4808 line_len = rule_len_out;
4809 }
4810
4811 if (attack_kern == ATTACK_KERN_STRAIGHT)
4812 {
4813 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4814 {
4815 max++;
4816
4817 hc_thread_mutex_lock (mux_counter);
4818
4819 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4820 {
4821 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4822 }
4823
4824 hc_thread_mutex_unlock (mux_counter);
4825
4826 continue;
4827 }
4828 }
4829 else if (attack_kern == ATTACK_KERN_COMBI)
4830 {
4831 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4832 // since we still need to combine the plains
4833
4834 if (line_len > data.pw_max)
4835 {
4836 max++;
4837
4838 hc_thread_mutex_lock (mux_counter);
4839
4840 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4841 {
4842 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4843 }
4844
4845 hc_thread_mutex_unlock (mux_counter);
4846
4847 continue;
4848 }
4849 }
4850
4851 pw_add (device_param, (u8 *) line_buf, line_len);
4852
4853 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4854
4855 if (data.devices_status == STATUS_CRACKED) break;
4856 if (data.devices_status == STATUS_ABORTED) break;
4857 if (data.devices_status == STATUS_QUIT) break;
4858 if (data.devices_status == STATUS_BYPASS) break;
4859 }
4860
4861 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4862
4863 if (data.devices_status == STATUS_CRACKED) break;
4864 if (data.devices_status == STATUS_ABORTED) break;
4865 if (data.devices_status == STATUS_QUIT) break;
4866 if (data.devices_status == STATUS_BYPASS) break;
4867 }
4868
4869 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4870
4871 if (data.devices_status == STATUS_CRACKED) break;
4872 if (data.devices_status == STATUS_ABORTED) break;
4873 if (data.devices_status == STATUS_QUIT) break;
4874 if (data.devices_status == STATUS_BYPASS) break;
4875
4876 //
4877 // flush
4878 //
4879
4880 const uint pws_cnt = device_param->pws_cnt;
4881
4882 if (pws_cnt)
4883 {
4884 run_copy (device_param, pws_cnt);
4885
4886 run_cracker (device_param, pws_cnt);
4887
4888 device_param->pws_cnt = 0;
4889
4890 /*
4891 still required?
4892 if (attack_kern == ATTACK_KERN_STRAIGHT)
4893 {
4894 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4895 }
4896 else if (attack_kern == ATTACK_KERN_COMBI)
4897 {
4898 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4899 }
4900 */
4901 }
4902
4903 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4904
4905 if (data.devices_status == STATUS_CRACKED) break;
4906 if (data.devices_status == STATUS_ABORTED) break;
4907 if (data.devices_status == STATUS_QUIT) break;
4908 if (data.devices_status == STATUS_BYPASS) break;
4909
4910 if (words_fin == 0) break;
4911
4912 device_param->words_done = words_fin;
4913 }
4914
4915 if (attack_mode == ATTACK_MODE_COMBI)
4916 {
4917 fclose (device_param->combs_fp);
4918 }
4919
4920 free (wl_data->buf);
4921 free (wl_data);
4922
4923 fclose (fd);
4924 }
4925
4926 device_param->kernel_accel = 0;
4927 device_param->kernel_loops = 0;
4928
4929 return NULL;
4930 }
4931
4932 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4933 {
4934 if (!device_param)
4935 {
4936 log_error ("ERROR: %s : Invalid argument", __func__);
4937
4938 exit (-1);
4939 }
4940
4941 salt_t *salt_buf = &data.salts_buf[salt_pos];
4942
4943 device_param->kernel_params_buf32[24] = salt_pos;
4944 device_param->kernel_params_buf32[27] = 1;
4945 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4946 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4947 device_param->kernel_params_buf32[30] = 0;
4948 device_param->kernel_params_buf32[31] = 1;
4949
4950 char *dictfile_old = data.dictfile;
4951
4952 const char *weak_hash_check = "weak-hash-check";
4953
4954 data.dictfile = (char *) weak_hash_check;
4955
4956 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4957
4958 data.kernel_rules_buf[0].cmds[0] = 0;
4959
4960 /**
4961 * run the kernel
4962 */
4963
4964 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4965 {
4966 run_kernel (KERN_RUN_1, device_param, 1, false);
4967 }
4968 else
4969 {
4970 run_kernel (KERN_RUN_1, device_param, 1, false);
4971
4972 uint loop_step = 16;
4973
4974 const uint iter = salt_buf->salt_iter;
4975
4976 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4977 {
4978 uint loop_left = iter - loop_pos;
4979
4980 loop_left = MIN (loop_left, loop_step);
4981
4982 device_param->kernel_params_buf32[25] = loop_pos;
4983 device_param->kernel_params_buf32[26] = loop_left;
4984
4985 run_kernel (KERN_RUN_2, device_param, 1, false);
4986 }
4987
4988 run_kernel (KERN_RUN_3, device_param, 1, false);
4989 }
4990
4991 /**
4992 * result
4993 */
4994
4995 check_cracked (device_param, salt_pos);
4996
4997 /**
4998 * cleanup
4999 */
5000
5001 device_param->kernel_params_buf32[24] = 0;
5002 device_param->kernel_params_buf32[25] = 0;
5003 device_param->kernel_params_buf32[26] = 0;
5004 device_param->kernel_params_buf32[27] = 0;
5005 device_param->kernel_params_buf32[28] = 0;
5006 device_param->kernel_params_buf32[29] = 0;
5007 device_param->kernel_params_buf32[30] = 0;
5008 device_param->kernel_params_buf32[31] = 0;
5009
5010 data.dictfile = dictfile_old;
5011
5012 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5013 }
5014
5015 // hlfmt hashcat
5016
5017 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5018 {
5019 if (data.username == 0)
5020 {
5021 *hashbuf_pos = line_buf;
5022 *hashbuf_len = line_len;
5023 }
5024 else
5025 {
5026 char *pos = line_buf;
5027 int len = line_len;
5028
5029 for (int i = 0; i < line_len; i++, pos++, len--)
5030 {
5031 if (line_buf[i] == data.separator)
5032 {
5033 pos++;
5034
5035 len--;
5036
5037 break;
5038 }
5039 }
5040
5041 *hashbuf_pos = pos;
5042 *hashbuf_len = len;
5043 }
5044 }
5045
5046 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5047 {
5048 char *pos = NULL;
5049 int len = 0;
5050
5051 int sep_cnt = 0;
5052
5053 for (int i = 0; i < line_len; i++)
5054 {
5055 if (line_buf[i] == data.separator)
5056 {
5057 sep_cnt++;
5058
5059 continue;
5060 }
5061
5062 if (sep_cnt == 0)
5063 {
5064 if (pos == NULL) pos = line_buf + i;
5065
5066 len++;
5067 }
5068 }
5069
5070 *userbuf_pos = pos;
5071 *userbuf_len = len;
5072 }
5073
5074 // hlfmt pwdump
5075
5076 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5077 {
5078 int sep_cnt = 0;
5079
5080 int sep2_len = 0;
5081 int sep3_len = 0;
5082
5083 for (int i = 0; i < line_len; i++)
5084 {
5085 if (line_buf[i] == ':')
5086 {
5087 sep_cnt++;
5088
5089 continue;
5090 }
5091
5092 if (sep_cnt == 2) sep2_len++;
5093 if (sep_cnt == 3) sep3_len++;
5094 }
5095
5096 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5097
5098 return 0;
5099 }
5100
5101 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5102 {
5103 char *pos = NULL;
5104 int len = 0;
5105
5106 int sep_cnt = 0;
5107
5108 for (int i = 0; i < line_len; i++)
5109 {
5110 if (line_buf[i] == ':')
5111 {
5112 sep_cnt++;
5113
5114 continue;
5115 }
5116
5117 if (data.hash_mode == 1000)
5118 {
5119 if (sep_cnt == 3)
5120 {
5121 if (pos == NULL) pos = line_buf + i;
5122
5123 len++;
5124 }
5125 }
5126 else if (data.hash_mode == 3000)
5127 {
5128 if (sep_cnt == 2)
5129 {
5130 if (pos == NULL) pos = line_buf + i;
5131
5132 len++;
5133 }
5134 }
5135 }
5136
5137 *hashbuf_pos = pos;
5138 *hashbuf_len = len;
5139 }
5140
5141 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5142 {
5143 char *pos = NULL;
5144 int len = 0;
5145
5146 int sep_cnt = 0;
5147
5148 for (int i = 0; i < line_len; i++)
5149 {
5150 if (line_buf[i] == ':')
5151 {
5152 sep_cnt++;
5153
5154 continue;
5155 }
5156
5157 if (sep_cnt == 0)
5158 {
5159 if (pos == NULL) pos = line_buf + i;
5160
5161 len++;
5162 }
5163 }
5164
5165 *userbuf_pos = pos;
5166 *userbuf_len = len;
5167 }
5168
5169 // hlfmt passwd
5170
5171 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5172 {
5173 int sep_cnt = 0;
5174
5175 char sep5_first = 0;
5176 char sep6_first = 0;
5177
5178 for (int i = 0; i < line_len; i++)
5179 {
5180 if (line_buf[i] == ':')
5181 {
5182 sep_cnt++;
5183
5184 continue;
5185 }
5186
5187 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5188 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5189 }
5190
5191 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5192
5193 return 0;
5194 }
5195
5196 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5197 {
5198 char *pos = NULL;
5199 int len = 0;
5200
5201 int sep_cnt = 0;
5202
5203 for (int i = 0; i < line_len; i++)
5204 {
5205 if (line_buf[i] == ':')
5206 {
5207 sep_cnt++;
5208
5209 continue;
5210 }
5211
5212 if (sep_cnt == 1)
5213 {
5214 if (pos == NULL) pos = line_buf + i;
5215
5216 len++;
5217 }
5218 }
5219
5220 *hashbuf_pos = pos;
5221 *hashbuf_len = len;
5222 }
5223
5224 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5225 {
5226 char *pos = NULL;
5227 int len = 0;
5228
5229 int sep_cnt = 0;
5230
5231 for (int i = 0; i < line_len; i++)
5232 {
5233 if (line_buf[i] == ':')
5234 {
5235 sep_cnt++;
5236
5237 continue;
5238 }
5239
5240 if (sep_cnt == 0)
5241 {
5242 if (pos == NULL) pos = line_buf + i;
5243
5244 len++;
5245 }
5246 }
5247
5248 *userbuf_pos = pos;
5249 *userbuf_len = len;
5250 }
5251
5252 // hlfmt shadow
5253
5254 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5255 {
5256 int sep_cnt = 0;
5257
5258 for (int i = 0; i < line_len; i++)
5259 {
5260 if (line_buf[i] == ':') sep_cnt++;
5261 }
5262
5263 if (sep_cnt == 8) return 1;
5264
5265 return 0;
5266 }
5267
5268 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5269 {
5270 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5271 }
5272
5273 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5274 {
5275 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5276 }
5277
5278 // hlfmt main
5279
5280 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5281 {
5282 switch (hashfile_format)
5283 {
5284 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5285 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5286 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5287 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5288 }
5289 }
5290
5291 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5292 {
5293 switch (hashfile_format)
5294 {
5295 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5296 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5297 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5298 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5299 }
5300 }
5301
5302 char *strhlfmt (const uint hashfile_format)
5303 {
5304 switch (hashfile_format)
5305 {
5306 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5307 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5308 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5309 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5310 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5311 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5312 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5313 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5314 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5315 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5316 }
5317
5318 return ((char *) "Unknown");
5319 }
5320
5321 static uint hlfmt_detect (FILE *fp, uint max_check)
5322 {
5323 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5324
5325 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5326 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5327
5328 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5329
5330 uint num_check = 0;
5331
5332 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5333
5334 while (!feof (fp))
5335 {
5336 int line_len = fgetl (fp, line_buf);
5337
5338 if (line_len == 0) continue;
5339
5340 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5341 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5342 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5343
5344 if (num_check == max_check) break;
5345
5346 num_check++;
5347 }
5348
5349 myfree (line_buf);
5350
5351 uint hashlist_format = HLFMT_HASHCAT;
5352
5353 for (int i = 1; i < HLFMTS_CNT; i++)
5354 {
5355 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5356
5357 hashlist_format = i;
5358 }
5359
5360 free (formats_cnt);
5361
5362 return hashlist_format;
5363 }
5364
5365 /**
5366 * some further helper function
5367 */
5368
5369 // wrapper around mymalloc for ADL
5370
5371 #if defined(HAVE_HWMON)
5372 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5373 {
5374 return mymalloc (iSize);
5375 }
5376 #endif
5377
5378 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const u64 collisions_max)
5379 {
5380 u64 collisions = 0;
5381
5382 const uint dgst_pos0 = data.dgst_pos0;
5383 const uint dgst_pos1 = data.dgst_pos1;
5384 const uint dgst_pos2 = data.dgst_pos2;
5385 const uint dgst_pos3 = data.dgst_pos3;
5386
5387 memset (bitmap_a, 0, bitmap_size);
5388 memset (bitmap_b, 0, bitmap_size);
5389 memset (bitmap_c, 0, bitmap_size);
5390 memset (bitmap_d, 0, bitmap_size);
5391
5392 for (uint i = 0; i < digests_cnt; i++)
5393 {
5394 uint *digest_ptr = (uint *) digests_buf_ptr;
5395
5396 digests_buf_ptr += dgst_size;
5397
5398 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5399 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5400 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5401 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5402
5403 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5404 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5405 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5406 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5407
5408 if (bitmap_a[idx0] & val0) collisions++;
5409 if (bitmap_b[idx1] & val1) collisions++;
5410 if (bitmap_c[idx2] & val2) collisions++;
5411 if (bitmap_d[idx3] & val3) collisions++;
5412
5413 bitmap_a[idx0] |= val0;
5414 bitmap_b[idx1] |= val1;
5415 bitmap_c[idx2] |= val2;
5416 bitmap_d[idx3] |= val3;
5417
5418 if (collisions >= collisions_max) return 0x7fffffff;
5419 }
5420
5421 return collisions;
5422 }
5423
5424 /**
5425 * main
5426 */
5427
5428 #ifdef _WIN
5429 void SetConsoleWindowSize (const int x)
5430 {
5431 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5432
5433 if (h == INVALID_HANDLE_VALUE) return;
5434
5435 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5436
5437 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5438
5439 SMALL_RECT *sr = &bufferInfo.srWindow;
5440
5441 sr->Right = MAX (sr->Right, x - 1);
5442
5443 COORD co;
5444
5445 co.X = sr->Right + 1;
5446 co.Y = 9999;
5447
5448 if (!SetConsoleScreenBufferSize (h, co)) return;
5449
5450 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5451 }
5452 #endif
5453
5454 #ifdef _POSIX
5455 int (*clock_gettime_orig) (clockid_t clk_id, struct timespec *tp);
5456
5457 int clock_gettime (clockid_t clk_id, struct timespec *tp)
5458 {
5459 int r = clock_gettime_orig (clk_id, tp);
5460
5461 usleep (NVIDIA_100PERCENTCPU_WORKAROUND);
5462
5463 return r;
5464 }
5465 #endif
5466
5467 int main (int argc, char **argv)
5468 {
5469 #ifdef _POSIX
5470 clock_gettime_orig = dlsym (RTLD_NEXT, "clock_gettime");
5471 #endif
5472
5473 #ifdef _WIN
5474 SetConsoleWindowSize (132);
5475 #endif
5476
5477 /**
5478 * To help users a bit
5479 */
5480
5481 char *compute = getenv ("COMPUTE");
5482
5483 if (compute)
5484 {
5485 static char display[100];
5486
5487 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5488
5489 putenv (display);
5490 }
5491 else
5492 {
5493 if (getenv ("DISPLAY") == NULL)
5494 putenv ((char *) "DISPLAY=:0");
5495 }
5496
5497 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5498 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5499
5500 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5501 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5502
5503 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5504 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5505
5506 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5507 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5508
5509 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5510 putenv ((char *) "POCL_KERNEL_CACHE=0");
5511
5512 umask (077);
5513
5514 /**
5515 * Real init
5516 */
5517
5518 memset (&data, 0, sizeof (hc_global_data_t));
5519
5520 time_t proc_start;
5521
5522 time (&proc_start);
5523
5524 data.proc_start = proc_start;
5525
5526 int myargc = argc;
5527 char **myargv = argv;
5528
5529 hc_thread_mutex_init (mux_dispatcher);
5530 hc_thread_mutex_init (mux_counter);
5531 hc_thread_mutex_init (mux_display);
5532 hc_thread_mutex_init (mux_adl);
5533
5534 /**
5535 * commandline parameters
5536 */
5537
5538 uint usage = USAGE;
5539 uint version = VERSION;
5540 uint quiet = QUIET;
5541 uint benchmark = BENCHMARK;
5542 uint show = SHOW;
5543 uint left = LEFT;
5544 uint username = USERNAME;
5545 uint remove = REMOVE;
5546 uint remove_timer = REMOVE_TIMER;
5547 u64 skip = SKIP;
5548 u64 limit = LIMIT;
5549 uint keyspace = KEYSPACE;
5550 uint potfile_disable = POTFILE_DISABLE;
5551 char *potfile_path = NULL;
5552 uint debug_mode = DEBUG_MODE;
5553 char *debug_file = NULL;
5554 char *induction_dir = NULL;
5555 char *outfile_check_dir = NULL;
5556 uint force = FORCE;
5557 uint runtime = RUNTIME;
5558 uint hash_mode = HASH_MODE;
5559 uint attack_mode = ATTACK_MODE;
5560 uint markov_disable = MARKOV_DISABLE;
5561 uint markov_classic = MARKOV_CLASSIC;
5562 uint markov_threshold = MARKOV_THRESHOLD;
5563 char *markov_hcstat = NULL;
5564 char *outfile = NULL;
5565 uint outfile_format = OUTFILE_FORMAT;
5566 uint outfile_autohex = OUTFILE_AUTOHEX;
5567 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5568 uint restore = RESTORE;
5569 uint restore_timer = RESTORE_TIMER;
5570 uint restore_disable = RESTORE_DISABLE;
5571 uint status = STATUS;
5572 uint status_timer = STATUS_TIMER;
5573 uint machine_readable = MACHINE_READABLE;
5574 uint loopback = LOOPBACK;
5575 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5576 char *session = NULL;
5577 uint hex_charset = HEX_CHARSET;
5578 uint hex_salt = HEX_SALT;
5579 uint hex_wordlist = HEX_WORDLIST;
5580 uint rp_gen = RP_GEN;
5581 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5582 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5583 uint rp_gen_seed = RP_GEN_SEED;
5584 char *rule_buf_l = (char *) RULE_BUF_L;
5585 char *rule_buf_r = (char *) RULE_BUF_R;
5586 uint increment = INCREMENT;
5587 uint increment_min = INCREMENT_MIN;
5588 uint increment_max = INCREMENT_MAX;
5589 char *cpu_affinity = NULL;
5590 OCL_PTR *ocl = NULL;
5591 char *opencl_devices = NULL;
5592 char *opencl_platforms = NULL;
5593 char *opencl_device_types = NULL;
5594 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5595 char *truecrypt_keyfiles = NULL;
5596 char *veracrypt_keyfiles = NULL;
5597 uint veracrypt_pim = 0;
5598 uint workload_profile = WORKLOAD_PROFILE;
5599 uint kernel_accel = KERNEL_ACCEL;
5600 uint kernel_loops = KERNEL_LOOPS;
5601 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5602 #ifdef HAVE_HWMON
5603 uint gpu_temp_abort = GPU_TEMP_ABORT;
5604 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5605 uint powertune_enable = POWERTUNE_ENABLE;
5606 #endif
5607 uint logfile_disable = LOGFILE_DISABLE;
5608 uint segment_size = SEGMENT_SIZE;
5609 uint scrypt_tmto = SCRYPT_TMTO;
5610 char separator = SEPARATOR;
5611 uint bitmap_min = BITMAP_MIN;
5612 uint bitmap_max = BITMAP_MAX;
5613 char *custom_charset_1 = NULL;
5614 char *custom_charset_2 = NULL;
5615 char *custom_charset_3 = NULL;
5616 char *custom_charset_4 = NULL;
5617
5618 #define IDX_HELP 'h'
5619 #define IDX_VERSION 'V'
5620 #define IDX_VERSION_LOWER 'v'
5621 #define IDX_QUIET 0xff02
5622 #define IDX_SHOW 0xff03
5623 #define IDX_LEFT 0xff04
5624 #define IDX_REMOVE 0xff05
5625 #define IDX_REMOVE_TIMER 0xff37
5626 #define IDX_SKIP 's'
5627 #define IDX_LIMIT 'l'
5628 #define IDX_KEYSPACE 0xff35
5629 #define IDX_POTFILE_DISABLE 0xff06
5630 #define IDX_POTFILE_PATH 0xffe0
5631 #define IDX_DEBUG_MODE 0xff43
5632 #define IDX_DEBUG_FILE 0xff44
5633 #define IDX_INDUCTION_DIR 0xff46
5634 #define IDX_OUTFILE_CHECK_DIR 0xff47
5635 #define IDX_USERNAME 0xff07
5636 #define IDX_FORCE 0xff08
5637 #define IDX_RUNTIME 0xff09
5638 #define IDX_BENCHMARK 'b'
5639 #define IDX_HASH_MODE 'm'
5640 #define IDX_ATTACK_MODE 'a'
5641 #define IDX_RP_FILE 'r'
5642 #define IDX_RP_GEN 'g'
5643 #define IDX_RP_GEN_FUNC_MIN 0xff10
5644 #define IDX_RP_GEN_FUNC_MAX 0xff11
5645 #define IDX_RP_GEN_SEED 0xff34
5646 #define IDX_RULE_BUF_L 'j'
5647 #define IDX_RULE_BUF_R 'k'
5648 #define IDX_INCREMENT 'i'
5649 #define IDX_INCREMENT_MIN 0xff12
5650 #define IDX_INCREMENT_MAX 0xff13
5651 #define IDX_OUTFILE 'o'
5652 #define IDX_OUTFILE_FORMAT 0xff14
5653 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5654 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5655 #define IDX_RESTORE 0xff15
5656 #define IDX_RESTORE_DISABLE 0xff27
5657 #define IDX_STATUS 0xff17
5658 #define IDX_STATUS_TIMER 0xff18
5659 #define IDX_MACHINE_READABLE 0xff50
5660 #define IDX_LOOPBACK 0xff38
5661 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5662 #define IDX_SESSION 0xff19
5663 #define IDX_HEX_CHARSET 0xff20
5664 #define IDX_HEX_SALT 0xff21
5665 #define IDX_HEX_WORDLIST 0xff40
5666 #define IDX_MARKOV_DISABLE 0xff22
5667 #define IDX_MARKOV_CLASSIC 0xff23
5668 #define IDX_MARKOV_THRESHOLD 't'
5669 #define IDX_MARKOV_HCSTAT 0xff24
5670 #define IDX_CPU_AFFINITY 0xff25
5671 #define IDX_OPENCL_DEVICES 'd'
5672 #define IDX_OPENCL_PLATFORMS 0xff72
5673 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5674 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5675 #define IDX_WORKLOAD_PROFILE 'w'
5676 #define IDX_KERNEL_ACCEL 'n'
5677 #define IDX_KERNEL_LOOPS 'u'
5678 #define IDX_GPU_TEMP_DISABLE 0xff29
5679 #define IDX_GPU_TEMP_ABORT 0xff30
5680 #define IDX_GPU_TEMP_RETAIN 0xff31
5681 #define IDX_POWERTUNE_ENABLE 0xff41
5682 #define IDX_LOGFILE_DISABLE 0xff51
5683 #define IDX_TRUECRYPT_KEYFILES 0xff52
5684 #define IDX_VERACRYPT_KEYFILES 0xff53
5685 #define IDX_VERACRYPT_PIM 0xff54
5686 #define IDX_SCRYPT_TMTO 0xff61
5687 #define IDX_SEGMENT_SIZE 'c'
5688 #define IDX_SEPARATOR 'p'
5689 #define IDX_BITMAP_MIN 0xff70
5690 #define IDX_BITMAP_MAX 0xff71
5691 #define IDX_CUSTOM_CHARSET_1 '1'
5692 #define IDX_CUSTOM_CHARSET_2 '2'
5693 #define IDX_CUSTOM_CHARSET_3 '3'
5694 #define IDX_CUSTOM_CHARSET_4 '4'
5695
5696 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5697
5698 struct option long_options[] =
5699 {
5700 {"help", no_argument, 0, IDX_HELP},
5701 {"version", no_argument, 0, IDX_VERSION},
5702 {"quiet", no_argument, 0, IDX_QUIET},
5703 {"show", no_argument, 0, IDX_SHOW},
5704 {"left", no_argument, 0, IDX_LEFT},
5705 {"username", no_argument, 0, IDX_USERNAME},
5706 {"remove", no_argument, 0, IDX_REMOVE},
5707 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5708 {"skip", required_argument, 0, IDX_SKIP},
5709 {"limit", required_argument, 0, IDX_LIMIT},
5710 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5711 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5712 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5713 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5714 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5715 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5716 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5717 {"force", no_argument, 0, IDX_FORCE},
5718 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5719 {"restore", no_argument, 0, IDX_RESTORE},
5720 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5721 {"status", no_argument, 0, IDX_STATUS},
5722 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5723 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5724 {"loopback", no_argument, 0, IDX_LOOPBACK},
5725 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5726 {"session", required_argument, 0, IDX_SESSION},
5727 {"runtime", required_argument, 0, IDX_RUNTIME},
5728 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5729 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5730 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5731 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5732 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5733 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5734 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5735 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5736 {"rules-file", required_argument, 0, IDX_RP_FILE},
5737 {"outfile", required_argument, 0, IDX_OUTFILE},
5738 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5739 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5740 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5741 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5742 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5743 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5744 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5745 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5746 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5747 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5748 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5749 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5750 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5751 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5752 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5753 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5754 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5755 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5756 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5757 #ifdef HAVE_HWMON
5758 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5759 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5760 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5761 #endif // HAVE_HWMON
5762 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5763 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5764 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5765 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5766 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5767 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5768 {"seperator", required_argument, 0, IDX_SEPARATOR},
5769 {"separator", required_argument, 0, IDX_SEPARATOR},
5770 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5771 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5772 {"increment", no_argument, 0, IDX_INCREMENT},
5773 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5774 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5775 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5776 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5777 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5778 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5779 {0, 0, 0, 0}
5780 };
5781
5782 uint rp_files_cnt = 0;
5783
5784 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5785
5786 int option_index = 0;
5787 int c = -1;
5788
5789 optind = 1;
5790 optopt = 0;
5791
5792 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5793 {
5794 switch (c)
5795 {
5796 case IDX_HELP: usage = 1; break;
5797 case IDX_VERSION:
5798 case IDX_VERSION_LOWER: version = 1; break;
5799 case IDX_RESTORE: restore = 1; break;
5800 case IDX_SESSION: session = optarg; break;
5801 case IDX_SHOW: show = 1; break;
5802 case IDX_LEFT: left = 1; break;
5803 case '?': return (-1);
5804 }
5805 }
5806
5807 if (optopt != 0)
5808 {
5809 log_error ("ERROR: Invalid argument specified");
5810
5811 return (-1);
5812 }
5813
5814 /**
5815 * exit functions
5816 */
5817
5818 if (version)
5819 {
5820 log_info ("%s", VERSION_TAG);
5821
5822 return (0);
5823 }
5824
5825 if (usage)
5826 {
5827 usage_big_print (PROGNAME);
5828
5829 return (0);
5830 }
5831
5832 /**
5833 * session needs to be set, always!
5834 */
5835
5836 if (session == NULL) session = (char *) PROGNAME;
5837
5838 /**
5839 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5840 */
5841
5842 char *exec_path = get_exec_path ();
5843
5844 #ifdef LINUX
5845
5846 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5847 char *resolved_exec_path = realpath (exec_path, NULL);
5848
5849 char *install_dir = get_install_dir (resolved_exec_path);
5850 char *profile_dir = NULL;
5851 char *session_dir = NULL;
5852 char *shared_dir = NULL;
5853
5854 if (strcmp (install_dir, resolved_install_folder) == 0)
5855 {
5856 struct passwd *pw = getpwuid (getuid ());
5857
5858 const char *homedir = pw->pw_dir;
5859
5860 profile_dir = get_profile_dir (homedir);
5861 session_dir = get_session_dir (profile_dir);
5862 shared_dir = strdup (SHARED_FOLDER);
5863
5864 mkdir (profile_dir, 0700);
5865 mkdir (session_dir, 0700);
5866 }
5867 else
5868 {
5869 profile_dir = install_dir;
5870 session_dir = install_dir;
5871 shared_dir = install_dir;
5872 }
5873
5874 myfree (resolved_install_folder);
5875 myfree (resolved_exec_path);
5876
5877 #else
5878
5879 char *install_dir = get_install_dir (exec_path);
5880 char *profile_dir = install_dir;
5881 char *session_dir = install_dir;
5882 char *shared_dir = install_dir;
5883
5884 #endif
5885
5886 data.install_dir = install_dir;
5887 data.profile_dir = profile_dir;
5888 data.session_dir = session_dir;
5889 data.shared_dir = shared_dir;
5890
5891 myfree (exec_path);
5892
5893 /**
5894 * kernel cache, we need to make sure folder exist
5895 */
5896
5897 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5898
5899 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5900
5901 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5902
5903 mkdir (kernels_folder, 0700);
5904
5905 myfree (kernels_folder);
5906
5907 /**
5908 * session
5909 */
5910
5911 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5912
5913 data.session = session;
5914
5915 char *eff_restore_file = (char *) mymalloc (session_size);
5916 char *new_restore_file = (char *) mymalloc (session_size);
5917
5918 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5919 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5920
5921 data.eff_restore_file = eff_restore_file;
5922 data.new_restore_file = new_restore_file;
5923
5924 if (((show == 1) || (left == 1)) && (restore == 1))
5925 {
5926 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5927 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5928
5929 return (-1);
5930 }
5931
5932 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5933 if ((show == 1) || (left == 1))
5934 {
5935 restore_disable = 1;
5936
5937 restore = 0;
5938 }
5939
5940 data.restore_disable = restore_disable;
5941
5942 restore_data_t *rd = init_restore (argc, argv);
5943
5944 data.rd = rd;
5945
5946 /**
5947 * restore file
5948 */
5949
5950 if (restore == 1)
5951 {
5952 read_restore (eff_restore_file, rd);
5953
5954 if (rd->version_bin < RESTORE_MIN)
5955 {
5956 log_error ("ERROR: Incompatible restore-file version");
5957
5958 return (-1);
5959 }
5960
5961 myargc = rd->argc;
5962 myargv = rd->argv;
5963
5964 #ifdef _POSIX
5965 rd->pid = getpid ();
5966 #elif _WIN
5967 rd->pid = GetCurrentProcessId ();
5968 #endif
5969 }
5970
5971 uint hash_mode_chgd = 0;
5972 uint runtime_chgd = 0;
5973 uint kernel_loops_chgd = 0;
5974 uint kernel_accel_chgd = 0;
5975 uint attack_mode_chgd = 0;
5976 uint outfile_format_chgd = 0;
5977 uint rp_gen_seed_chgd = 0;
5978 uint remove_timer_chgd = 0;
5979 uint increment_min_chgd = 0;
5980 uint increment_max_chgd = 0;
5981 uint workload_profile_chgd = 0;
5982 uint opencl_vector_width_chgd = 0;
5983
5984 optind = 1;
5985 optopt = 0;
5986 option_index = 0;
5987
5988 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5989 {
5990 switch (c)
5991 {
5992 //case IDX_HELP: usage = 1; break;
5993 //case IDX_VERSION: version = 1; break;
5994 //case IDX_RESTORE: restore = 1; break;
5995 case IDX_QUIET: quiet = 1; break;
5996 //case IDX_SHOW: show = 1; break;
5997 case IDX_SHOW: break;
5998 //case IDX_LEFT: left = 1; break;
5999 case IDX_LEFT: break;
6000 case IDX_USERNAME: username = 1; break;
6001 case IDX_REMOVE: remove = 1; break;
6002 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6003 remove_timer_chgd = 1; break;
6004 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6005 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6006 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6007 case IDX_DEBUG_FILE: debug_file = optarg; break;
6008 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6009 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6010 case IDX_FORCE: force = 1; break;
6011 case IDX_SKIP: skip = atoll (optarg); break;
6012 case IDX_LIMIT: limit = atoll (optarg); break;
6013 case IDX_KEYSPACE: keyspace = 1; break;
6014 case IDX_BENCHMARK: benchmark = 1; break;
6015 case IDX_RESTORE: break;
6016 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6017 case IDX_STATUS: status = 1; break;
6018 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6019 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6020 case IDX_LOOPBACK: loopback = 1; break;
6021 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6022 //case IDX_SESSION: session = optarg; break;
6023 case IDX_SESSION: break;
6024 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6025 hash_mode_chgd = 1; break;
6026 case IDX_RUNTIME: runtime = atoi (optarg);
6027 runtime_chgd = 1; break;
6028 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6029 attack_mode_chgd = 1; break;
6030 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6031 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6032 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6033 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6034 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6035 rp_gen_seed_chgd = 1; break;
6036 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6037 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6038 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6039 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6040 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6041 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6042 case IDX_OUTFILE: outfile = optarg; break;
6043 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6044 outfile_format_chgd = 1; break;
6045 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6046 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6047 case IDX_HEX_CHARSET: hex_charset = 1; break;
6048 case IDX_HEX_SALT: hex_salt = 1; break;
6049 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6050 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6051 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6052 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6053 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6054 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6055 opencl_vector_width_chgd = 1; break;
6056 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6057 workload_profile_chgd = 1; break;
6058 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6059 kernel_accel_chgd = 1; break;
6060 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6061 kernel_loops_chgd = 1; break;
6062 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6063 #ifdef HAVE_HWMON
6064 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6065 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6066 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6067 #endif // HAVE_HWMON
6068 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6069 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6070 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6071 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6072 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6073 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6074 case IDX_SEPARATOR: separator = optarg[0]; break;
6075 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6076 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6077 case IDX_INCREMENT: increment = 1; break;
6078 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6079 increment_min_chgd = 1; break;
6080 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6081 increment_max_chgd = 1; break;
6082 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6083 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6084 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6085 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6086
6087 default:
6088 log_error ("ERROR: Invalid argument specified");
6089 return (-1);
6090 }
6091 }
6092
6093 if (optopt != 0)
6094 {
6095 log_error ("ERROR: Invalid argument specified");
6096
6097 return (-1);
6098 }
6099
6100 /**
6101 * Inform user things getting started,
6102 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6103 * - we do not need to check algorithm_pos
6104 */
6105
6106 if (quiet == 0)
6107 {
6108 if (benchmark == 1)
6109 {
6110 if (machine_readable == 0)
6111 {
6112 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6113 log_info ("");
6114 }
6115 else
6116 {
6117 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6118 }
6119 }
6120 else if (restore == 1)
6121 {
6122 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6123 log_info ("");
6124 }
6125 else
6126 {
6127 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6128 log_info ("");
6129 }
6130 }
6131
6132 /**
6133 * sanity check
6134 */
6135
6136 if (attack_mode > 7)
6137 {
6138 log_error ("ERROR: Invalid attack-mode specified");
6139
6140 return (-1);
6141 }
6142
6143 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6144 {
6145 log_error ("ERROR: Invalid runtime specified");
6146
6147 return (-1);
6148 }
6149
6150 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6151 {
6152 log_error ("ERROR: Invalid hash-type specified");
6153
6154 return (-1);
6155 }
6156
6157 // renamed hash modes
6158
6159 if (hash_mode_chgd)
6160 {
6161 int n = -1;
6162
6163 switch (hash_mode)
6164 {
6165 case 123: n = 124;
6166 break;
6167 }
6168
6169 if (n >= 0)
6170 {
6171 log_error ("Old -m specified, use -m %d instead", n);
6172
6173 return (-1);
6174 }
6175 }
6176
6177 if (username == 1)
6178 {
6179 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6180 {
6181 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6182
6183 return (-1);
6184 }
6185 }
6186
6187 if (outfile_format > 16)
6188 {
6189 log_error ("ERROR: Invalid outfile-format specified");
6190
6191 return (-1);
6192 }
6193
6194 if (left == 1)
6195 {
6196 if (outfile_format_chgd == 1)
6197 {
6198 if (outfile_format > 1)
6199 {
6200 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6201
6202 return (-1);
6203 }
6204 }
6205 else
6206 {
6207 outfile_format = OUTFILE_FMT_HASH;
6208 }
6209 }
6210
6211 if (show == 1)
6212 {
6213 if (outfile_format_chgd == 1)
6214 {
6215 if ((outfile_format > 7) && (outfile_format < 16))
6216 {
6217 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6218
6219 return (-1);
6220 }
6221 }
6222 }
6223
6224 if (increment_min < INCREMENT_MIN)
6225 {
6226 log_error ("ERROR: Invalid increment-min specified");
6227
6228 return (-1);
6229 }
6230
6231 if (increment_max > INCREMENT_MAX)
6232 {
6233 log_error ("ERROR: Invalid increment-max specified");
6234
6235 return (-1);
6236 }
6237
6238 if (increment_min > increment_max)
6239 {
6240 log_error ("ERROR: Invalid increment-min specified");
6241
6242 return (-1);
6243 }
6244
6245 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6246 {
6247 log_error ("ERROR: increment is not allowed in attack-mode 0");
6248
6249 return (-1);
6250 }
6251
6252 if ((increment == 0) && (increment_min_chgd == 1))
6253 {
6254 log_error ("ERROR: increment-min is only supported together with increment switch");
6255
6256 return (-1);
6257 }
6258
6259 if ((increment == 0) && (increment_max_chgd == 1))
6260 {
6261 log_error ("ERROR: increment-max is only supported together with increment switch");
6262
6263 return (-1);
6264 }
6265
6266 if (rp_files_cnt && rp_gen)
6267 {
6268 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6269
6270 return (-1);
6271 }
6272
6273 if (rp_files_cnt || rp_gen)
6274 {
6275 if (attack_mode != ATTACK_MODE_STRAIGHT)
6276 {
6277 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6278
6279 return (-1);
6280 }
6281 }
6282
6283 if (rp_gen_func_min > rp_gen_func_max)
6284 {
6285 log_error ("ERROR: Invalid rp-gen-func-min specified");
6286
6287 return (-1);
6288 }
6289
6290 if (kernel_accel_chgd == 1)
6291 {
6292 if (force == 0)
6293 {
6294 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6295 log_info ("Please consider using the option -w instead");
6296 log_info ("You can use --force to override this but do not post error reports if you do so");
6297 log_info ("");
6298
6299 return (-1);
6300 }
6301
6302 if (kernel_accel < 1)
6303 {
6304 log_error ("ERROR: Invalid kernel-accel specified");
6305
6306 return (-1);
6307 }
6308
6309 if (kernel_accel > 1024)
6310 {
6311 log_error ("ERROR: Invalid kernel-accel specified");
6312
6313 return (-1);
6314 }
6315 }
6316
6317 if (kernel_loops_chgd == 1)
6318 {
6319 if (force == 0)
6320 {
6321 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6322 log_info ("Please consider using the option -w instead");
6323 log_info ("You can use --force to override this but do not post error reports if you do so");
6324 log_info ("");
6325
6326 return (-1);
6327 }
6328
6329 if (kernel_loops < 1)
6330 {
6331 log_error ("ERROR: Invalid kernel-loops specified");
6332
6333 return (-1);
6334 }
6335
6336 if (kernel_loops > 1024)
6337 {
6338 log_error ("ERROR: Invalid kernel-loops specified");
6339
6340 return (-1);
6341 }
6342 }
6343
6344 if ((workload_profile < 1) || (workload_profile > 4))
6345 {
6346 log_error ("ERROR: workload-profile %i not available", workload_profile);
6347
6348 return (-1);
6349 }
6350
6351 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6352 {
6353 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6354
6355 return (-1);
6356 }
6357
6358 if (show == 1 || left == 1)
6359 {
6360 attack_mode = ATTACK_MODE_NONE;
6361
6362 if (remove == 1)
6363 {
6364 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6365
6366 return (-1);
6367 }
6368
6369 if (potfile_disable == 1)
6370 {
6371 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6372
6373 return (-1);
6374 }
6375 }
6376
6377 uint attack_kern = ATTACK_KERN_NONE;
6378
6379 switch (attack_mode)
6380 {
6381 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6382 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6383 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6384 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6385 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6386 }
6387
6388 if (benchmark == 0)
6389 {
6390 if (keyspace == 1)
6391 {
6392 int num_additional_params = 1;
6393
6394 if (attack_kern == ATTACK_KERN_COMBI)
6395 {
6396 num_additional_params = 2;
6397 }
6398
6399 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6400
6401 if (keyspace_wordlist_specified == 0) optind--;
6402 }
6403
6404 if (attack_kern == ATTACK_KERN_NONE)
6405 {
6406 if ((optind + 1) != myargc)
6407 {
6408 usage_mini_print (myargv[0]);
6409
6410 return (-1);
6411 }
6412 }
6413 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6414 {
6415 if ((optind + 1) > myargc)
6416 {
6417 usage_mini_print (myargv[0]);
6418
6419 return (-1);
6420 }
6421 }
6422 else if (attack_kern == ATTACK_KERN_COMBI)
6423 {
6424 if ((optind + 3) != myargc)
6425 {
6426 usage_mini_print (myargv[0]);
6427
6428 return (-1);
6429 }
6430 }
6431 else if (attack_kern == ATTACK_KERN_BF)
6432 {
6433 if ((optind + 1) > myargc)
6434 {
6435 usage_mini_print (myargv[0]);
6436
6437 return (-1);
6438 }
6439 }
6440 else
6441 {
6442 usage_mini_print (myargv[0]);
6443
6444 return (-1);
6445 }
6446 }
6447 else
6448 {
6449 if (myargv[optind] != 0)
6450 {
6451 log_error ("ERROR: Invalid argument for benchmark mode specified");
6452
6453 return (-1);
6454 }
6455
6456 if (attack_mode_chgd == 1)
6457 {
6458 if (attack_mode != ATTACK_MODE_BF)
6459 {
6460 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6461
6462 return (-1);
6463 }
6464 }
6465 }
6466
6467 if (skip != 0 && limit != 0)
6468 {
6469 limit += skip;
6470 }
6471
6472 if (keyspace == 1)
6473 {
6474 if (show == 1)
6475 {
6476 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6477
6478 return (-1);
6479 }
6480 else if (left == 1)
6481 {
6482 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6483
6484 return (-1);
6485 }
6486
6487 potfile_disable = 1;
6488
6489 restore_disable = 1;
6490
6491 restore = 0;
6492
6493 weak_hash_threshold = 0;
6494
6495 quiet = 1;
6496 }
6497
6498 if (remove_timer_chgd == 1)
6499 {
6500 if (remove == 0)
6501 {
6502 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6503
6504 return (-1);
6505 }
6506
6507 if (remove_timer < 1)
6508 {
6509 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6510
6511 return (-1);
6512 }
6513 }
6514
6515 if (loopback == 1)
6516 {
6517 if (attack_mode == ATTACK_MODE_STRAIGHT)
6518 {
6519 if ((rp_files_cnt == 0) && (rp_gen == 0))
6520 {
6521 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6522
6523 return (-1);
6524 }
6525 }
6526 else
6527 {
6528 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6529
6530 return (-1);
6531 }
6532 }
6533
6534 if (debug_mode > 0)
6535 {
6536 if (attack_mode != ATTACK_MODE_STRAIGHT)
6537 {
6538 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6539
6540 return (-1);
6541 }
6542
6543 if ((rp_files_cnt == 0) && (rp_gen == 0))
6544 {
6545 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6546
6547 return (-1);
6548 }
6549 }
6550
6551 if (debug_mode > 4)
6552 {
6553 log_error ("ERROR: Invalid debug-mode specified");
6554
6555 return (-1);
6556 }
6557
6558 if (debug_file != NULL)
6559 {
6560 if (debug_mode < 1)
6561 {
6562 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6563
6564 return (-1);
6565 }
6566 }
6567
6568 if (induction_dir != NULL)
6569 {
6570 if (attack_mode == ATTACK_MODE_BF)
6571 {
6572 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6573
6574 return (-1);
6575 }
6576 }
6577
6578 if (attack_mode != ATTACK_MODE_STRAIGHT)
6579 {
6580 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6581 {
6582 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6583
6584 return (-1);
6585 }
6586
6587 weak_hash_threshold = 0;
6588 }
6589
6590 /**
6591 * induction directory
6592 */
6593
6594 char *induction_directory = NULL;
6595
6596 if (attack_mode != ATTACK_MODE_BF)
6597 {
6598 if (induction_dir == NULL)
6599 {
6600 induction_directory = (char *) mymalloc (session_size);
6601
6602 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6603
6604 // create induction folder if it does not already exist
6605
6606 if (keyspace == 0)
6607 {
6608 if (rmdir (induction_directory) == -1)
6609 {
6610 if (errno == ENOENT)
6611 {
6612 // good, we can ignore
6613 }
6614 else if (errno == ENOTEMPTY)
6615 {
6616 char *induction_directory_mv = (char *) mymalloc (session_size);
6617
6618 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6619
6620 if (rename (induction_directory, induction_directory_mv) != 0)
6621 {
6622 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6623
6624 return (-1);
6625 }
6626 }
6627 else
6628 {
6629 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6630
6631 return (-1);
6632 }
6633 }
6634
6635 if (mkdir (induction_directory, 0700) == -1)
6636 {
6637 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6638
6639 return (-1);
6640 }
6641 }
6642 }
6643 else
6644 {
6645 induction_directory = induction_dir;
6646 }
6647 }
6648
6649 data.induction_directory = induction_directory;
6650
6651 /**
6652 * loopback
6653 */
6654
6655 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6656
6657 char *loopback_file = (char *) mymalloc (loopback_size);
6658
6659 /**
6660 * tuning db
6661 */
6662
6663 char tuning_db_file[256] = { 0 };
6664
6665 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6666
6667 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6668
6669 /**
6670 * outfile-check directory
6671 */
6672
6673 char *outfile_check_directory = NULL;
6674
6675 if (outfile_check_dir == NULL)
6676 {
6677 outfile_check_directory = (char *) mymalloc (session_size);
6678
6679 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6680 }
6681 else
6682 {
6683 outfile_check_directory = outfile_check_dir;
6684 }
6685
6686 data.outfile_check_directory = outfile_check_directory;
6687
6688 if (keyspace == 0)
6689 {
6690 struct stat outfile_check_stat;
6691
6692 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6693 {
6694 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6695
6696 if (is_dir == 0)
6697 {
6698 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6699
6700 return (-1);
6701 }
6702 }
6703 else if (outfile_check_dir == NULL)
6704 {
6705 if (mkdir (outfile_check_directory, 0700) == -1)
6706 {
6707 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6708
6709 return (-1);
6710 }
6711 }
6712 }
6713
6714 /**
6715 * special other stuff
6716 */
6717
6718 if (hash_mode == 9710)
6719 {
6720 outfile_format = 5;
6721 outfile_format_chgd = 1;
6722 }
6723
6724 if (hash_mode == 9810)
6725 {
6726 outfile_format = 5;
6727 outfile_format_chgd = 1;
6728 }
6729
6730 if (hash_mode == 10410)
6731 {
6732 outfile_format = 5;
6733 outfile_format_chgd = 1;
6734 }
6735
6736 /**
6737 * store stuff
6738 */
6739
6740 data.hash_mode = hash_mode;
6741 data.restore = restore;
6742 data.restore_timer = restore_timer;
6743 data.restore_disable = restore_disable;
6744 data.status = status;
6745 data.status_timer = status_timer;
6746 data.machine_readable = machine_readable;
6747 data.loopback = loopback;
6748 data.runtime = runtime;
6749 data.remove = remove;
6750 data.remove_timer = remove_timer;
6751 data.debug_mode = debug_mode;
6752 data.debug_file = debug_file;
6753 data.username = username;
6754 data.quiet = quiet;
6755 data.outfile = outfile;
6756 data.outfile_format = outfile_format;
6757 data.outfile_autohex = outfile_autohex;
6758 data.hex_charset = hex_charset;
6759 data.hex_salt = hex_salt;
6760 data.hex_wordlist = hex_wordlist;
6761 data.separator = separator;
6762 data.rp_files = rp_files;
6763 data.rp_files_cnt = rp_files_cnt;
6764 data.rp_gen = rp_gen;
6765 data.rp_gen_seed = rp_gen_seed;
6766 data.force = force;
6767 data.benchmark = benchmark;
6768 data.skip = skip;
6769 data.limit = limit;
6770 #ifdef HAVE_HWMON
6771 data.powertune_enable = powertune_enable;
6772 #endif
6773 data.logfile_disable = logfile_disable;
6774 data.truecrypt_keyfiles = truecrypt_keyfiles;
6775 data.veracrypt_keyfiles = veracrypt_keyfiles;
6776 data.veracrypt_pim = veracrypt_pim;
6777 data.scrypt_tmto = scrypt_tmto;
6778 data.workload_profile = workload_profile;
6779
6780 /**
6781 * cpu affinity
6782 */
6783
6784 if (cpu_affinity)
6785 {
6786 set_cpu_affinity (cpu_affinity);
6787 }
6788
6789 if (rp_gen_seed_chgd == 0)
6790 {
6791 srand (proc_start);
6792 }
6793 else
6794 {
6795 srand (rp_gen_seed);
6796 }
6797
6798 /**
6799 * logfile init
6800 */
6801
6802 if (logfile_disable == 0)
6803 {
6804 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6805
6806 char *logfile = (char *) mymalloc (logfile_size);
6807
6808 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6809
6810 data.logfile = logfile;
6811
6812 char *topid = logfile_generate_topid ();
6813
6814 data.topid = topid;
6815 }
6816
6817 // logfile_append() checks for logfile_disable internally to make it easier from here
6818
6819 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6820 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6821 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6822 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6823 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6824 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6825 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6826 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6827 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6828 #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));
6829
6830 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6831 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6832 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6833 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6834 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6835 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6836 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6837 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6838
6839 logfile_top_msg ("START");
6840
6841 logfile_top_uint (attack_mode);
6842 logfile_top_uint (attack_kern);
6843 logfile_top_uint (benchmark);
6844 logfile_top_uint (bitmap_min);
6845 logfile_top_uint (bitmap_max);
6846 logfile_top_uint (debug_mode);
6847 logfile_top_uint (force);
6848 logfile_top_uint (kernel_accel);
6849 logfile_top_uint (kernel_loops);
6850 logfile_top_uint (gpu_temp_disable);
6851 #ifdef HAVE_HWMON
6852 logfile_top_uint (gpu_temp_abort);
6853 logfile_top_uint (gpu_temp_retain);
6854 #endif
6855 logfile_top_uint (hash_mode);
6856 logfile_top_uint (hex_charset);
6857 logfile_top_uint (hex_salt);
6858 logfile_top_uint (hex_wordlist);
6859 logfile_top_uint (increment);
6860 logfile_top_uint (increment_max);
6861 logfile_top_uint (increment_min);
6862 logfile_top_uint (keyspace);
6863 logfile_top_uint (left);
6864 logfile_top_uint (logfile_disable);
6865 logfile_top_uint (loopback);
6866 logfile_top_uint (markov_classic);
6867 logfile_top_uint (markov_disable);
6868 logfile_top_uint (markov_threshold);
6869 logfile_top_uint (outfile_autohex);
6870 logfile_top_uint (outfile_check_timer);
6871 logfile_top_uint (outfile_format);
6872 logfile_top_uint (potfile_disable);
6873 logfile_top_string (potfile_path);
6874 #if defined(HAVE_HWMON)
6875 logfile_top_uint (powertune_enable);
6876 #endif
6877 logfile_top_uint (scrypt_tmto);
6878 logfile_top_uint (quiet);
6879 logfile_top_uint (remove);
6880 logfile_top_uint (remove_timer);
6881 logfile_top_uint (restore);
6882 logfile_top_uint (restore_disable);
6883 logfile_top_uint (restore_timer);
6884 logfile_top_uint (rp_gen);
6885 logfile_top_uint (rp_gen_func_max);
6886 logfile_top_uint (rp_gen_func_min);
6887 logfile_top_uint (rp_gen_seed);
6888 logfile_top_uint (runtime);
6889 logfile_top_uint (segment_size);
6890 logfile_top_uint (show);
6891 logfile_top_uint (status);
6892 logfile_top_uint (machine_readable);
6893 logfile_top_uint (status_timer);
6894 logfile_top_uint (usage);
6895 logfile_top_uint (username);
6896 logfile_top_uint (version);
6897 logfile_top_uint (weak_hash_threshold);
6898 logfile_top_uint (workload_profile);
6899 logfile_top_uint64 (limit);
6900 logfile_top_uint64 (skip);
6901 logfile_top_char (separator);
6902 logfile_top_string (cpu_affinity);
6903 logfile_top_string (custom_charset_1);
6904 logfile_top_string (custom_charset_2);
6905 logfile_top_string (custom_charset_3);
6906 logfile_top_string (custom_charset_4);
6907 logfile_top_string (debug_file);
6908 logfile_top_string (opencl_devices);
6909 logfile_top_string (opencl_platforms);
6910 logfile_top_string (opencl_device_types);
6911 logfile_top_uint (opencl_vector_width);
6912 logfile_top_string (induction_dir);
6913 logfile_top_string (markov_hcstat);
6914 logfile_top_string (outfile);
6915 logfile_top_string (outfile_check_dir);
6916 logfile_top_string (rule_buf_l);
6917 logfile_top_string (rule_buf_r);
6918 logfile_top_string (session);
6919 logfile_top_string (truecrypt_keyfiles);
6920 logfile_top_string (veracrypt_keyfiles);
6921 logfile_top_uint (veracrypt_pim);
6922
6923 /**
6924 * Init OpenCL library loader
6925 */
6926
6927 if (keyspace == 0)
6928 {
6929 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6930
6931 ocl_init (ocl);
6932
6933 data.ocl = ocl;
6934 }
6935
6936 /**
6937 * OpenCL platform selection
6938 */
6939
6940 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6941
6942 /**
6943 * OpenCL device selection
6944 */
6945
6946 u32 devices_filter = setup_devices_filter (opencl_devices);
6947
6948 /**
6949 * OpenCL device type selection
6950 */
6951
6952 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6953
6954 /**
6955 * benchmark
6956 */
6957
6958 if (benchmark == 1)
6959 {
6960 /**
6961 * disable useless stuff for benchmark
6962 */
6963
6964 status_timer = 0;
6965 restore_timer = 0;
6966 restore_disable = 1;
6967 potfile_disable = 1;
6968 weak_hash_threshold = 0;
6969 gpu_temp_disable = 1;
6970
6971 #ifdef HAVE_HWMON
6972 gpu_temp_disable = 0;
6973 powertune_enable = 1;
6974 #endif
6975
6976 data.status_timer = status_timer;
6977 data.restore_timer = restore_timer;
6978 data.restore_disable = restore_disable;
6979
6980 /**
6981 * force attack mode to be bruteforce
6982 */
6983
6984 attack_mode = ATTACK_MODE_BF;
6985 attack_kern = ATTACK_KERN_BF;
6986
6987 if (workload_profile_chgd == 0)
6988 {
6989 workload_profile = 3;
6990
6991 data.workload_profile = workload_profile;
6992 }
6993 }
6994
6995 /**
6996 * config
6997 */
6998
6999 uint hash_type = 0;
7000 uint salt_type = 0;
7001 uint attack_exec = 0;
7002 uint opts_type = 0;
7003 uint kern_type = 0;
7004 uint dgst_size = 0;
7005 uint esalt_size = 0;
7006 uint opti_type = 0;
7007 uint dgst_pos0 = -1;
7008 uint dgst_pos1 = -1;
7009 uint dgst_pos2 = -1;
7010 uint dgst_pos3 = -1;
7011
7012 int (*parse_func) (char *, uint, hash_t *);
7013 int (*sort_by_digest) (const void *, const void *);
7014
7015 uint algorithm_pos = 0;
7016 uint algorithm_max = 1;
7017
7018 uint *algorithms = default_benchmark_algorithms;
7019
7020 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7021
7022 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7023 {
7024 /*
7025 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7026 * the following algos are skipped entirely
7027 */
7028
7029 if (algorithm_pos > 0)
7030 {
7031 local_free (rd);
7032
7033 rd = init_restore (argc, argv);
7034
7035 data.rd = rd;
7036 }
7037
7038 /**
7039 * update hash_mode in case of multihash benchmark
7040 */
7041
7042 if (benchmark == 1)
7043 {
7044 if (hash_mode_chgd == 0)
7045 {
7046 hash_mode = algorithms[algorithm_pos];
7047
7048 data.hash_mode = hash_mode;
7049 }
7050
7051 quiet = 1;
7052
7053 data.quiet = quiet;
7054 }
7055
7056 switch (hash_mode)
7057 {
7058 case 0: hash_type = HASH_TYPE_MD5;
7059 salt_type = SALT_TYPE_NONE;
7060 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7061 opts_type = OPTS_TYPE_PT_GENERATE_LE
7062 | OPTS_TYPE_PT_ADD80
7063 | OPTS_TYPE_PT_ADDBITS14;
7064 kern_type = KERN_TYPE_MD5;
7065 dgst_size = DGST_SIZE_4_4;
7066 parse_func = md5_parse_hash;
7067 sort_by_digest = sort_by_digest_4_4;
7068 opti_type = OPTI_TYPE_ZERO_BYTE
7069 | OPTI_TYPE_PRECOMPUTE_INIT
7070 | OPTI_TYPE_PRECOMPUTE_MERKLE
7071 | OPTI_TYPE_MEET_IN_MIDDLE
7072 | OPTI_TYPE_EARLY_SKIP
7073 | OPTI_TYPE_NOT_ITERATED
7074 | OPTI_TYPE_NOT_SALTED
7075 | OPTI_TYPE_RAW_HASH;
7076 dgst_pos0 = 0;
7077 dgst_pos1 = 3;
7078 dgst_pos2 = 2;
7079 dgst_pos3 = 1;
7080 break;
7081
7082 case 10: hash_type = HASH_TYPE_MD5;
7083 salt_type = SALT_TYPE_INTERN;
7084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7085 opts_type = OPTS_TYPE_PT_GENERATE_LE
7086 | OPTS_TYPE_ST_ADD80
7087 | OPTS_TYPE_ST_ADDBITS14;
7088 kern_type = KERN_TYPE_MD5_PWSLT;
7089 dgst_size = DGST_SIZE_4_4;
7090 parse_func = md5s_parse_hash;
7091 sort_by_digest = sort_by_digest_4_4;
7092 opti_type = OPTI_TYPE_ZERO_BYTE
7093 | OPTI_TYPE_PRECOMPUTE_INIT
7094 | OPTI_TYPE_PRECOMPUTE_MERKLE
7095 | OPTI_TYPE_MEET_IN_MIDDLE
7096 | OPTI_TYPE_EARLY_SKIP
7097 | OPTI_TYPE_NOT_ITERATED
7098 | OPTI_TYPE_APPENDED_SALT
7099 | OPTI_TYPE_RAW_HASH;
7100 dgst_pos0 = 0;
7101 dgst_pos1 = 3;
7102 dgst_pos2 = 2;
7103 dgst_pos3 = 1;
7104 break;
7105
7106 case 11: hash_type = HASH_TYPE_MD5;
7107 salt_type = SALT_TYPE_INTERN;
7108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7109 opts_type = OPTS_TYPE_PT_GENERATE_LE
7110 | OPTS_TYPE_ST_ADD80
7111 | OPTS_TYPE_ST_ADDBITS14;
7112 kern_type = KERN_TYPE_MD5_PWSLT;
7113 dgst_size = DGST_SIZE_4_4;
7114 parse_func = joomla_parse_hash;
7115 sort_by_digest = sort_by_digest_4_4;
7116 opti_type = OPTI_TYPE_ZERO_BYTE
7117 | OPTI_TYPE_PRECOMPUTE_INIT
7118 | OPTI_TYPE_PRECOMPUTE_MERKLE
7119 | OPTI_TYPE_MEET_IN_MIDDLE
7120 | OPTI_TYPE_EARLY_SKIP
7121 | OPTI_TYPE_NOT_ITERATED
7122 | OPTI_TYPE_APPENDED_SALT
7123 | OPTI_TYPE_RAW_HASH;
7124 dgst_pos0 = 0;
7125 dgst_pos1 = 3;
7126 dgst_pos2 = 2;
7127 dgst_pos3 = 1;
7128 break;
7129
7130 case 12: hash_type = HASH_TYPE_MD5;
7131 salt_type = SALT_TYPE_INTERN;
7132 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7133 opts_type = OPTS_TYPE_PT_GENERATE_LE
7134 | OPTS_TYPE_ST_ADD80
7135 | OPTS_TYPE_ST_ADDBITS14;
7136 kern_type = KERN_TYPE_MD5_PWSLT;
7137 dgst_size = DGST_SIZE_4_4;
7138 parse_func = postgresql_parse_hash;
7139 sort_by_digest = sort_by_digest_4_4;
7140 opti_type = OPTI_TYPE_ZERO_BYTE
7141 | OPTI_TYPE_PRECOMPUTE_INIT
7142 | OPTI_TYPE_PRECOMPUTE_MERKLE
7143 | OPTI_TYPE_MEET_IN_MIDDLE
7144 | OPTI_TYPE_EARLY_SKIP
7145 | OPTI_TYPE_NOT_ITERATED
7146 | OPTI_TYPE_APPENDED_SALT
7147 | OPTI_TYPE_RAW_HASH;
7148 dgst_pos0 = 0;
7149 dgst_pos1 = 3;
7150 dgst_pos2 = 2;
7151 dgst_pos3 = 1;
7152 break;
7153
7154 case 20: hash_type = HASH_TYPE_MD5;
7155 salt_type = SALT_TYPE_INTERN;
7156 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7157 opts_type = OPTS_TYPE_PT_GENERATE_LE
7158 | OPTS_TYPE_PT_ADD80
7159 | OPTS_TYPE_PT_ADDBITS14;
7160 kern_type = KERN_TYPE_MD5_SLTPW;
7161 dgst_size = DGST_SIZE_4_4;
7162 parse_func = md5s_parse_hash;
7163 sort_by_digest = sort_by_digest_4_4;
7164 opti_type = OPTI_TYPE_ZERO_BYTE
7165 | OPTI_TYPE_PRECOMPUTE_INIT
7166 | OPTI_TYPE_PRECOMPUTE_MERKLE
7167 | OPTI_TYPE_EARLY_SKIP
7168 | OPTI_TYPE_NOT_ITERATED
7169 | OPTI_TYPE_PREPENDED_SALT
7170 | OPTI_TYPE_RAW_HASH;
7171 dgst_pos0 = 0;
7172 dgst_pos1 = 3;
7173 dgst_pos2 = 2;
7174 dgst_pos3 = 1;
7175 break;
7176
7177 case 21: hash_type = HASH_TYPE_MD5;
7178 salt_type = SALT_TYPE_INTERN;
7179 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7180 opts_type = OPTS_TYPE_PT_GENERATE_LE
7181 | OPTS_TYPE_PT_ADD80
7182 | OPTS_TYPE_PT_ADDBITS14;
7183 kern_type = KERN_TYPE_MD5_SLTPW;
7184 dgst_size = DGST_SIZE_4_4;
7185 parse_func = osc_parse_hash;
7186 sort_by_digest = sort_by_digest_4_4;
7187 opti_type = OPTI_TYPE_ZERO_BYTE
7188 | OPTI_TYPE_PRECOMPUTE_INIT
7189 | OPTI_TYPE_PRECOMPUTE_MERKLE
7190 | OPTI_TYPE_EARLY_SKIP
7191 | OPTI_TYPE_NOT_ITERATED
7192 | OPTI_TYPE_PREPENDED_SALT
7193 | OPTI_TYPE_RAW_HASH;
7194 dgst_pos0 = 0;
7195 dgst_pos1 = 3;
7196 dgst_pos2 = 2;
7197 dgst_pos3 = 1;
7198 break;
7199
7200 case 22: hash_type = HASH_TYPE_MD5;
7201 salt_type = SALT_TYPE_EMBEDDED;
7202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7203 opts_type = OPTS_TYPE_PT_GENERATE_LE
7204 | OPTS_TYPE_PT_ADD80
7205 | OPTS_TYPE_PT_ADDBITS14;
7206 kern_type = KERN_TYPE_MD5_SLTPW;
7207 dgst_size = DGST_SIZE_4_4;
7208 parse_func = netscreen_parse_hash;
7209 sort_by_digest = sort_by_digest_4_4;
7210 opti_type = OPTI_TYPE_ZERO_BYTE
7211 | OPTI_TYPE_PRECOMPUTE_INIT
7212 | OPTI_TYPE_PRECOMPUTE_MERKLE
7213 | OPTI_TYPE_EARLY_SKIP
7214 | OPTI_TYPE_NOT_ITERATED
7215 | OPTI_TYPE_PREPENDED_SALT
7216 | OPTI_TYPE_RAW_HASH;
7217 dgst_pos0 = 0;
7218 dgst_pos1 = 3;
7219 dgst_pos2 = 2;
7220 dgst_pos3 = 1;
7221 break;
7222
7223 case 23: hash_type = HASH_TYPE_MD5;
7224 salt_type = SALT_TYPE_EMBEDDED;
7225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7226 opts_type = OPTS_TYPE_PT_GENERATE_LE
7227 | OPTS_TYPE_PT_ADD80
7228 | OPTS_TYPE_PT_ADDBITS14;
7229 kern_type = KERN_TYPE_MD5_SLTPW;
7230 dgst_size = DGST_SIZE_4_4;
7231 parse_func = skype_parse_hash;
7232 sort_by_digest = sort_by_digest_4_4;
7233 opti_type = OPTI_TYPE_ZERO_BYTE
7234 | OPTI_TYPE_PRECOMPUTE_INIT
7235 | OPTI_TYPE_PRECOMPUTE_MERKLE
7236 | OPTI_TYPE_EARLY_SKIP
7237 | OPTI_TYPE_NOT_ITERATED
7238 | OPTI_TYPE_PREPENDED_SALT
7239 | OPTI_TYPE_RAW_HASH;
7240 dgst_pos0 = 0;
7241 dgst_pos1 = 3;
7242 dgst_pos2 = 2;
7243 dgst_pos3 = 1;
7244 break;
7245
7246 case 30: hash_type = HASH_TYPE_MD5;
7247 salt_type = SALT_TYPE_INTERN;
7248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7249 opts_type = OPTS_TYPE_PT_GENERATE_LE
7250 | OPTS_TYPE_PT_UNICODE
7251 | OPTS_TYPE_ST_ADD80
7252 | OPTS_TYPE_ST_ADDBITS14;
7253 kern_type = KERN_TYPE_MD5_PWUSLT;
7254 dgst_size = DGST_SIZE_4_4;
7255 parse_func = md5s_parse_hash;
7256 sort_by_digest = sort_by_digest_4_4;
7257 opti_type = OPTI_TYPE_ZERO_BYTE
7258 | OPTI_TYPE_PRECOMPUTE_INIT
7259 | OPTI_TYPE_PRECOMPUTE_MERKLE
7260 | OPTI_TYPE_MEET_IN_MIDDLE
7261 | OPTI_TYPE_EARLY_SKIP
7262 | OPTI_TYPE_NOT_ITERATED
7263 | OPTI_TYPE_APPENDED_SALT
7264 | OPTI_TYPE_RAW_HASH;
7265 dgst_pos0 = 0;
7266 dgst_pos1 = 3;
7267 dgst_pos2 = 2;
7268 dgst_pos3 = 1;
7269 break;
7270
7271 case 40: hash_type = HASH_TYPE_MD5;
7272 salt_type = SALT_TYPE_INTERN;
7273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7274 opts_type = OPTS_TYPE_PT_GENERATE_LE
7275 | OPTS_TYPE_PT_ADD80
7276 | OPTS_TYPE_PT_ADDBITS14
7277 | OPTS_TYPE_PT_UNICODE;
7278 kern_type = KERN_TYPE_MD5_SLTPWU;
7279 dgst_size = DGST_SIZE_4_4;
7280 parse_func = md5s_parse_hash;
7281 sort_by_digest = sort_by_digest_4_4;
7282 opti_type = OPTI_TYPE_ZERO_BYTE
7283 | OPTI_TYPE_PRECOMPUTE_INIT
7284 | OPTI_TYPE_PRECOMPUTE_MERKLE
7285 | OPTI_TYPE_EARLY_SKIP
7286 | OPTI_TYPE_NOT_ITERATED
7287 | OPTI_TYPE_PREPENDED_SALT
7288 | OPTI_TYPE_RAW_HASH;
7289 dgst_pos0 = 0;
7290 dgst_pos1 = 3;
7291 dgst_pos2 = 2;
7292 dgst_pos3 = 1;
7293 break;
7294
7295 case 50: hash_type = HASH_TYPE_MD5;
7296 salt_type = SALT_TYPE_INTERN;
7297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7298 opts_type = OPTS_TYPE_PT_GENERATE_LE
7299 | OPTS_TYPE_ST_ADD80
7300 | OPTS_TYPE_ST_ADDBITS14;
7301 kern_type = KERN_TYPE_HMACMD5_PW;
7302 dgst_size = DGST_SIZE_4_4;
7303 parse_func = hmacmd5_parse_hash;
7304 sort_by_digest = sort_by_digest_4_4;
7305 opti_type = OPTI_TYPE_ZERO_BYTE
7306 | OPTI_TYPE_NOT_ITERATED;
7307 dgst_pos0 = 0;
7308 dgst_pos1 = 3;
7309 dgst_pos2 = 2;
7310 dgst_pos3 = 1;
7311 break;
7312
7313 case 60: hash_type = HASH_TYPE_MD5;
7314 salt_type = SALT_TYPE_INTERN;
7315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7316 opts_type = OPTS_TYPE_PT_GENERATE_LE
7317 | OPTS_TYPE_PT_ADD80
7318 | OPTS_TYPE_PT_ADDBITS14;
7319 kern_type = KERN_TYPE_HMACMD5_SLT;
7320 dgst_size = DGST_SIZE_4_4;
7321 parse_func = hmacmd5_parse_hash;
7322 sort_by_digest = sort_by_digest_4_4;
7323 opti_type = OPTI_TYPE_ZERO_BYTE
7324 | OPTI_TYPE_NOT_ITERATED;
7325 dgst_pos0 = 0;
7326 dgst_pos1 = 3;
7327 dgst_pos2 = 2;
7328 dgst_pos3 = 1;
7329 break;
7330
7331 case 100: hash_type = HASH_TYPE_SHA1;
7332 salt_type = SALT_TYPE_NONE;
7333 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7334 opts_type = OPTS_TYPE_PT_GENERATE_BE
7335 | OPTS_TYPE_PT_ADD80
7336 | OPTS_TYPE_PT_ADDBITS15;
7337 kern_type = KERN_TYPE_SHA1;
7338 dgst_size = DGST_SIZE_4_5;
7339 parse_func = sha1_parse_hash;
7340 sort_by_digest = sort_by_digest_4_5;
7341 opti_type = OPTI_TYPE_ZERO_BYTE
7342 | OPTI_TYPE_PRECOMPUTE_INIT
7343 | OPTI_TYPE_PRECOMPUTE_MERKLE
7344 | OPTI_TYPE_EARLY_SKIP
7345 | OPTI_TYPE_NOT_ITERATED
7346 | OPTI_TYPE_NOT_SALTED
7347 | OPTI_TYPE_RAW_HASH;
7348 dgst_pos0 = 3;
7349 dgst_pos1 = 4;
7350 dgst_pos2 = 2;
7351 dgst_pos3 = 1;
7352 break;
7353
7354 case 101: hash_type = HASH_TYPE_SHA1;
7355 salt_type = SALT_TYPE_NONE;
7356 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7357 opts_type = OPTS_TYPE_PT_GENERATE_BE
7358 | OPTS_TYPE_PT_ADD80
7359 | OPTS_TYPE_PT_ADDBITS15;
7360 kern_type = KERN_TYPE_SHA1;
7361 dgst_size = DGST_SIZE_4_5;
7362 parse_func = sha1b64_parse_hash;
7363 sort_by_digest = sort_by_digest_4_5;
7364 opti_type = OPTI_TYPE_ZERO_BYTE
7365 | OPTI_TYPE_PRECOMPUTE_INIT
7366 | OPTI_TYPE_PRECOMPUTE_MERKLE
7367 | OPTI_TYPE_EARLY_SKIP
7368 | OPTI_TYPE_NOT_ITERATED
7369 | OPTI_TYPE_NOT_SALTED
7370 | OPTI_TYPE_RAW_HASH;
7371 dgst_pos0 = 3;
7372 dgst_pos1 = 4;
7373 dgst_pos2 = 2;
7374 dgst_pos3 = 1;
7375 break;
7376
7377 case 110: hash_type = HASH_TYPE_SHA1;
7378 salt_type = SALT_TYPE_INTERN;
7379 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7380 opts_type = OPTS_TYPE_PT_GENERATE_BE
7381 | OPTS_TYPE_ST_ADD80
7382 | OPTS_TYPE_ST_ADDBITS15;
7383 kern_type = KERN_TYPE_SHA1_PWSLT;
7384 dgst_size = DGST_SIZE_4_5;
7385 parse_func = sha1s_parse_hash;
7386 sort_by_digest = sort_by_digest_4_5;
7387 opti_type = OPTI_TYPE_ZERO_BYTE
7388 | OPTI_TYPE_PRECOMPUTE_INIT
7389 | OPTI_TYPE_PRECOMPUTE_MERKLE
7390 | OPTI_TYPE_EARLY_SKIP
7391 | OPTI_TYPE_NOT_ITERATED
7392 | OPTI_TYPE_APPENDED_SALT
7393 | OPTI_TYPE_RAW_HASH;
7394 dgst_pos0 = 3;
7395 dgst_pos1 = 4;
7396 dgst_pos2 = 2;
7397 dgst_pos3 = 1;
7398 break;
7399
7400 case 111: hash_type = HASH_TYPE_SHA1;
7401 salt_type = SALT_TYPE_EMBEDDED;
7402 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7403 opts_type = OPTS_TYPE_PT_GENERATE_BE
7404 | OPTS_TYPE_ST_ADD80
7405 | OPTS_TYPE_ST_ADDBITS15;
7406 kern_type = KERN_TYPE_SHA1_PWSLT;
7407 dgst_size = DGST_SIZE_4_5;
7408 parse_func = sha1b64s_parse_hash;
7409 sort_by_digest = sort_by_digest_4_5;
7410 opti_type = OPTI_TYPE_ZERO_BYTE
7411 | OPTI_TYPE_PRECOMPUTE_INIT
7412 | OPTI_TYPE_PRECOMPUTE_MERKLE
7413 | OPTI_TYPE_EARLY_SKIP
7414 | OPTI_TYPE_NOT_ITERATED
7415 | OPTI_TYPE_APPENDED_SALT
7416 | OPTI_TYPE_RAW_HASH;
7417 dgst_pos0 = 3;
7418 dgst_pos1 = 4;
7419 dgst_pos2 = 2;
7420 dgst_pos3 = 1;
7421 break;
7422
7423 case 112: hash_type = HASH_TYPE_SHA1;
7424 salt_type = SALT_TYPE_INTERN;
7425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7426 opts_type = OPTS_TYPE_PT_GENERATE_BE
7427 | OPTS_TYPE_ST_ADD80
7428 | OPTS_TYPE_ST_ADDBITS15
7429 | OPTS_TYPE_ST_HEX;
7430 kern_type = KERN_TYPE_SHA1_PWSLT;
7431 dgst_size = DGST_SIZE_4_5;
7432 parse_func = oracles_parse_hash;
7433 sort_by_digest = sort_by_digest_4_5;
7434 opti_type = OPTI_TYPE_ZERO_BYTE
7435 | OPTI_TYPE_PRECOMPUTE_INIT
7436 | OPTI_TYPE_PRECOMPUTE_MERKLE
7437 | OPTI_TYPE_EARLY_SKIP
7438 | OPTI_TYPE_NOT_ITERATED
7439 | OPTI_TYPE_APPENDED_SALT
7440 | OPTI_TYPE_RAW_HASH;
7441 dgst_pos0 = 3;
7442 dgst_pos1 = 4;
7443 dgst_pos2 = 2;
7444 dgst_pos3 = 1;
7445 break;
7446
7447 case 120: hash_type = HASH_TYPE_SHA1;
7448 salt_type = SALT_TYPE_INTERN;
7449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7450 opts_type = OPTS_TYPE_PT_GENERATE_BE
7451 | OPTS_TYPE_PT_ADD80
7452 | OPTS_TYPE_PT_ADDBITS15;
7453 kern_type = KERN_TYPE_SHA1_SLTPW;
7454 dgst_size = DGST_SIZE_4_5;
7455 parse_func = sha1s_parse_hash;
7456 sort_by_digest = sort_by_digest_4_5;
7457 opti_type = OPTI_TYPE_ZERO_BYTE
7458 | OPTI_TYPE_PRECOMPUTE_INIT
7459 | OPTI_TYPE_PRECOMPUTE_MERKLE
7460 | OPTI_TYPE_EARLY_SKIP
7461 | OPTI_TYPE_NOT_ITERATED
7462 | OPTI_TYPE_PREPENDED_SALT
7463 | OPTI_TYPE_RAW_HASH;
7464 dgst_pos0 = 3;
7465 dgst_pos1 = 4;
7466 dgst_pos2 = 2;
7467 dgst_pos3 = 1;
7468 break;
7469
7470 case 121: hash_type = HASH_TYPE_SHA1;
7471 salt_type = SALT_TYPE_INTERN;
7472 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7473 opts_type = OPTS_TYPE_PT_GENERATE_BE
7474 | OPTS_TYPE_PT_ADD80
7475 | OPTS_TYPE_PT_ADDBITS15
7476 | OPTS_TYPE_ST_LOWER;
7477 kern_type = KERN_TYPE_SHA1_SLTPW;
7478 dgst_size = DGST_SIZE_4_5;
7479 parse_func = smf_parse_hash;
7480 sort_by_digest = sort_by_digest_4_5;
7481 opti_type = OPTI_TYPE_ZERO_BYTE
7482 | OPTI_TYPE_PRECOMPUTE_INIT
7483 | OPTI_TYPE_PRECOMPUTE_MERKLE
7484 | OPTI_TYPE_EARLY_SKIP
7485 | OPTI_TYPE_NOT_ITERATED
7486 | OPTI_TYPE_PREPENDED_SALT
7487 | OPTI_TYPE_RAW_HASH;
7488 dgst_pos0 = 3;
7489 dgst_pos1 = 4;
7490 dgst_pos2 = 2;
7491 dgst_pos3 = 1;
7492 break;
7493
7494 case 122: hash_type = HASH_TYPE_SHA1;
7495 salt_type = SALT_TYPE_EMBEDDED;
7496 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7497 opts_type = OPTS_TYPE_PT_GENERATE_BE
7498 | OPTS_TYPE_PT_ADD80
7499 | OPTS_TYPE_PT_ADDBITS15
7500 | OPTS_TYPE_ST_HEX;
7501 kern_type = KERN_TYPE_SHA1_SLTPW;
7502 dgst_size = DGST_SIZE_4_5;
7503 parse_func = osx1_parse_hash;
7504 sort_by_digest = sort_by_digest_4_5;
7505 opti_type = OPTI_TYPE_ZERO_BYTE
7506 | OPTI_TYPE_PRECOMPUTE_INIT
7507 | OPTI_TYPE_PRECOMPUTE_MERKLE
7508 | OPTI_TYPE_EARLY_SKIP
7509 | OPTI_TYPE_NOT_ITERATED
7510 | OPTI_TYPE_PREPENDED_SALT
7511 | OPTI_TYPE_RAW_HASH;
7512 dgst_pos0 = 3;
7513 dgst_pos1 = 4;
7514 dgst_pos2 = 2;
7515 dgst_pos3 = 1;
7516 break;
7517
7518 case 124: hash_type = HASH_TYPE_SHA1;
7519 salt_type = SALT_TYPE_EMBEDDED;
7520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7521 opts_type = OPTS_TYPE_PT_GENERATE_BE
7522 | OPTS_TYPE_PT_ADD80
7523 | OPTS_TYPE_PT_ADDBITS15;
7524 kern_type = KERN_TYPE_SHA1_SLTPW;
7525 dgst_size = DGST_SIZE_4_5;
7526 parse_func = djangosha1_parse_hash;
7527 sort_by_digest = sort_by_digest_4_5;
7528 opti_type = OPTI_TYPE_ZERO_BYTE
7529 | OPTI_TYPE_PRECOMPUTE_INIT
7530 | OPTI_TYPE_PRECOMPUTE_MERKLE
7531 | OPTI_TYPE_EARLY_SKIP
7532 | OPTI_TYPE_NOT_ITERATED
7533 | OPTI_TYPE_PREPENDED_SALT
7534 | OPTI_TYPE_RAW_HASH;
7535 dgst_pos0 = 3;
7536 dgst_pos1 = 4;
7537 dgst_pos2 = 2;
7538 dgst_pos3 = 1;
7539 break;
7540
7541 case 125: hash_type = HASH_TYPE_SHA1;
7542 salt_type = SALT_TYPE_EMBEDDED;
7543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7544 opts_type = OPTS_TYPE_PT_GENERATE_BE
7545 | OPTS_TYPE_PT_ADD80
7546 | OPTS_TYPE_PT_ADDBITS15
7547 | OPTS_TYPE_ST_HEX;
7548 kern_type = KERN_TYPE_SHA1_SLTPW;
7549 dgst_size = DGST_SIZE_4_5;
7550 parse_func = arubaos_parse_hash;
7551 sort_by_digest = sort_by_digest_4_5;
7552 opti_type = OPTI_TYPE_ZERO_BYTE
7553 | OPTI_TYPE_PRECOMPUTE_INIT
7554 | OPTI_TYPE_PRECOMPUTE_MERKLE
7555 | OPTI_TYPE_EARLY_SKIP
7556 | OPTI_TYPE_NOT_ITERATED
7557 | OPTI_TYPE_PREPENDED_SALT
7558 | OPTI_TYPE_RAW_HASH;
7559 dgst_pos0 = 3;
7560 dgst_pos1 = 4;
7561 dgst_pos2 = 2;
7562 dgst_pos3 = 1;
7563 break;
7564
7565 case 130: hash_type = HASH_TYPE_SHA1;
7566 salt_type = SALT_TYPE_INTERN;
7567 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7568 opts_type = OPTS_TYPE_PT_GENERATE_BE
7569 | OPTS_TYPE_PT_UNICODE
7570 | OPTS_TYPE_ST_ADD80
7571 | OPTS_TYPE_ST_ADDBITS15;
7572 kern_type = KERN_TYPE_SHA1_PWUSLT;
7573 dgst_size = DGST_SIZE_4_5;
7574 parse_func = sha1s_parse_hash;
7575 sort_by_digest = sort_by_digest_4_5;
7576 opti_type = OPTI_TYPE_ZERO_BYTE
7577 | OPTI_TYPE_PRECOMPUTE_INIT
7578 | OPTI_TYPE_PRECOMPUTE_MERKLE
7579 | OPTI_TYPE_EARLY_SKIP
7580 | OPTI_TYPE_NOT_ITERATED
7581 | OPTI_TYPE_APPENDED_SALT
7582 | OPTI_TYPE_RAW_HASH;
7583 dgst_pos0 = 3;
7584 dgst_pos1 = 4;
7585 dgst_pos2 = 2;
7586 dgst_pos3 = 1;
7587 break;
7588
7589 case 131: hash_type = HASH_TYPE_SHA1;
7590 salt_type = SALT_TYPE_EMBEDDED;
7591 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7592 opts_type = OPTS_TYPE_PT_GENERATE_BE
7593 | OPTS_TYPE_PT_UNICODE
7594 | OPTS_TYPE_PT_UPPER
7595 | OPTS_TYPE_ST_ADD80
7596 | OPTS_TYPE_ST_ADDBITS15
7597 | OPTS_TYPE_ST_HEX;
7598 kern_type = KERN_TYPE_SHA1_PWUSLT;
7599 dgst_size = DGST_SIZE_4_5;
7600 parse_func = mssql2000_parse_hash;
7601 sort_by_digest = sort_by_digest_4_5;
7602 opti_type = OPTI_TYPE_ZERO_BYTE
7603 | OPTI_TYPE_PRECOMPUTE_INIT
7604 | OPTI_TYPE_PRECOMPUTE_MERKLE
7605 | OPTI_TYPE_EARLY_SKIP
7606 | OPTI_TYPE_NOT_ITERATED
7607 | OPTI_TYPE_APPENDED_SALT
7608 | OPTI_TYPE_RAW_HASH;
7609 dgst_pos0 = 3;
7610 dgst_pos1 = 4;
7611 dgst_pos2 = 2;
7612 dgst_pos3 = 1;
7613 break;
7614
7615 case 132: hash_type = HASH_TYPE_SHA1;
7616 salt_type = SALT_TYPE_EMBEDDED;
7617 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7618 opts_type = OPTS_TYPE_PT_GENERATE_BE
7619 | OPTS_TYPE_PT_UNICODE
7620 | OPTS_TYPE_ST_ADD80
7621 | OPTS_TYPE_ST_ADDBITS15
7622 | OPTS_TYPE_ST_HEX;
7623 kern_type = KERN_TYPE_SHA1_PWUSLT;
7624 dgst_size = DGST_SIZE_4_5;
7625 parse_func = mssql2005_parse_hash;
7626 sort_by_digest = sort_by_digest_4_5;
7627 opti_type = OPTI_TYPE_ZERO_BYTE
7628 | OPTI_TYPE_PRECOMPUTE_INIT
7629 | OPTI_TYPE_PRECOMPUTE_MERKLE
7630 | OPTI_TYPE_EARLY_SKIP
7631 | OPTI_TYPE_NOT_ITERATED
7632 | OPTI_TYPE_APPENDED_SALT
7633 | OPTI_TYPE_RAW_HASH;
7634 dgst_pos0 = 3;
7635 dgst_pos1 = 4;
7636 dgst_pos2 = 2;
7637 dgst_pos3 = 1;
7638 break;
7639
7640 case 133: hash_type = HASH_TYPE_SHA1;
7641 salt_type = SALT_TYPE_EMBEDDED;
7642 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7643 opts_type = OPTS_TYPE_PT_GENERATE_BE
7644 | OPTS_TYPE_PT_UNICODE
7645 | OPTS_TYPE_ST_ADD80
7646 | OPTS_TYPE_ST_ADDBITS15;
7647 kern_type = KERN_TYPE_SHA1_PWUSLT;
7648 dgst_size = DGST_SIZE_4_5;
7649 parse_func = peoplesoft_parse_hash;
7650 sort_by_digest = sort_by_digest_4_5;
7651 opti_type = OPTI_TYPE_ZERO_BYTE
7652 | OPTI_TYPE_PRECOMPUTE_INIT
7653 | OPTI_TYPE_PRECOMPUTE_MERKLE
7654 | OPTI_TYPE_EARLY_SKIP
7655 | OPTI_TYPE_NOT_ITERATED
7656 | OPTI_TYPE_APPENDED_SALT
7657 | OPTI_TYPE_RAW_HASH;
7658 dgst_pos0 = 3;
7659 dgst_pos1 = 4;
7660 dgst_pos2 = 2;
7661 dgst_pos3 = 1;
7662 break;
7663
7664 case 140: hash_type = HASH_TYPE_SHA1;
7665 salt_type = SALT_TYPE_INTERN;
7666 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7667 opts_type = OPTS_TYPE_PT_GENERATE_BE
7668 | OPTS_TYPE_PT_ADD80
7669 | OPTS_TYPE_PT_ADDBITS15
7670 | OPTS_TYPE_PT_UNICODE;
7671 kern_type = KERN_TYPE_SHA1_SLTPWU;
7672 dgst_size = DGST_SIZE_4_5;
7673 parse_func = sha1s_parse_hash;
7674 sort_by_digest = sort_by_digest_4_5;
7675 opti_type = OPTI_TYPE_ZERO_BYTE
7676 | OPTI_TYPE_PRECOMPUTE_INIT
7677 | OPTI_TYPE_PRECOMPUTE_MERKLE
7678 | OPTI_TYPE_EARLY_SKIP
7679 | OPTI_TYPE_NOT_ITERATED
7680 | OPTI_TYPE_PREPENDED_SALT
7681 | OPTI_TYPE_RAW_HASH;
7682 dgst_pos0 = 3;
7683 dgst_pos1 = 4;
7684 dgst_pos2 = 2;
7685 dgst_pos3 = 1;
7686 break;
7687
7688 case 141: hash_type = HASH_TYPE_SHA1;
7689 salt_type = SALT_TYPE_EMBEDDED;
7690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7691 opts_type = OPTS_TYPE_PT_GENERATE_BE
7692 | OPTS_TYPE_PT_ADD80
7693 | OPTS_TYPE_PT_ADDBITS15
7694 | OPTS_TYPE_PT_UNICODE
7695 | OPTS_TYPE_ST_BASE64;
7696 kern_type = KERN_TYPE_SHA1_SLTPWU;
7697 dgst_size = DGST_SIZE_4_5;
7698 parse_func = episerver_parse_hash;
7699 sort_by_digest = sort_by_digest_4_5;
7700 opti_type = OPTI_TYPE_ZERO_BYTE
7701 | OPTI_TYPE_PRECOMPUTE_INIT
7702 | OPTI_TYPE_PRECOMPUTE_MERKLE
7703 | OPTI_TYPE_EARLY_SKIP
7704 | OPTI_TYPE_NOT_ITERATED
7705 | OPTI_TYPE_PREPENDED_SALT
7706 | OPTI_TYPE_RAW_HASH;
7707 dgst_pos0 = 3;
7708 dgst_pos1 = 4;
7709 dgst_pos2 = 2;
7710 dgst_pos3 = 1;
7711 break;
7712
7713 case 150: hash_type = HASH_TYPE_SHA1;
7714 salt_type = SALT_TYPE_INTERN;
7715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7716 opts_type = OPTS_TYPE_PT_GENERATE_BE
7717 | OPTS_TYPE_ST_ADD80
7718 | OPTS_TYPE_ST_ADDBITS15;
7719 kern_type = KERN_TYPE_HMACSHA1_PW;
7720 dgst_size = DGST_SIZE_4_5;
7721 parse_func = hmacsha1_parse_hash;
7722 sort_by_digest = sort_by_digest_4_5;
7723 opti_type = OPTI_TYPE_ZERO_BYTE
7724 | OPTI_TYPE_NOT_ITERATED;
7725 dgst_pos0 = 3;
7726 dgst_pos1 = 4;
7727 dgst_pos2 = 2;
7728 dgst_pos3 = 1;
7729 break;
7730
7731 case 160: hash_type = HASH_TYPE_SHA1;
7732 salt_type = SALT_TYPE_INTERN;
7733 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7734 opts_type = OPTS_TYPE_PT_GENERATE_BE
7735 | OPTS_TYPE_PT_ADD80
7736 | OPTS_TYPE_PT_ADDBITS15;
7737 kern_type = KERN_TYPE_HMACSHA1_SLT;
7738 dgst_size = DGST_SIZE_4_5;
7739 parse_func = hmacsha1_parse_hash;
7740 sort_by_digest = sort_by_digest_4_5;
7741 opti_type = OPTI_TYPE_ZERO_BYTE
7742 | OPTI_TYPE_NOT_ITERATED;
7743 dgst_pos0 = 3;
7744 dgst_pos1 = 4;
7745 dgst_pos2 = 2;
7746 dgst_pos3 = 1;
7747 break;
7748
7749 case 190: hash_type = HASH_TYPE_SHA1;
7750 salt_type = SALT_TYPE_NONE;
7751 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7752 opts_type = OPTS_TYPE_PT_GENERATE_BE
7753 | OPTS_TYPE_PT_ADD80
7754 | OPTS_TYPE_PT_ADDBITS15;
7755 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7756 dgst_size = DGST_SIZE_4_5;
7757 parse_func = sha1linkedin_parse_hash;
7758 sort_by_digest = sort_by_digest_4_5;
7759 opti_type = OPTI_TYPE_ZERO_BYTE
7760 | OPTI_TYPE_PRECOMPUTE_INIT
7761 | OPTI_TYPE_EARLY_SKIP
7762 | OPTI_TYPE_NOT_ITERATED
7763 | OPTI_TYPE_NOT_SALTED;
7764 dgst_pos0 = 0;
7765 dgst_pos1 = 4;
7766 dgst_pos2 = 3;
7767 dgst_pos3 = 2;
7768 break;
7769
7770 case 200: hash_type = HASH_TYPE_MYSQL;
7771 salt_type = SALT_TYPE_NONE;
7772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7773 opts_type = 0;
7774 kern_type = KERN_TYPE_MYSQL;
7775 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7776 parse_func = mysql323_parse_hash;
7777 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7778 opti_type = OPTI_TYPE_ZERO_BYTE;
7779 dgst_pos0 = 0;
7780 dgst_pos1 = 1;
7781 dgst_pos2 = 2;
7782 dgst_pos3 = 3;
7783 break;
7784
7785 case 300: hash_type = HASH_TYPE_SHA1;
7786 salt_type = SALT_TYPE_NONE;
7787 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7788 opts_type = OPTS_TYPE_PT_GENERATE_BE
7789 | OPTS_TYPE_PT_ADD80
7790 | OPTS_TYPE_PT_ADDBITS15;
7791 kern_type = KERN_TYPE_MYSQL41;
7792 dgst_size = DGST_SIZE_4_5;
7793 parse_func = sha1_parse_hash;
7794 sort_by_digest = sort_by_digest_4_5;
7795 opti_type = OPTI_TYPE_ZERO_BYTE
7796 | OPTI_TYPE_PRECOMPUTE_INIT
7797 | OPTI_TYPE_PRECOMPUTE_MERKLE
7798 | OPTI_TYPE_EARLY_SKIP
7799 | OPTI_TYPE_NOT_ITERATED
7800 | OPTI_TYPE_NOT_SALTED;
7801 dgst_pos0 = 3;
7802 dgst_pos1 = 4;
7803 dgst_pos2 = 2;
7804 dgst_pos3 = 1;
7805 break;
7806
7807 case 400: hash_type = HASH_TYPE_MD5;
7808 salt_type = SALT_TYPE_EMBEDDED;
7809 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7810 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7811 kern_type = KERN_TYPE_PHPASS;
7812 dgst_size = DGST_SIZE_4_4;
7813 parse_func = phpass_parse_hash;
7814 sort_by_digest = sort_by_digest_4_4;
7815 opti_type = OPTI_TYPE_ZERO_BYTE
7816 | OPTI_TYPE_SLOW_HASH_SIMD;
7817 dgst_pos0 = 0;
7818 dgst_pos1 = 1;
7819 dgst_pos2 = 2;
7820 dgst_pos3 = 3;
7821 break;
7822
7823 case 500: hash_type = HASH_TYPE_MD5;
7824 salt_type = SALT_TYPE_EMBEDDED;
7825 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7826 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7827 kern_type = KERN_TYPE_MD5CRYPT;
7828 dgst_size = DGST_SIZE_4_4;
7829 parse_func = md5crypt_parse_hash;
7830 sort_by_digest = sort_by_digest_4_4;
7831 opti_type = OPTI_TYPE_ZERO_BYTE;
7832 dgst_pos0 = 0;
7833 dgst_pos1 = 1;
7834 dgst_pos2 = 2;
7835 dgst_pos3 = 3;
7836 break;
7837
7838 case 501: hash_type = HASH_TYPE_MD5;
7839 salt_type = SALT_TYPE_EMBEDDED;
7840 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7841 opts_type = OPTS_TYPE_PT_GENERATE_LE
7842 | OPTS_TYPE_HASH_COPY;
7843 kern_type = KERN_TYPE_MD5CRYPT;
7844 dgst_size = DGST_SIZE_4_4;
7845 parse_func = juniper_parse_hash;
7846 sort_by_digest = sort_by_digest_4_4;
7847 opti_type = OPTI_TYPE_ZERO_BYTE;
7848 dgst_pos0 = 0;
7849 dgst_pos1 = 1;
7850 dgst_pos2 = 2;
7851 dgst_pos3 = 3;
7852 break;
7853
7854 case 900: hash_type = HASH_TYPE_MD4;
7855 salt_type = SALT_TYPE_NONE;
7856 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7857 opts_type = OPTS_TYPE_PT_GENERATE_LE
7858 | OPTS_TYPE_PT_ADD80
7859 | OPTS_TYPE_PT_ADDBITS14;
7860 kern_type = KERN_TYPE_MD4;
7861 dgst_size = DGST_SIZE_4_4;
7862 parse_func = md4_parse_hash;
7863 sort_by_digest = sort_by_digest_4_4;
7864 opti_type = OPTI_TYPE_ZERO_BYTE
7865 | OPTI_TYPE_PRECOMPUTE_INIT
7866 | OPTI_TYPE_PRECOMPUTE_MERKLE
7867 | OPTI_TYPE_MEET_IN_MIDDLE
7868 | OPTI_TYPE_EARLY_SKIP
7869 | OPTI_TYPE_NOT_ITERATED
7870 | OPTI_TYPE_NOT_SALTED
7871 | OPTI_TYPE_RAW_HASH;
7872 dgst_pos0 = 0;
7873 dgst_pos1 = 3;
7874 dgst_pos2 = 2;
7875 dgst_pos3 = 1;
7876 break;
7877
7878 case 1000: hash_type = HASH_TYPE_MD4;
7879 salt_type = SALT_TYPE_NONE;
7880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7881 opts_type = OPTS_TYPE_PT_GENERATE_LE
7882 | OPTS_TYPE_PT_ADD80
7883 | OPTS_TYPE_PT_ADDBITS14
7884 | OPTS_TYPE_PT_UNICODE;
7885 kern_type = KERN_TYPE_MD4_PWU;
7886 dgst_size = DGST_SIZE_4_4;
7887 parse_func = md4_parse_hash;
7888 sort_by_digest = sort_by_digest_4_4;
7889 opti_type = OPTI_TYPE_ZERO_BYTE
7890 | OPTI_TYPE_PRECOMPUTE_INIT
7891 | OPTI_TYPE_PRECOMPUTE_MERKLE
7892 | OPTI_TYPE_MEET_IN_MIDDLE
7893 | OPTI_TYPE_EARLY_SKIP
7894 | OPTI_TYPE_NOT_ITERATED
7895 | OPTI_TYPE_NOT_SALTED
7896 | OPTI_TYPE_RAW_HASH;
7897 dgst_pos0 = 0;
7898 dgst_pos1 = 3;
7899 dgst_pos2 = 2;
7900 dgst_pos3 = 1;
7901 break;
7902
7903 case 1100: hash_type = HASH_TYPE_MD4;
7904 salt_type = SALT_TYPE_INTERN;
7905 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7906 opts_type = OPTS_TYPE_PT_GENERATE_LE
7907 | OPTS_TYPE_PT_ADD80
7908 | OPTS_TYPE_PT_ADDBITS14
7909 | OPTS_TYPE_PT_UNICODE
7910 | OPTS_TYPE_ST_ADD80
7911 | OPTS_TYPE_ST_UNICODE
7912 | OPTS_TYPE_ST_LOWER;
7913 kern_type = KERN_TYPE_MD44_PWUSLT;
7914 dgst_size = DGST_SIZE_4_4;
7915 parse_func = dcc_parse_hash;
7916 sort_by_digest = sort_by_digest_4_4;
7917 opti_type = OPTI_TYPE_ZERO_BYTE
7918 | OPTI_TYPE_PRECOMPUTE_INIT
7919 | OPTI_TYPE_PRECOMPUTE_MERKLE
7920 | OPTI_TYPE_EARLY_SKIP
7921 | OPTI_TYPE_NOT_ITERATED;
7922 dgst_pos0 = 0;
7923 dgst_pos1 = 3;
7924 dgst_pos2 = 2;
7925 dgst_pos3 = 1;
7926 break;
7927
7928 case 1400: hash_type = HASH_TYPE_SHA256;
7929 salt_type = SALT_TYPE_NONE;
7930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7931 opts_type = OPTS_TYPE_PT_GENERATE_BE
7932 | OPTS_TYPE_PT_ADD80
7933 | OPTS_TYPE_PT_ADDBITS15;
7934 kern_type = KERN_TYPE_SHA256;
7935 dgst_size = DGST_SIZE_4_8;
7936 parse_func = sha256_parse_hash;
7937 sort_by_digest = sort_by_digest_4_8;
7938 opti_type = OPTI_TYPE_ZERO_BYTE
7939 | OPTI_TYPE_PRECOMPUTE_INIT
7940 | OPTI_TYPE_PRECOMPUTE_MERKLE
7941 | OPTI_TYPE_EARLY_SKIP
7942 | OPTI_TYPE_NOT_ITERATED
7943 | OPTI_TYPE_NOT_SALTED
7944 | OPTI_TYPE_RAW_HASH;
7945 dgst_pos0 = 3;
7946 dgst_pos1 = 7;
7947 dgst_pos2 = 2;
7948 dgst_pos3 = 6;
7949 break;
7950
7951 case 1410: hash_type = HASH_TYPE_SHA256;
7952 salt_type = SALT_TYPE_INTERN;
7953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7954 opts_type = OPTS_TYPE_PT_GENERATE_BE
7955 | OPTS_TYPE_ST_ADD80
7956 | OPTS_TYPE_ST_ADDBITS15;
7957 kern_type = KERN_TYPE_SHA256_PWSLT;
7958 dgst_size = DGST_SIZE_4_8;
7959 parse_func = sha256s_parse_hash;
7960 sort_by_digest = sort_by_digest_4_8;
7961 opti_type = OPTI_TYPE_ZERO_BYTE
7962 | OPTI_TYPE_PRECOMPUTE_INIT
7963 | OPTI_TYPE_PRECOMPUTE_MERKLE
7964 | OPTI_TYPE_EARLY_SKIP
7965 | OPTI_TYPE_NOT_ITERATED
7966 | OPTI_TYPE_APPENDED_SALT
7967 | OPTI_TYPE_RAW_HASH;
7968 dgst_pos0 = 3;
7969 dgst_pos1 = 7;
7970 dgst_pos2 = 2;
7971 dgst_pos3 = 6;
7972 break;
7973
7974 case 1420: hash_type = HASH_TYPE_SHA256;
7975 salt_type = SALT_TYPE_INTERN;
7976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7977 opts_type = OPTS_TYPE_PT_GENERATE_BE
7978 | OPTS_TYPE_PT_ADD80
7979 | OPTS_TYPE_PT_ADDBITS15;
7980 kern_type = KERN_TYPE_SHA256_SLTPW;
7981 dgst_size = DGST_SIZE_4_8;
7982 parse_func = sha256s_parse_hash;
7983 sort_by_digest = sort_by_digest_4_8;
7984 opti_type = OPTI_TYPE_ZERO_BYTE
7985 | OPTI_TYPE_PRECOMPUTE_INIT
7986 | OPTI_TYPE_PRECOMPUTE_MERKLE
7987 | OPTI_TYPE_EARLY_SKIP
7988 | OPTI_TYPE_NOT_ITERATED
7989 | OPTI_TYPE_PREPENDED_SALT
7990 | OPTI_TYPE_RAW_HASH;
7991 dgst_pos0 = 3;
7992 dgst_pos1 = 7;
7993 dgst_pos2 = 2;
7994 dgst_pos3 = 6;
7995 break;
7996
7997 case 1421: hash_type = HASH_TYPE_SHA256;
7998 salt_type = SALT_TYPE_EMBEDDED;
7999 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8000 opts_type = OPTS_TYPE_PT_GENERATE_BE
8001 | OPTS_TYPE_PT_ADD80
8002 | OPTS_TYPE_PT_ADDBITS15;
8003 kern_type = KERN_TYPE_SHA256_SLTPW;
8004 dgst_size = DGST_SIZE_4_8;
8005 parse_func = hmailserver_parse_hash;
8006 sort_by_digest = sort_by_digest_4_8;
8007 opti_type = OPTI_TYPE_ZERO_BYTE
8008 | OPTI_TYPE_PRECOMPUTE_INIT
8009 | OPTI_TYPE_PRECOMPUTE_MERKLE
8010 | OPTI_TYPE_EARLY_SKIP
8011 | OPTI_TYPE_NOT_ITERATED
8012 | OPTI_TYPE_PREPENDED_SALT
8013 | OPTI_TYPE_RAW_HASH;
8014 dgst_pos0 = 3;
8015 dgst_pos1 = 7;
8016 dgst_pos2 = 2;
8017 dgst_pos3 = 6;
8018 break;
8019
8020 case 1430: hash_type = HASH_TYPE_SHA256;
8021 salt_type = SALT_TYPE_INTERN;
8022 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8023 opts_type = OPTS_TYPE_PT_GENERATE_BE
8024 | OPTS_TYPE_PT_UNICODE
8025 | OPTS_TYPE_ST_ADD80
8026 | OPTS_TYPE_ST_ADDBITS15;
8027 kern_type = KERN_TYPE_SHA256_PWUSLT;
8028 dgst_size = DGST_SIZE_4_8;
8029 parse_func = sha256s_parse_hash;
8030 sort_by_digest = sort_by_digest_4_8;
8031 opti_type = OPTI_TYPE_ZERO_BYTE
8032 | OPTI_TYPE_PRECOMPUTE_INIT
8033 | OPTI_TYPE_PRECOMPUTE_MERKLE
8034 | OPTI_TYPE_EARLY_SKIP
8035 | OPTI_TYPE_NOT_ITERATED
8036 | OPTI_TYPE_APPENDED_SALT
8037 | OPTI_TYPE_RAW_HASH;
8038 dgst_pos0 = 3;
8039 dgst_pos1 = 7;
8040 dgst_pos2 = 2;
8041 dgst_pos3 = 6;
8042 break;
8043
8044 case 1440: hash_type = HASH_TYPE_SHA256;
8045 salt_type = SALT_TYPE_INTERN;
8046 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8047 opts_type = OPTS_TYPE_PT_GENERATE_BE
8048 | OPTS_TYPE_PT_ADD80
8049 | OPTS_TYPE_PT_ADDBITS15
8050 | OPTS_TYPE_PT_UNICODE;
8051 kern_type = KERN_TYPE_SHA256_SLTPWU;
8052 dgst_size = DGST_SIZE_4_8;
8053 parse_func = sha256s_parse_hash;
8054 sort_by_digest = sort_by_digest_4_8;
8055 opti_type = OPTI_TYPE_ZERO_BYTE
8056 | OPTI_TYPE_PRECOMPUTE_INIT
8057 | OPTI_TYPE_PRECOMPUTE_MERKLE
8058 | OPTI_TYPE_EARLY_SKIP
8059 | OPTI_TYPE_NOT_ITERATED
8060 | OPTI_TYPE_PREPENDED_SALT
8061 | OPTI_TYPE_RAW_HASH;
8062 dgst_pos0 = 3;
8063 dgst_pos1 = 7;
8064 dgst_pos2 = 2;
8065 dgst_pos3 = 6;
8066 break;
8067
8068 case 1441: hash_type = HASH_TYPE_SHA256;
8069 salt_type = SALT_TYPE_EMBEDDED;
8070 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8071 opts_type = OPTS_TYPE_PT_GENERATE_BE
8072 | OPTS_TYPE_PT_ADD80
8073 | OPTS_TYPE_PT_ADDBITS15
8074 | OPTS_TYPE_PT_UNICODE
8075 | OPTS_TYPE_ST_BASE64;
8076 kern_type = KERN_TYPE_SHA256_SLTPWU;
8077 dgst_size = DGST_SIZE_4_8;
8078 parse_func = episerver4_parse_hash;
8079 sort_by_digest = sort_by_digest_4_8;
8080 opti_type = OPTI_TYPE_ZERO_BYTE
8081 | OPTI_TYPE_PRECOMPUTE_INIT
8082 | OPTI_TYPE_PRECOMPUTE_MERKLE
8083 | OPTI_TYPE_EARLY_SKIP
8084 | OPTI_TYPE_NOT_ITERATED
8085 | OPTI_TYPE_PREPENDED_SALT
8086 | OPTI_TYPE_RAW_HASH;
8087 dgst_pos0 = 3;
8088 dgst_pos1 = 7;
8089 dgst_pos2 = 2;
8090 dgst_pos3 = 6;
8091 break;
8092
8093 case 1450: hash_type = HASH_TYPE_SHA256;
8094 salt_type = SALT_TYPE_INTERN;
8095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8096 opts_type = OPTS_TYPE_PT_GENERATE_BE
8097 | OPTS_TYPE_ST_ADD80;
8098 kern_type = KERN_TYPE_HMACSHA256_PW;
8099 dgst_size = DGST_SIZE_4_8;
8100 parse_func = hmacsha256_parse_hash;
8101 sort_by_digest = sort_by_digest_4_8;
8102 opti_type = OPTI_TYPE_ZERO_BYTE
8103 | OPTI_TYPE_NOT_ITERATED;
8104 dgst_pos0 = 3;
8105 dgst_pos1 = 7;
8106 dgst_pos2 = 2;
8107 dgst_pos3 = 6;
8108 break;
8109
8110 case 1460: hash_type = HASH_TYPE_SHA256;
8111 salt_type = SALT_TYPE_INTERN;
8112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8113 opts_type = OPTS_TYPE_PT_GENERATE_BE
8114 | OPTS_TYPE_PT_ADD80
8115 | OPTS_TYPE_PT_ADDBITS15;
8116 kern_type = KERN_TYPE_HMACSHA256_SLT;
8117 dgst_size = DGST_SIZE_4_8;
8118 parse_func = hmacsha256_parse_hash;
8119 sort_by_digest = sort_by_digest_4_8;
8120 opti_type = OPTI_TYPE_ZERO_BYTE
8121 | OPTI_TYPE_NOT_ITERATED;
8122 dgst_pos0 = 3;
8123 dgst_pos1 = 7;
8124 dgst_pos2 = 2;
8125 dgst_pos3 = 6;
8126 break;
8127
8128 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8129 salt_type = SALT_TYPE_EMBEDDED;
8130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8131 opts_type = OPTS_TYPE_PT_GENERATE_LE
8132 | OPTS_TYPE_PT_BITSLICE;
8133 kern_type = KERN_TYPE_DESCRYPT;
8134 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8135 parse_func = descrypt_parse_hash;
8136 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8137 opti_type = OPTI_TYPE_ZERO_BYTE
8138 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8139 dgst_pos0 = 0;
8140 dgst_pos1 = 1;
8141 dgst_pos2 = 2;
8142 dgst_pos3 = 3;
8143 break;
8144
8145 case 1600: hash_type = HASH_TYPE_MD5;
8146 salt_type = SALT_TYPE_EMBEDDED;
8147 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8148 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8149 kern_type = KERN_TYPE_APR1CRYPT;
8150 dgst_size = DGST_SIZE_4_4;
8151 parse_func = md5apr1_parse_hash;
8152 sort_by_digest = sort_by_digest_4_4;
8153 opti_type = OPTI_TYPE_ZERO_BYTE;
8154 dgst_pos0 = 0;
8155 dgst_pos1 = 1;
8156 dgst_pos2 = 2;
8157 dgst_pos3 = 3;
8158 break;
8159
8160 case 1700: hash_type = HASH_TYPE_SHA512;
8161 salt_type = SALT_TYPE_NONE;
8162 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8163 opts_type = OPTS_TYPE_PT_GENERATE_BE
8164 | OPTS_TYPE_PT_ADD80
8165 | OPTS_TYPE_PT_ADDBITS15;
8166 kern_type = KERN_TYPE_SHA512;
8167 dgst_size = DGST_SIZE_8_8;
8168 parse_func = sha512_parse_hash;
8169 sort_by_digest = sort_by_digest_8_8;
8170 opti_type = OPTI_TYPE_ZERO_BYTE
8171 | OPTI_TYPE_PRECOMPUTE_INIT
8172 | OPTI_TYPE_PRECOMPUTE_MERKLE
8173 | OPTI_TYPE_EARLY_SKIP
8174 | OPTI_TYPE_NOT_ITERATED
8175 | OPTI_TYPE_NOT_SALTED
8176 | OPTI_TYPE_USES_BITS_64
8177 | OPTI_TYPE_RAW_HASH;
8178 dgst_pos0 = 14;
8179 dgst_pos1 = 15;
8180 dgst_pos2 = 6;
8181 dgst_pos3 = 7;
8182 break;
8183
8184 case 1710: hash_type = HASH_TYPE_SHA512;
8185 salt_type = SALT_TYPE_INTERN;
8186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8187 opts_type = OPTS_TYPE_PT_GENERATE_BE
8188 | OPTS_TYPE_ST_ADD80
8189 | OPTS_TYPE_ST_ADDBITS15;
8190 kern_type = KERN_TYPE_SHA512_PWSLT;
8191 dgst_size = DGST_SIZE_8_8;
8192 parse_func = sha512s_parse_hash;
8193 sort_by_digest = sort_by_digest_8_8;
8194 opti_type = OPTI_TYPE_ZERO_BYTE
8195 | OPTI_TYPE_PRECOMPUTE_INIT
8196 | OPTI_TYPE_PRECOMPUTE_MERKLE
8197 | OPTI_TYPE_EARLY_SKIP
8198 | OPTI_TYPE_NOT_ITERATED
8199 | OPTI_TYPE_APPENDED_SALT
8200 | OPTI_TYPE_USES_BITS_64
8201 | OPTI_TYPE_RAW_HASH;
8202 dgst_pos0 = 14;
8203 dgst_pos1 = 15;
8204 dgst_pos2 = 6;
8205 dgst_pos3 = 7;
8206 break;
8207
8208 case 1711: hash_type = HASH_TYPE_SHA512;
8209 salt_type = SALT_TYPE_EMBEDDED;
8210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8211 opts_type = OPTS_TYPE_PT_GENERATE_BE
8212 | OPTS_TYPE_ST_ADD80
8213 | OPTS_TYPE_ST_ADDBITS15;
8214 kern_type = KERN_TYPE_SHA512_PWSLT;
8215 dgst_size = DGST_SIZE_8_8;
8216 parse_func = sha512b64s_parse_hash;
8217 sort_by_digest = sort_by_digest_8_8;
8218 opti_type = OPTI_TYPE_ZERO_BYTE
8219 | OPTI_TYPE_PRECOMPUTE_INIT
8220 | OPTI_TYPE_PRECOMPUTE_MERKLE
8221 | OPTI_TYPE_EARLY_SKIP
8222 | OPTI_TYPE_NOT_ITERATED
8223 | OPTI_TYPE_APPENDED_SALT
8224 | OPTI_TYPE_USES_BITS_64
8225 | OPTI_TYPE_RAW_HASH;
8226 dgst_pos0 = 14;
8227 dgst_pos1 = 15;
8228 dgst_pos2 = 6;
8229 dgst_pos3 = 7;
8230 break;
8231
8232 case 1720: hash_type = HASH_TYPE_SHA512;
8233 salt_type = SALT_TYPE_INTERN;
8234 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8235 opts_type = OPTS_TYPE_PT_GENERATE_BE
8236 | OPTS_TYPE_PT_ADD80
8237 | OPTS_TYPE_PT_ADDBITS15;
8238 kern_type = KERN_TYPE_SHA512_SLTPW;
8239 dgst_size = DGST_SIZE_8_8;
8240 parse_func = sha512s_parse_hash;
8241 sort_by_digest = sort_by_digest_8_8;
8242 opti_type = OPTI_TYPE_ZERO_BYTE
8243 | OPTI_TYPE_PRECOMPUTE_INIT
8244 | OPTI_TYPE_PRECOMPUTE_MERKLE
8245 | OPTI_TYPE_EARLY_SKIP
8246 | OPTI_TYPE_NOT_ITERATED
8247 | OPTI_TYPE_PREPENDED_SALT
8248 | OPTI_TYPE_USES_BITS_64
8249 | OPTI_TYPE_RAW_HASH;
8250 dgst_pos0 = 14;
8251 dgst_pos1 = 15;
8252 dgst_pos2 = 6;
8253 dgst_pos3 = 7;
8254 break;
8255
8256 case 1722: hash_type = HASH_TYPE_SHA512;
8257 salt_type = SALT_TYPE_EMBEDDED;
8258 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8259 opts_type = OPTS_TYPE_PT_GENERATE_BE
8260 | OPTS_TYPE_PT_ADD80
8261 | OPTS_TYPE_PT_ADDBITS15
8262 | OPTS_TYPE_ST_HEX;
8263 kern_type = KERN_TYPE_SHA512_SLTPW;
8264 dgst_size = DGST_SIZE_8_8;
8265 parse_func = osx512_parse_hash;
8266 sort_by_digest = sort_by_digest_8_8;
8267 opti_type = OPTI_TYPE_ZERO_BYTE
8268 | OPTI_TYPE_PRECOMPUTE_INIT
8269 | OPTI_TYPE_PRECOMPUTE_MERKLE
8270 | OPTI_TYPE_EARLY_SKIP
8271 | OPTI_TYPE_NOT_ITERATED
8272 | OPTI_TYPE_PREPENDED_SALT
8273 | OPTI_TYPE_USES_BITS_64
8274 | OPTI_TYPE_RAW_HASH;
8275 dgst_pos0 = 14;
8276 dgst_pos1 = 15;
8277 dgst_pos2 = 6;
8278 dgst_pos3 = 7;
8279 break;
8280
8281 case 1730: hash_type = HASH_TYPE_SHA512;
8282 salt_type = SALT_TYPE_INTERN;
8283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8284 opts_type = OPTS_TYPE_PT_GENERATE_BE
8285 | OPTS_TYPE_PT_UNICODE
8286 | OPTS_TYPE_ST_ADD80
8287 | OPTS_TYPE_ST_ADDBITS15;
8288 kern_type = KERN_TYPE_SHA512_PWSLTU;
8289 dgst_size = DGST_SIZE_8_8;
8290 parse_func = sha512s_parse_hash;
8291 sort_by_digest = sort_by_digest_8_8;
8292 opti_type = OPTI_TYPE_ZERO_BYTE
8293 | OPTI_TYPE_PRECOMPUTE_INIT
8294 | OPTI_TYPE_PRECOMPUTE_MERKLE
8295 | OPTI_TYPE_EARLY_SKIP
8296 | OPTI_TYPE_NOT_ITERATED
8297 | OPTI_TYPE_APPENDED_SALT
8298 | OPTI_TYPE_USES_BITS_64
8299 | OPTI_TYPE_RAW_HASH;
8300 dgst_pos0 = 14;
8301 dgst_pos1 = 15;
8302 dgst_pos2 = 6;
8303 dgst_pos3 = 7;
8304 break;
8305
8306 case 1731: hash_type = HASH_TYPE_SHA512;
8307 salt_type = SALT_TYPE_EMBEDDED;
8308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8309 opts_type = OPTS_TYPE_PT_GENERATE_BE
8310 | OPTS_TYPE_PT_UNICODE
8311 | OPTS_TYPE_ST_ADD80
8312 | OPTS_TYPE_ST_ADDBITS15
8313 | OPTS_TYPE_ST_HEX;
8314 kern_type = KERN_TYPE_SHA512_PWSLTU;
8315 dgst_size = DGST_SIZE_8_8;
8316 parse_func = mssql2012_parse_hash;
8317 sort_by_digest = sort_by_digest_8_8;
8318 opti_type = OPTI_TYPE_ZERO_BYTE
8319 | OPTI_TYPE_PRECOMPUTE_INIT
8320 | OPTI_TYPE_PRECOMPUTE_MERKLE
8321 | OPTI_TYPE_EARLY_SKIP
8322 | OPTI_TYPE_NOT_ITERATED
8323 | OPTI_TYPE_APPENDED_SALT
8324 | OPTI_TYPE_USES_BITS_64
8325 | OPTI_TYPE_RAW_HASH;
8326 dgst_pos0 = 14;
8327 dgst_pos1 = 15;
8328 dgst_pos2 = 6;
8329 dgst_pos3 = 7;
8330 break;
8331
8332 case 1740: hash_type = HASH_TYPE_SHA512;
8333 salt_type = SALT_TYPE_INTERN;
8334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8335 opts_type = OPTS_TYPE_PT_GENERATE_BE
8336 | OPTS_TYPE_PT_ADD80
8337 | OPTS_TYPE_PT_ADDBITS15
8338 | OPTS_TYPE_PT_UNICODE;
8339 kern_type = KERN_TYPE_SHA512_SLTPWU;
8340 dgst_size = DGST_SIZE_8_8;
8341 parse_func = sha512s_parse_hash;
8342 sort_by_digest = sort_by_digest_8_8;
8343 opti_type = OPTI_TYPE_ZERO_BYTE
8344 | OPTI_TYPE_PRECOMPUTE_INIT
8345 | OPTI_TYPE_PRECOMPUTE_MERKLE
8346 | OPTI_TYPE_EARLY_SKIP
8347 | OPTI_TYPE_NOT_ITERATED
8348 | OPTI_TYPE_PREPENDED_SALT
8349 | OPTI_TYPE_USES_BITS_64
8350 | OPTI_TYPE_RAW_HASH;
8351 dgst_pos0 = 14;
8352 dgst_pos1 = 15;
8353 dgst_pos2 = 6;
8354 dgst_pos3 = 7;
8355 break;
8356
8357 case 1750: hash_type = HASH_TYPE_SHA512;
8358 salt_type = SALT_TYPE_INTERN;
8359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8360 opts_type = OPTS_TYPE_PT_GENERATE_BE
8361 | OPTS_TYPE_ST_ADD80;
8362 kern_type = KERN_TYPE_HMACSHA512_PW;
8363 dgst_size = DGST_SIZE_8_8;
8364 parse_func = hmacsha512_parse_hash;
8365 sort_by_digest = sort_by_digest_8_8;
8366 opti_type = OPTI_TYPE_ZERO_BYTE
8367 | OPTI_TYPE_USES_BITS_64
8368 | OPTI_TYPE_NOT_ITERATED;
8369 dgst_pos0 = 14;
8370 dgst_pos1 = 15;
8371 dgst_pos2 = 6;
8372 dgst_pos3 = 7;
8373 break;
8374
8375 case 1760: hash_type = HASH_TYPE_SHA512;
8376 salt_type = SALT_TYPE_INTERN;
8377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8378 opts_type = OPTS_TYPE_PT_GENERATE_BE
8379 | OPTS_TYPE_PT_ADD80
8380 | OPTS_TYPE_PT_ADDBITS15;
8381 kern_type = KERN_TYPE_HMACSHA512_SLT;
8382 dgst_size = DGST_SIZE_8_8;
8383 parse_func = hmacsha512_parse_hash;
8384 sort_by_digest = sort_by_digest_8_8;
8385 opti_type = OPTI_TYPE_ZERO_BYTE
8386 | OPTI_TYPE_USES_BITS_64
8387 | OPTI_TYPE_NOT_ITERATED;
8388 dgst_pos0 = 14;
8389 dgst_pos1 = 15;
8390 dgst_pos2 = 6;
8391 dgst_pos3 = 7;
8392 break;
8393
8394 case 1800: hash_type = HASH_TYPE_SHA512;
8395 salt_type = SALT_TYPE_EMBEDDED;
8396 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8397 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8398 kern_type = KERN_TYPE_SHA512CRYPT;
8399 dgst_size = DGST_SIZE_8_8;
8400 parse_func = sha512crypt_parse_hash;
8401 sort_by_digest = sort_by_digest_8_8;
8402 opti_type = OPTI_TYPE_ZERO_BYTE
8403 | OPTI_TYPE_USES_BITS_64;
8404 dgst_pos0 = 0;
8405 dgst_pos1 = 1;
8406 dgst_pos2 = 2;
8407 dgst_pos3 = 3;
8408 break;
8409
8410 case 2100: hash_type = HASH_TYPE_DCC2;
8411 salt_type = SALT_TYPE_EMBEDDED;
8412 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8413 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8414 | OPTS_TYPE_ST_LOWER
8415 | OPTS_TYPE_ST_UNICODE;
8416 kern_type = KERN_TYPE_DCC2;
8417 dgst_size = DGST_SIZE_4_4;
8418 parse_func = dcc2_parse_hash;
8419 sort_by_digest = sort_by_digest_4_4;
8420 opti_type = OPTI_TYPE_ZERO_BYTE
8421 | OPTI_TYPE_SLOW_HASH_SIMD;
8422 dgst_pos0 = 0;
8423 dgst_pos1 = 1;
8424 dgst_pos2 = 2;
8425 dgst_pos3 = 3;
8426 break;
8427
8428 case 2400: hash_type = HASH_TYPE_MD5;
8429 salt_type = SALT_TYPE_NONE;
8430 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8431 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8432 kern_type = KERN_TYPE_MD5PIX;
8433 dgst_size = DGST_SIZE_4_4;
8434 parse_func = md5pix_parse_hash;
8435 sort_by_digest = sort_by_digest_4_4;
8436 opti_type = OPTI_TYPE_ZERO_BYTE
8437 | OPTI_TYPE_PRECOMPUTE_INIT
8438 | OPTI_TYPE_PRECOMPUTE_MERKLE
8439 | OPTI_TYPE_EARLY_SKIP
8440 | OPTI_TYPE_NOT_ITERATED
8441 | OPTI_TYPE_NOT_SALTED;
8442 dgst_pos0 = 0;
8443 dgst_pos1 = 3;
8444 dgst_pos2 = 2;
8445 dgst_pos3 = 1;
8446 break;
8447
8448 case 2410: hash_type = HASH_TYPE_MD5;
8449 salt_type = SALT_TYPE_INTERN;
8450 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8451 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8452 kern_type = KERN_TYPE_MD5ASA;
8453 dgst_size = DGST_SIZE_4_4;
8454 parse_func = md5asa_parse_hash;
8455 sort_by_digest = sort_by_digest_4_4;
8456 opti_type = OPTI_TYPE_ZERO_BYTE
8457 | OPTI_TYPE_PRECOMPUTE_INIT
8458 | OPTI_TYPE_PRECOMPUTE_MERKLE
8459 | OPTI_TYPE_EARLY_SKIP
8460 | OPTI_TYPE_NOT_ITERATED;
8461 dgst_pos0 = 0;
8462 dgst_pos1 = 3;
8463 dgst_pos2 = 2;
8464 dgst_pos3 = 1;
8465 break;
8466
8467 case 2500: hash_type = HASH_TYPE_WPA;
8468 salt_type = SALT_TYPE_EMBEDDED;
8469 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8470 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8471 kern_type = KERN_TYPE_WPA;
8472 dgst_size = DGST_SIZE_4_4;
8473 parse_func = wpa_parse_hash;
8474 sort_by_digest = sort_by_digest_4_4;
8475 opti_type = OPTI_TYPE_ZERO_BYTE
8476 | OPTI_TYPE_SLOW_HASH_SIMD;
8477 dgst_pos0 = 0;
8478 dgst_pos1 = 1;
8479 dgst_pos2 = 2;
8480 dgst_pos3 = 3;
8481 break;
8482
8483 case 2600: hash_type = HASH_TYPE_MD5;
8484 salt_type = SALT_TYPE_VIRTUAL;
8485 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8486 opts_type = OPTS_TYPE_PT_GENERATE_LE
8487 | OPTS_TYPE_PT_ADD80
8488 | OPTS_TYPE_PT_ADDBITS14
8489 | OPTS_TYPE_ST_ADD80;
8490 kern_type = KERN_TYPE_MD55_PWSLT1;
8491 dgst_size = DGST_SIZE_4_4;
8492 parse_func = md5md5_parse_hash;
8493 sort_by_digest = sort_by_digest_4_4;
8494 opti_type = OPTI_TYPE_ZERO_BYTE
8495 | OPTI_TYPE_PRECOMPUTE_INIT
8496 | OPTI_TYPE_PRECOMPUTE_MERKLE
8497 | OPTI_TYPE_EARLY_SKIP;
8498 dgst_pos0 = 0;
8499 dgst_pos1 = 3;
8500 dgst_pos2 = 2;
8501 dgst_pos3 = 1;
8502 break;
8503
8504 case 2611: hash_type = HASH_TYPE_MD5;
8505 salt_type = SALT_TYPE_INTERN;
8506 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8507 opts_type = OPTS_TYPE_PT_GENERATE_LE
8508 | OPTS_TYPE_PT_ADD80
8509 | OPTS_TYPE_PT_ADDBITS14
8510 | OPTS_TYPE_ST_ADD80;
8511 kern_type = KERN_TYPE_MD55_PWSLT1;
8512 dgst_size = DGST_SIZE_4_4;
8513 parse_func = vb3_parse_hash;
8514 sort_by_digest = sort_by_digest_4_4;
8515 opti_type = OPTI_TYPE_ZERO_BYTE
8516 | OPTI_TYPE_PRECOMPUTE_INIT
8517 | OPTI_TYPE_PRECOMPUTE_MERKLE
8518 | OPTI_TYPE_EARLY_SKIP;
8519 dgst_pos0 = 0;
8520 dgst_pos1 = 3;
8521 dgst_pos2 = 2;
8522 dgst_pos3 = 1;
8523 break;
8524
8525 case 2612: hash_type = HASH_TYPE_MD5;
8526 salt_type = SALT_TYPE_EMBEDDED;
8527 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8528 opts_type = OPTS_TYPE_PT_GENERATE_LE
8529 | OPTS_TYPE_PT_ADD80
8530 | OPTS_TYPE_PT_ADDBITS14
8531 | OPTS_TYPE_ST_ADD80
8532 | OPTS_TYPE_ST_HEX;
8533 kern_type = KERN_TYPE_MD55_PWSLT1;
8534 dgst_size = DGST_SIZE_4_4;
8535 parse_func = phps_parse_hash;
8536 sort_by_digest = sort_by_digest_4_4;
8537 opti_type = OPTI_TYPE_ZERO_BYTE
8538 | OPTI_TYPE_PRECOMPUTE_INIT
8539 | OPTI_TYPE_PRECOMPUTE_MERKLE
8540 | OPTI_TYPE_EARLY_SKIP;
8541 dgst_pos0 = 0;
8542 dgst_pos1 = 3;
8543 dgst_pos2 = 2;
8544 dgst_pos3 = 1;
8545 break;
8546
8547 case 2711: hash_type = HASH_TYPE_MD5;
8548 salt_type = SALT_TYPE_INTERN;
8549 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8550 opts_type = OPTS_TYPE_PT_GENERATE_LE
8551 | OPTS_TYPE_PT_ADD80
8552 | OPTS_TYPE_PT_ADDBITS14
8553 | OPTS_TYPE_ST_ADD80;
8554 kern_type = KERN_TYPE_MD55_PWSLT2;
8555 dgst_size = DGST_SIZE_4_4;
8556 parse_func = vb30_parse_hash;
8557 sort_by_digest = sort_by_digest_4_4;
8558 opti_type = OPTI_TYPE_ZERO_BYTE
8559 | OPTI_TYPE_PRECOMPUTE_INIT
8560 | OPTI_TYPE_EARLY_SKIP;
8561 dgst_pos0 = 0;
8562 dgst_pos1 = 3;
8563 dgst_pos2 = 2;
8564 dgst_pos3 = 1;
8565 break;
8566
8567 case 2811: hash_type = HASH_TYPE_MD5;
8568 salt_type = SALT_TYPE_INTERN;
8569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8570 opts_type = OPTS_TYPE_PT_GENERATE_LE
8571 | OPTS_TYPE_PT_ADD80
8572 | OPTS_TYPE_PT_ADDBITS14;
8573 kern_type = KERN_TYPE_MD55_SLTPW;
8574 dgst_size = DGST_SIZE_4_4;
8575 parse_func = ipb2_parse_hash;
8576 sort_by_digest = sort_by_digest_4_4;
8577 opti_type = OPTI_TYPE_ZERO_BYTE
8578 | OPTI_TYPE_PRECOMPUTE_INIT
8579 | OPTI_TYPE_EARLY_SKIP;
8580 dgst_pos0 = 0;
8581 dgst_pos1 = 3;
8582 dgst_pos2 = 2;
8583 dgst_pos3 = 1;
8584 break;
8585
8586 case 3000: hash_type = HASH_TYPE_LM;
8587 salt_type = SALT_TYPE_NONE;
8588 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8589 opts_type = OPTS_TYPE_PT_GENERATE_LE
8590 | OPTS_TYPE_PT_UPPER
8591 | OPTS_TYPE_PT_BITSLICE;
8592 kern_type = KERN_TYPE_LM;
8593 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8594 parse_func = lm_parse_hash;
8595 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8596 opti_type = OPTI_TYPE_ZERO_BYTE
8597 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8598 dgst_pos0 = 0;
8599 dgst_pos1 = 1;
8600 dgst_pos2 = 2;
8601 dgst_pos3 = 3;
8602 break;
8603
8604 case 3100: hash_type = HASH_TYPE_ORACLEH;
8605 salt_type = SALT_TYPE_INTERN;
8606 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8607 opts_type = OPTS_TYPE_PT_GENERATE_LE
8608 | OPTS_TYPE_PT_UPPER
8609 | OPTS_TYPE_ST_UPPER;
8610 kern_type = KERN_TYPE_ORACLEH;
8611 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8612 parse_func = oracleh_parse_hash;
8613 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8614 opti_type = OPTI_TYPE_ZERO_BYTE;
8615 dgst_pos0 = 0;
8616 dgst_pos1 = 1;
8617 dgst_pos2 = 2;
8618 dgst_pos3 = 3;
8619 break;
8620
8621 case 3200: hash_type = HASH_TYPE_BCRYPT;
8622 salt_type = SALT_TYPE_EMBEDDED;
8623 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8624 opts_type = OPTS_TYPE_PT_GENERATE_LE
8625 | OPTS_TYPE_ST_GENERATE_LE;
8626 kern_type = KERN_TYPE_BCRYPT;
8627 dgst_size = DGST_SIZE_4_6;
8628 parse_func = bcrypt_parse_hash;
8629 sort_by_digest = sort_by_digest_4_6;
8630 opti_type = OPTI_TYPE_ZERO_BYTE;
8631 dgst_pos0 = 0;
8632 dgst_pos1 = 1;
8633 dgst_pos2 = 2;
8634 dgst_pos3 = 3;
8635 break;
8636
8637 case 3710: hash_type = HASH_TYPE_MD5;
8638 salt_type = SALT_TYPE_INTERN;
8639 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8640 opts_type = OPTS_TYPE_PT_GENERATE_LE
8641 | OPTS_TYPE_PT_ADD80
8642 | OPTS_TYPE_PT_ADDBITS14;
8643 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8644 dgst_size = DGST_SIZE_4_4;
8645 parse_func = md5s_parse_hash;
8646 sort_by_digest = sort_by_digest_4_4;
8647 opti_type = OPTI_TYPE_ZERO_BYTE
8648 | OPTI_TYPE_PRECOMPUTE_INIT
8649 | OPTI_TYPE_PRECOMPUTE_MERKLE
8650 | OPTI_TYPE_EARLY_SKIP;
8651 dgst_pos0 = 0;
8652 dgst_pos1 = 3;
8653 dgst_pos2 = 2;
8654 dgst_pos3 = 1;
8655 break;
8656
8657 case 3711: hash_type = HASH_TYPE_MD5;
8658 salt_type = SALT_TYPE_EMBEDDED;
8659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8660 opts_type = OPTS_TYPE_PT_GENERATE_LE
8661 | OPTS_TYPE_PT_ADD80
8662 | OPTS_TYPE_PT_ADDBITS14;
8663 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8664 dgst_size = DGST_SIZE_4_4;
8665 parse_func = mediawiki_b_parse_hash;
8666 sort_by_digest = sort_by_digest_4_4;
8667 opti_type = OPTI_TYPE_ZERO_BYTE
8668 | OPTI_TYPE_PRECOMPUTE_INIT
8669 | OPTI_TYPE_PRECOMPUTE_MERKLE
8670 | OPTI_TYPE_EARLY_SKIP;
8671 dgst_pos0 = 0;
8672 dgst_pos1 = 3;
8673 dgst_pos2 = 2;
8674 dgst_pos3 = 1;
8675 break;
8676
8677 case 3800: hash_type = HASH_TYPE_MD5;
8678 salt_type = SALT_TYPE_INTERN;
8679 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8680 opts_type = OPTS_TYPE_PT_GENERATE_LE
8681 | OPTS_TYPE_ST_ADDBITS14;
8682 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8683 dgst_size = DGST_SIZE_4_4;
8684 parse_func = md5s_parse_hash;
8685 sort_by_digest = sort_by_digest_4_4;
8686 opti_type = OPTI_TYPE_ZERO_BYTE
8687 | OPTI_TYPE_PRECOMPUTE_INIT
8688 | OPTI_TYPE_PRECOMPUTE_MERKLE
8689 | OPTI_TYPE_EARLY_SKIP
8690 | OPTI_TYPE_NOT_ITERATED
8691 | OPTI_TYPE_RAW_HASH;
8692 dgst_pos0 = 0;
8693 dgst_pos1 = 3;
8694 dgst_pos2 = 2;
8695 dgst_pos3 = 1;
8696 break;
8697
8698 case 4300: hash_type = HASH_TYPE_MD5;
8699 salt_type = SALT_TYPE_VIRTUAL;
8700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8701 opts_type = OPTS_TYPE_PT_GENERATE_LE
8702 | OPTS_TYPE_PT_ADD80
8703 | OPTS_TYPE_PT_ADDBITS14
8704 | OPTS_TYPE_ST_ADD80;
8705 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8706 dgst_size = DGST_SIZE_4_4;
8707 parse_func = md5md5_parse_hash;
8708 sort_by_digest = sort_by_digest_4_4;
8709 opti_type = OPTI_TYPE_ZERO_BYTE
8710 | OPTI_TYPE_PRECOMPUTE_INIT
8711 | OPTI_TYPE_PRECOMPUTE_MERKLE
8712 | OPTI_TYPE_EARLY_SKIP;
8713 dgst_pos0 = 0;
8714 dgst_pos1 = 3;
8715 dgst_pos2 = 2;
8716 dgst_pos3 = 1;
8717 break;
8718
8719
8720 case 4400: hash_type = HASH_TYPE_MD5;
8721 salt_type = SALT_TYPE_NONE;
8722 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8723 opts_type = OPTS_TYPE_PT_GENERATE_BE
8724 | OPTS_TYPE_PT_ADD80
8725 | OPTS_TYPE_PT_ADDBITS15;
8726 kern_type = KERN_TYPE_MD5_SHA1;
8727 dgst_size = DGST_SIZE_4_4;
8728 parse_func = md5_parse_hash;
8729 sort_by_digest = sort_by_digest_4_4;
8730 opti_type = OPTI_TYPE_ZERO_BYTE
8731 | OPTI_TYPE_PRECOMPUTE_INIT
8732 | OPTI_TYPE_PRECOMPUTE_MERKLE
8733 | OPTI_TYPE_EARLY_SKIP
8734 | OPTI_TYPE_NOT_ITERATED
8735 | OPTI_TYPE_NOT_SALTED
8736 | OPTI_TYPE_RAW_HASH;
8737 dgst_pos0 = 0;
8738 dgst_pos1 = 3;
8739 dgst_pos2 = 2;
8740 dgst_pos3 = 1;
8741 break;
8742
8743 case 4500: hash_type = HASH_TYPE_SHA1;
8744 salt_type = SALT_TYPE_NONE;
8745 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8746 opts_type = OPTS_TYPE_PT_GENERATE_BE
8747 | OPTS_TYPE_PT_ADD80
8748 | OPTS_TYPE_PT_ADDBITS15;
8749 kern_type = KERN_TYPE_SHA11;
8750 dgst_size = DGST_SIZE_4_5;
8751 parse_func = sha1_parse_hash;
8752 sort_by_digest = sort_by_digest_4_5;
8753 opti_type = OPTI_TYPE_ZERO_BYTE
8754 | OPTI_TYPE_PRECOMPUTE_INIT
8755 | OPTI_TYPE_PRECOMPUTE_MERKLE
8756 | OPTI_TYPE_EARLY_SKIP
8757 | OPTI_TYPE_NOT_SALTED;
8758 dgst_pos0 = 3;
8759 dgst_pos1 = 4;
8760 dgst_pos2 = 2;
8761 dgst_pos3 = 1;
8762 break;
8763
8764 case 4700: hash_type = HASH_TYPE_SHA1;
8765 salt_type = SALT_TYPE_NONE;
8766 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8767 opts_type = OPTS_TYPE_PT_GENERATE_LE
8768 | OPTS_TYPE_PT_ADD80
8769 | OPTS_TYPE_PT_ADDBITS14;
8770 kern_type = KERN_TYPE_SHA1_MD5;
8771 dgst_size = DGST_SIZE_4_5;
8772 parse_func = sha1_parse_hash;
8773 sort_by_digest = sort_by_digest_4_5;
8774 opti_type = OPTI_TYPE_ZERO_BYTE
8775 | OPTI_TYPE_PRECOMPUTE_INIT
8776 | OPTI_TYPE_PRECOMPUTE_MERKLE
8777 | OPTI_TYPE_EARLY_SKIP
8778 | OPTI_TYPE_NOT_ITERATED
8779 | OPTI_TYPE_NOT_SALTED
8780 | OPTI_TYPE_RAW_HASH;
8781 dgst_pos0 = 3;
8782 dgst_pos1 = 4;
8783 dgst_pos2 = 2;
8784 dgst_pos3 = 1;
8785 break;
8786
8787 case 4800: hash_type = HASH_TYPE_MD5;
8788 salt_type = SALT_TYPE_EMBEDDED;
8789 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8790 opts_type = OPTS_TYPE_PT_GENERATE_LE
8791 | OPTS_TYPE_PT_ADDBITS14;
8792 kern_type = KERN_TYPE_MD5_CHAP;
8793 dgst_size = DGST_SIZE_4_4;
8794 parse_func = chap_parse_hash;
8795 sort_by_digest = sort_by_digest_4_4;
8796 opti_type = OPTI_TYPE_ZERO_BYTE
8797 | OPTI_TYPE_PRECOMPUTE_INIT
8798 | OPTI_TYPE_PRECOMPUTE_MERKLE
8799 | OPTI_TYPE_MEET_IN_MIDDLE
8800 | OPTI_TYPE_EARLY_SKIP
8801 | OPTI_TYPE_NOT_ITERATED
8802 | OPTI_TYPE_RAW_HASH;
8803 dgst_pos0 = 0;
8804 dgst_pos1 = 3;
8805 dgst_pos2 = 2;
8806 dgst_pos3 = 1;
8807 break;
8808
8809 case 4900: hash_type = HASH_TYPE_SHA1;
8810 salt_type = SALT_TYPE_INTERN;
8811 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8812 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8813 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8814 dgst_size = DGST_SIZE_4_5;
8815 parse_func = sha1s_parse_hash;
8816 sort_by_digest = sort_by_digest_4_5;
8817 opti_type = OPTI_TYPE_ZERO_BYTE
8818 | OPTI_TYPE_PRECOMPUTE_INIT
8819 | OPTI_TYPE_PRECOMPUTE_MERKLE
8820 | OPTI_TYPE_EARLY_SKIP;
8821 dgst_pos0 = 3;
8822 dgst_pos1 = 4;
8823 dgst_pos2 = 2;
8824 dgst_pos3 = 1;
8825 break;
8826
8827 case 5000: hash_type = HASH_TYPE_KECCAK;
8828 salt_type = SALT_TYPE_EMBEDDED;
8829 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8830 opts_type = OPTS_TYPE_PT_GENERATE_LE
8831 | OPTS_TYPE_PT_ADD01;
8832 kern_type = KERN_TYPE_KECCAK;
8833 dgst_size = DGST_SIZE_8_25;
8834 parse_func = keccak_parse_hash;
8835 sort_by_digest = sort_by_digest_8_25;
8836 opti_type = OPTI_TYPE_ZERO_BYTE
8837 | OPTI_TYPE_USES_BITS_64
8838 | OPTI_TYPE_RAW_HASH;
8839 dgst_pos0 = 2;
8840 dgst_pos1 = 3;
8841 dgst_pos2 = 4;
8842 dgst_pos3 = 5;
8843 break;
8844
8845 case 5100: hash_type = HASH_TYPE_MD5H;
8846 salt_type = SALT_TYPE_NONE;
8847 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8848 opts_type = OPTS_TYPE_PT_GENERATE_LE
8849 | OPTS_TYPE_PT_ADD80
8850 | OPTS_TYPE_PT_ADDBITS14;
8851 kern_type = KERN_TYPE_MD5H;
8852 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8853 parse_func = md5half_parse_hash;
8854 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8855 opti_type = OPTI_TYPE_ZERO_BYTE
8856 | OPTI_TYPE_RAW_HASH;
8857 dgst_pos0 = 0;
8858 dgst_pos1 = 1;
8859 dgst_pos2 = 2;
8860 dgst_pos3 = 3;
8861 break;
8862
8863 case 5200: hash_type = HASH_TYPE_SHA256;
8864 salt_type = SALT_TYPE_EMBEDDED;
8865 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8866 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8867 kern_type = KERN_TYPE_PSAFE3;
8868 dgst_size = DGST_SIZE_4_8;
8869 parse_func = psafe3_parse_hash;
8870 sort_by_digest = sort_by_digest_4_8;
8871 opti_type = OPTI_TYPE_ZERO_BYTE;
8872 dgst_pos0 = 0;
8873 dgst_pos1 = 1;
8874 dgst_pos2 = 2;
8875 dgst_pos3 = 3;
8876 break;
8877
8878 case 5300: hash_type = HASH_TYPE_MD5;
8879 salt_type = SALT_TYPE_EMBEDDED;
8880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8881 opts_type = OPTS_TYPE_PT_GENERATE_LE
8882 | OPTS_TYPE_ST_ADD80;
8883 kern_type = KERN_TYPE_IKEPSK_MD5;
8884 dgst_size = DGST_SIZE_4_4;
8885 parse_func = ikepsk_md5_parse_hash;
8886 sort_by_digest = sort_by_digest_4_4;
8887 opti_type = OPTI_TYPE_ZERO_BYTE;
8888 dgst_pos0 = 0;
8889 dgst_pos1 = 3;
8890 dgst_pos2 = 2;
8891 dgst_pos3 = 1;
8892 break;
8893
8894 case 5400: hash_type = HASH_TYPE_SHA1;
8895 salt_type = SALT_TYPE_EMBEDDED;
8896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8897 opts_type = OPTS_TYPE_PT_GENERATE_BE
8898 | OPTS_TYPE_ST_ADD80;
8899 kern_type = KERN_TYPE_IKEPSK_SHA1;
8900 dgst_size = DGST_SIZE_4_5;
8901 parse_func = ikepsk_sha1_parse_hash;
8902 sort_by_digest = sort_by_digest_4_5;
8903 opti_type = OPTI_TYPE_ZERO_BYTE;
8904 dgst_pos0 = 3;
8905 dgst_pos1 = 4;
8906 dgst_pos2 = 2;
8907 dgst_pos3 = 1;
8908 break;
8909
8910 case 5500: hash_type = HASH_TYPE_NETNTLM;
8911 salt_type = SALT_TYPE_EMBEDDED;
8912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8913 opts_type = OPTS_TYPE_PT_GENERATE_LE
8914 | OPTS_TYPE_PT_ADD80
8915 | OPTS_TYPE_PT_ADDBITS14
8916 | OPTS_TYPE_PT_UNICODE
8917 | OPTS_TYPE_ST_HEX;
8918 kern_type = KERN_TYPE_NETNTLMv1;
8919 dgst_size = DGST_SIZE_4_4;
8920 parse_func = netntlmv1_parse_hash;
8921 sort_by_digest = sort_by_digest_4_4;
8922 opti_type = OPTI_TYPE_ZERO_BYTE
8923 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8924 dgst_pos0 = 0;
8925 dgst_pos1 = 1;
8926 dgst_pos2 = 2;
8927 dgst_pos3 = 3;
8928 break;
8929
8930 case 5600: hash_type = HASH_TYPE_MD5;
8931 salt_type = SALT_TYPE_EMBEDDED;
8932 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8933 opts_type = OPTS_TYPE_PT_GENERATE_LE
8934 | OPTS_TYPE_PT_ADD80
8935 | OPTS_TYPE_PT_ADDBITS14
8936 | OPTS_TYPE_PT_UNICODE;
8937 kern_type = KERN_TYPE_NETNTLMv2;
8938 dgst_size = DGST_SIZE_4_4;
8939 parse_func = netntlmv2_parse_hash;
8940 sort_by_digest = sort_by_digest_4_4;
8941 opti_type = OPTI_TYPE_ZERO_BYTE;
8942 dgst_pos0 = 0;
8943 dgst_pos1 = 3;
8944 dgst_pos2 = 2;
8945 dgst_pos3 = 1;
8946 break;
8947
8948 case 5700: hash_type = HASH_TYPE_SHA256;
8949 salt_type = SALT_TYPE_NONE;
8950 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8951 opts_type = OPTS_TYPE_PT_GENERATE_BE
8952 | OPTS_TYPE_PT_ADD80
8953 | OPTS_TYPE_PT_ADDBITS15;
8954 kern_type = KERN_TYPE_SHA256;
8955 dgst_size = DGST_SIZE_4_8;
8956 parse_func = cisco4_parse_hash;
8957 sort_by_digest = sort_by_digest_4_8;
8958 opti_type = OPTI_TYPE_ZERO_BYTE
8959 | OPTI_TYPE_PRECOMPUTE_INIT
8960 | OPTI_TYPE_PRECOMPUTE_MERKLE
8961 | OPTI_TYPE_EARLY_SKIP
8962 | OPTI_TYPE_NOT_ITERATED
8963 | OPTI_TYPE_NOT_SALTED
8964 | OPTI_TYPE_RAW_HASH;
8965 dgst_pos0 = 3;
8966 dgst_pos1 = 7;
8967 dgst_pos2 = 2;
8968 dgst_pos3 = 6;
8969 break;
8970
8971 case 5800: hash_type = HASH_TYPE_SHA1;
8972 salt_type = SALT_TYPE_INTERN;
8973 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8974 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8975 | OPTS_TYPE_ST_ADD80;
8976 kern_type = KERN_TYPE_ANDROIDPIN;
8977 dgst_size = DGST_SIZE_4_5;
8978 parse_func = androidpin_parse_hash;
8979 sort_by_digest = sort_by_digest_4_5;
8980 opti_type = OPTI_TYPE_ZERO_BYTE;
8981 dgst_pos0 = 0;
8982 dgst_pos1 = 1;
8983 dgst_pos2 = 2;
8984 dgst_pos3 = 3;
8985 break;
8986
8987 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8988 salt_type = SALT_TYPE_NONE;
8989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8990 opts_type = OPTS_TYPE_PT_GENERATE_LE
8991 | OPTS_TYPE_PT_ADD80;
8992 kern_type = KERN_TYPE_RIPEMD160;
8993 dgst_size = DGST_SIZE_4_5;
8994 parse_func = ripemd160_parse_hash;
8995 sort_by_digest = sort_by_digest_4_5;
8996 opti_type = OPTI_TYPE_ZERO_BYTE;
8997 dgst_pos0 = 0;
8998 dgst_pos1 = 1;
8999 dgst_pos2 = 2;
9000 dgst_pos3 = 3;
9001 break;
9002
9003 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9004 salt_type = SALT_TYPE_NONE;
9005 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9006 opts_type = OPTS_TYPE_PT_GENERATE_BE
9007 | OPTS_TYPE_PT_ADD80;
9008 kern_type = KERN_TYPE_WHIRLPOOL;
9009 dgst_size = DGST_SIZE_4_16;
9010 parse_func = whirlpool_parse_hash;
9011 sort_by_digest = sort_by_digest_4_16;
9012 opti_type = OPTI_TYPE_ZERO_BYTE;
9013 dgst_pos0 = 0;
9014 dgst_pos1 = 1;
9015 dgst_pos2 = 2;
9016 dgst_pos3 = 3;
9017 break;
9018
9019 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9020 salt_type = SALT_TYPE_EMBEDDED;
9021 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9022 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9023 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9024 dgst_size = DGST_SIZE_4_5;
9025 parse_func = truecrypt_parse_hash_2k;
9026 sort_by_digest = sort_by_digest_4_5;
9027 opti_type = OPTI_TYPE_ZERO_BYTE;
9028 dgst_pos0 = 0;
9029 dgst_pos1 = 1;
9030 dgst_pos2 = 2;
9031 dgst_pos3 = 3;
9032 break;
9033
9034 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9035 salt_type = SALT_TYPE_EMBEDDED;
9036 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9037 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9038 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9039 dgst_size = DGST_SIZE_4_5;
9040 parse_func = truecrypt_parse_hash_2k;
9041 sort_by_digest = sort_by_digest_4_5;
9042 opti_type = OPTI_TYPE_ZERO_BYTE;
9043 dgst_pos0 = 0;
9044 dgst_pos1 = 1;
9045 dgst_pos2 = 2;
9046 dgst_pos3 = 3;
9047 break;
9048
9049 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9050 salt_type = SALT_TYPE_EMBEDDED;
9051 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9052 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9053 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9054 dgst_size = DGST_SIZE_4_5;
9055 parse_func = truecrypt_parse_hash_2k;
9056 sort_by_digest = sort_by_digest_4_5;
9057 opti_type = OPTI_TYPE_ZERO_BYTE;
9058 dgst_pos0 = 0;
9059 dgst_pos1 = 1;
9060 dgst_pos2 = 2;
9061 dgst_pos3 = 3;
9062 break;
9063
9064 case 6221: hash_type = HASH_TYPE_SHA512;
9065 salt_type = SALT_TYPE_EMBEDDED;
9066 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9067 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9068 kern_type = KERN_TYPE_TCSHA512_XTS512;
9069 dgst_size = DGST_SIZE_8_8;
9070 parse_func = truecrypt_parse_hash_1k;
9071 sort_by_digest = sort_by_digest_8_8;
9072 opti_type = OPTI_TYPE_ZERO_BYTE
9073 | OPTI_TYPE_USES_BITS_64;
9074 dgst_pos0 = 0;
9075 dgst_pos1 = 1;
9076 dgst_pos2 = 2;
9077 dgst_pos3 = 3;
9078 break;
9079
9080 case 6222: hash_type = HASH_TYPE_SHA512;
9081 salt_type = SALT_TYPE_EMBEDDED;
9082 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9083 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9084 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9085 dgst_size = DGST_SIZE_8_8;
9086 parse_func = truecrypt_parse_hash_1k;
9087 sort_by_digest = sort_by_digest_8_8;
9088 opti_type = OPTI_TYPE_ZERO_BYTE
9089 | OPTI_TYPE_USES_BITS_64;
9090 dgst_pos0 = 0;
9091 dgst_pos1 = 1;
9092 dgst_pos2 = 2;
9093 dgst_pos3 = 3;
9094 break;
9095
9096 case 6223: hash_type = HASH_TYPE_SHA512;
9097 salt_type = SALT_TYPE_EMBEDDED;
9098 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9099 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9100 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9101 dgst_size = DGST_SIZE_8_8;
9102 parse_func = truecrypt_parse_hash_1k;
9103 sort_by_digest = sort_by_digest_8_8;
9104 opti_type = OPTI_TYPE_ZERO_BYTE
9105 | OPTI_TYPE_USES_BITS_64;
9106 dgst_pos0 = 0;
9107 dgst_pos1 = 1;
9108 dgst_pos2 = 2;
9109 dgst_pos3 = 3;
9110 break;
9111
9112 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9113 salt_type = SALT_TYPE_EMBEDDED;
9114 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9115 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9116 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9117 dgst_size = DGST_SIZE_4_8;
9118 parse_func = truecrypt_parse_hash_1k;
9119 sort_by_digest = sort_by_digest_4_8;
9120 opti_type = OPTI_TYPE_ZERO_BYTE;
9121 dgst_pos0 = 0;
9122 dgst_pos1 = 1;
9123 dgst_pos2 = 2;
9124 dgst_pos3 = 3;
9125 break;
9126
9127 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9128 salt_type = SALT_TYPE_EMBEDDED;
9129 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9130 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9131 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9132 dgst_size = DGST_SIZE_4_8;
9133 parse_func = truecrypt_parse_hash_1k;
9134 sort_by_digest = sort_by_digest_4_8;
9135 opti_type = OPTI_TYPE_ZERO_BYTE;
9136 dgst_pos0 = 0;
9137 dgst_pos1 = 1;
9138 dgst_pos2 = 2;
9139 dgst_pos3 = 3;
9140 break;
9141
9142 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9143 salt_type = SALT_TYPE_EMBEDDED;
9144 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9145 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9146 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9147 dgst_size = DGST_SIZE_4_8;
9148 parse_func = truecrypt_parse_hash_1k;
9149 sort_by_digest = sort_by_digest_4_8;
9150 opti_type = OPTI_TYPE_ZERO_BYTE;
9151 dgst_pos0 = 0;
9152 dgst_pos1 = 1;
9153 dgst_pos2 = 2;
9154 dgst_pos3 = 3;
9155 break;
9156
9157 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9158 salt_type = SALT_TYPE_EMBEDDED;
9159 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9160 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9161 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9162 dgst_size = DGST_SIZE_4_5;
9163 parse_func = truecrypt_parse_hash_1k;
9164 sort_by_digest = sort_by_digest_4_5;
9165 opti_type = OPTI_TYPE_ZERO_BYTE;
9166 dgst_pos0 = 0;
9167 dgst_pos1 = 1;
9168 dgst_pos2 = 2;
9169 dgst_pos3 = 3;
9170 break;
9171
9172 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9173 salt_type = SALT_TYPE_EMBEDDED;
9174 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9175 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9176 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9177 dgst_size = DGST_SIZE_4_5;
9178 parse_func = truecrypt_parse_hash_1k;
9179 sort_by_digest = sort_by_digest_4_5;
9180 opti_type = OPTI_TYPE_ZERO_BYTE;
9181 dgst_pos0 = 0;
9182 dgst_pos1 = 1;
9183 dgst_pos2 = 2;
9184 dgst_pos3 = 3;
9185 break;
9186
9187 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9188 salt_type = SALT_TYPE_EMBEDDED;
9189 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9190 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9191 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9192 dgst_size = DGST_SIZE_4_5;
9193 parse_func = truecrypt_parse_hash_1k;
9194 sort_by_digest = sort_by_digest_4_5;
9195 opti_type = OPTI_TYPE_ZERO_BYTE;
9196 dgst_pos0 = 0;
9197 dgst_pos1 = 1;
9198 dgst_pos2 = 2;
9199 dgst_pos3 = 3;
9200 break;
9201
9202 case 6300: hash_type = HASH_TYPE_MD5;
9203 salt_type = SALT_TYPE_EMBEDDED;
9204 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9205 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9206 kern_type = KERN_TYPE_MD5AIX;
9207 dgst_size = DGST_SIZE_4_4;
9208 parse_func = md5aix_parse_hash;
9209 sort_by_digest = sort_by_digest_4_4;
9210 opti_type = OPTI_TYPE_ZERO_BYTE;
9211 dgst_pos0 = 0;
9212 dgst_pos1 = 1;
9213 dgst_pos2 = 2;
9214 dgst_pos3 = 3;
9215 break;
9216
9217 case 6400: hash_type = HASH_TYPE_SHA256;
9218 salt_type = SALT_TYPE_EMBEDDED;
9219 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9220 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9221 kern_type = KERN_TYPE_SHA256AIX;
9222 dgst_size = DGST_SIZE_4_8;
9223 parse_func = sha256aix_parse_hash;
9224 sort_by_digest = sort_by_digest_4_8;
9225 opti_type = OPTI_TYPE_ZERO_BYTE;
9226 dgst_pos0 = 0;
9227 dgst_pos1 = 1;
9228 dgst_pos2 = 2;
9229 dgst_pos3 = 3;
9230 break;
9231
9232 case 6500: hash_type = HASH_TYPE_SHA512;
9233 salt_type = SALT_TYPE_EMBEDDED;
9234 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9235 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9236 kern_type = KERN_TYPE_SHA512AIX;
9237 dgst_size = DGST_SIZE_8_8;
9238 parse_func = sha512aix_parse_hash;
9239 sort_by_digest = sort_by_digest_8_8;
9240 opti_type = OPTI_TYPE_ZERO_BYTE
9241 | OPTI_TYPE_USES_BITS_64;
9242 dgst_pos0 = 0;
9243 dgst_pos1 = 1;
9244 dgst_pos2 = 2;
9245 dgst_pos3 = 3;
9246 break;
9247
9248 case 6600: hash_type = HASH_TYPE_AES;
9249 salt_type = SALT_TYPE_EMBEDDED;
9250 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9251 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9252 kern_type = KERN_TYPE_AGILEKEY;
9253 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9254 parse_func = agilekey_parse_hash;
9255 sort_by_digest = sort_by_digest_4_5;
9256 opti_type = OPTI_TYPE_ZERO_BYTE;
9257 dgst_pos0 = 0;
9258 dgst_pos1 = 1;
9259 dgst_pos2 = 2;
9260 dgst_pos3 = 3;
9261 break;
9262
9263 case 6700: hash_type = HASH_TYPE_SHA1;
9264 salt_type = SALT_TYPE_EMBEDDED;
9265 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9266 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9267 kern_type = KERN_TYPE_SHA1AIX;
9268 dgst_size = DGST_SIZE_4_5;
9269 parse_func = sha1aix_parse_hash;
9270 sort_by_digest = sort_by_digest_4_5;
9271 opti_type = OPTI_TYPE_ZERO_BYTE;
9272 dgst_pos0 = 0;
9273 dgst_pos1 = 1;
9274 dgst_pos2 = 2;
9275 dgst_pos3 = 3;
9276 break;
9277
9278 case 6800: hash_type = HASH_TYPE_AES;
9279 salt_type = SALT_TYPE_EMBEDDED;
9280 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9281 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9282 kern_type = KERN_TYPE_LASTPASS;
9283 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9284 parse_func = lastpass_parse_hash;
9285 sort_by_digest = sort_by_digest_4_8;
9286 opti_type = OPTI_TYPE_ZERO_BYTE;
9287 dgst_pos0 = 0;
9288 dgst_pos1 = 1;
9289 dgst_pos2 = 2;
9290 dgst_pos3 = 3;
9291 break;
9292
9293 case 6900: hash_type = HASH_TYPE_GOST;
9294 salt_type = SALT_TYPE_NONE;
9295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9296 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9297 kern_type = KERN_TYPE_GOST;
9298 dgst_size = DGST_SIZE_4_8;
9299 parse_func = gost_parse_hash;
9300 sort_by_digest = sort_by_digest_4_8;
9301 opti_type = OPTI_TYPE_ZERO_BYTE;
9302 dgst_pos0 = 0;
9303 dgst_pos1 = 1;
9304 dgst_pos2 = 2;
9305 dgst_pos3 = 3;
9306 break;
9307
9308 case 7100: hash_type = HASH_TYPE_SHA512;
9309 salt_type = SALT_TYPE_EMBEDDED;
9310 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9311 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9312 kern_type = KERN_TYPE_PBKDF2_SHA512;
9313 dgst_size = DGST_SIZE_8_16;
9314 parse_func = sha512osx_parse_hash;
9315 sort_by_digest = sort_by_digest_8_16;
9316 opti_type = OPTI_TYPE_ZERO_BYTE
9317 | OPTI_TYPE_USES_BITS_64
9318 | OPTI_TYPE_SLOW_HASH_SIMD;
9319 dgst_pos0 = 0;
9320 dgst_pos1 = 1;
9321 dgst_pos2 = 2;
9322 dgst_pos3 = 3;
9323 break;
9324
9325 case 7200: hash_type = HASH_TYPE_SHA512;
9326 salt_type = SALT_TYPE_EMBEDDED;
9327 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9328 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9329 kern_type = KERN_TYPE_PBKDF2_SHA512;
9330 dgst_size = DGST_SIZE_8_16;
9331 parse_func = sha512grub_parse_hash;
9332 sort_by_digest = sort_by_digest_8_16;
9333 opti_type = OPTI_TYPE_ZERO_BYTE
9334 | OPTI_TYPE_USES_BITS_64
9335 | OPTI_TYPE_SLOW_HASH_SIMD;
9336 dgst_pos0 = 0;
9337 dgst_pos1 = 1;
9338 dgst_pos2 = 2;
9339 dgst_pos3 = 3;
9340 break;
9341
9342 case 7300: hash_type = HASH_TYPE_SHA1;
9343 salt_type = SALT_TYPE_EMBEDDED;
9344 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9345 opts_type = OPTS_TYPE_PT_GENERATE_BE
9346 | OPTS_TYPE_ST_ADD80
9347 | OPTS_TYPE_ST_ADDBITS15;
9348 kern_type = KERN_TYPE_RAKP;
9349 dgst_size = DGST_SIZE_4_5;
9350 parse_func = rakp_parse_hash;
9351 sort_by_digest = sort_by_digest_4_5;
9352 opti_type = OPTI_TYPE_ZERO_BYTE
9353 | OPTI_TYPE_NOT_ITERATED;
9354 dgst_pos0 = 3;
9355 dgst_pos1 = 4;
9356 dgst_pos2 = 2;
9357 dgst_pos3 = 1;
9358 break;
9359
9360 case 7400: hash_type = HASH_TYPE_SHA256;
9361 salt_type = SALT_TYPE_EMBEDDED;
9362 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9363 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9364 kern_type = KERN_TYPE_SHA256CRYPT;
9365 dgst_size = DGST_SIZE_4_8;
9366 parse_func = sha256crypt_parse_hash;
9367 sort_by_digest = sort_by_digest_4_8;
9368 opti_type = OPTI_TYPE_ZERO_BYTE;
9369 dgst_pos0 = 0;
9370 dgst_pos1 = 1;
9371 dgst_pos2 = 2;
9372 dgst_pos3 = 3;
9373 break;
9374
9375 case 7500: hash_type = HASH_TYPE_KRB5PA;
9376 salt_type = SALT_TYPE_EMBEDDED;
9377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9378 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9379 kern_type = KERN_TYPE_KRB5PA;
9380 dgst_size = DGST_SIZE_4_4;
9381 parse_func = krb5pa_parse_hash;
9382 sort_by_digest = sort_by_digest_4_4;
9383 opti_type = OPTI_TYPE_ZERO_BYTE
9384 | OPTI_TYPE_NOT_ITERATED;
9385 dgst_pos0 = 0;
9386 dgst_pos1 = 1;
9387 dgst_pos2 = 2;
9388 dgst_pos3 = 3;
9389 break;
9390
9391 case 7600: hash_type = HASH_TYPE_SHA1;
9392 salt_type = SALT_TYPE_INTERN;
9393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9394 opts_type = OPTS_TYPE_PT_GENERATE_BE
9395 | OPTS_TYPE_PT_ADD80
9396 | OPTS_TYPE_PT_ADDBITS15;
9397 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9398 dgst_size = DGST_SIZE_4_5;
9399 parse_func = redmine_parse_hash;
9400 sort_by_digest = sort_by_digest_4_5;
9401 opti_type = OPTI_TYPE_ZERO_BYTE
9402 | OPTI_TYPE_PRECOMPUTE_INIT
9403 | OPTI_TYPE_EARLY_SKIP
9404 | OPTI_TYPE_NOT_ITERATED
9405 | OPTI_TYPE_PREPENDED_SALT;
9406 dgst_pos0 = 3;
9407 dgst_pos1 = 4;
9408 dgst_pos2 = 2;
9409 dgst_pos3 = 1;
9410 break;
9411
9412 case 7700: hash_type = HASH_TYPE_SAPB;
9413 salt_type = SALT_TYPE_EMBEDDED;
9414 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9415 opts_type = OPTS_TYPE_PT_GENERATE_LE
9416 | OPTS_TYPE_PT_UPPER
9417 | OPTS_TYPE_ST_UPPER;
9418 kern_type = KERN_TYPE_SAPB;
9419 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9420 parse_func = sapb_parse_hash;
9421 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9422 opti_type = OPTI_TYPE_ZERO_BYTE
9423 | OPTI_TYPE_PRECOMPUTE_INIT
9424 | OPTI_TYPE_NOT_ITERATED;
9425 dgst_pos0 = 0;
9426 dgst_pos1 = 1;
9427 dgst_pos2 = 2;
9428 dgst_pos3 = 3;
9429 break;
9430
9431 case 7800: hash_type = HASH_TYPE_SAPG;
9432 salt_type = SALT_TYPE_EMBEDDED;
9433 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9434 opts_type = OPTS_TYPE_PT_GENERATE_BE
9435 | OPTS_TYPE_ST_ADD80
9436 | OPTS_TYPE_ST_UPPER;
9437 kern_type = KERN_TYPE_SAPG;
9438 dgst_size = DGST_SIZE_4_5;
9439 parse_func = sapg_parse_hash;
9440 sort_by_digest = sort_by_digest_4_5;
9441 opti_type = OPTI_TYPE_ZERO_BYTE
9442 | OPTI_TYPE_PRECOMPUTE_INIT
9443 | OPTI_TYPE_NOT_ITERATED;
9444 dgst_pos0 = 3;
9445 dgst_pos1 = 4;
9446 dgst_pos2 = 2;
9447 dgst_pos3 = 1;
9448 break;
9449
9450 case 7900: hash_type = HASH_TYPE_SHA512;
9451 salt_type = SALT_TYPE_EMBEDDED;
9452 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9453 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9454 kern_type = KERN_TYPE_DRUPAL7;
9455 dgst_size = DGST_SIZE_8_8;
9456 parse_func = drupal7_parse_hash;
9457 sort_by_digest = sort_by_digest_8_8;
9458 opti_type = OPTI_TYPE_ZERO_BYTE
9459 | OPTI_TYPE_USES_BITS_64;
9460 dgst_pos0 = 0;
9461 dgst_pos1 = 1;
9462 dgst_pos2 = 2;
9463 dgst_pos3 = 3;
9464 break;
9465
9466 case 8000: hash_type = HASH_TYPE_SHA256;
9467 salt_type = SALT_TYPE_EMBEDDED;
9468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9469 opts_type = OPTS_TYPE_PT_GENERATE_BE
9470 | OPTS_TYPE_PT_UNICODE
9471 | OPTS_TYPE_ST_ADD80
9472 | OPTS_TYPE_ST_HEX;
9473 kern_type = KERN_TYPE_SYBASEASE;
9474 dgst_size = DGST_SIZE_4_8;
9475 parse_func = sybasease_parse_hash;
9476 sort_by_digest = sort_by_digest_4_8;
9477 opti_type = OPTI_TYPE_ZERO_BYTE
9478 | OPTI_TYPE_PRECOMPUTE_INIT
9479 | OPTI_TYPE_EARLY_SKIP
9480 | OPTI_TYPE_NOT_ITERATED
9481 | OPTI_TYPE_RAW_HASH;
9482 dgst_pos0 = 3;
9483 dgst_pos1 = 7;
9484 dgst_pos2 = 2;
9485 dgst_pos3 = 6;
9486 break;
9487
9488 case 8100: hash_type = HASH_TYPE_SHA1;
9489 salt_type = SALT_TYPE_EMBEDDED;
9490 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9491 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9492 kern_type = KERN_TYPE_NETSCALER;
9493 dgst_size = DGST_SIZE_4_5;
9494 parse_func = netscaler_parse_hash;
9495 sort_by_digest = sort_by_digest_4_5;
9496 opti_type = OPTI_TYPE_ZERO_BYTE
9497 | OPTI_TYPE_PRECOMPUTE_INIT
9498 | OPTI_TYPE_PRECOMPUTE_MERKLE
9499 | OPTI_TYPE_EARLY_SKIP
9500 | OPTI_TYPE_NOT_ITERATED
9501 | OPTI_TYPE_PREPENDED_SALT
9502 | OPTI_TYPE_RAW_HASH;
9503 dgst_pos0 = 3;
9504 dgst_pos1 = 4;
9505 dgst_pos2 = 2;
9506 dgst_pos3 = 1;
9507 break;
9508
9509 case 8200: hash_type = HASH_TYPE_SHA256;
9510 salt_type = SALT_TYPE_EMBEDDED;
9511 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9512 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9513 kern_type = KERN_TYPE_CLOUDKEY;
9514 dgst_size = DGST_SIZE_4_8;
9515 parse_func = cloudkey_parse_hash;
9516 sort_by_digest = sort_by_digest_4_8;
9517 opti_type = OPTI_TYPE_ZERO_BYTE;
9518 dgst_pos0 = 0;
9519 dgst_pos1 = 1;
9520 dgst_pos2 = 2;
9521 dgst_pos3 = 3;
9522 break;
9523
9524 case 8300: hash_type = HASH_TYPE_SHA1;
9525 salt_type = SALT_TYPE_EMBEDDED;
9526 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9527 opts_type = OPTS_TYPE_PT_GENERATE_BE
9528 | OPTS_TYPE_ST_HEX
9529 | OPTS_TYPE_ST_ADD80;
9530 kern_type = KERN_TYPE_NSEC3;
9531 dgst_size = DGST_SIZE_4_5;
9532 parse_func = nsec3_parse_hash;
9533 sort_by_digest = sort_by_digest_4_5;
9534 opti_type = OPTI_TYPE_ZERO_BYTE;
9535 dgst_pos0 = 3;
9536 dgst_pos1 = 4;
9537 dgst_pos2 = 2;
9538 dgst_pos3 = 1;
9539 break;
9540
9541 case 8400: hash_type = HASH_TYPE_SHA1;
9542 salt_type = SALT_TYPE_INTERN;
9543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9544 opts_type = OPTS_TYPE_PT_GENERATE_BE
9545 | OPTS_TYPE_PT_ADD80
9546 | OPTS_TYPE_PT_ADDBITS15;
9547 kern_type = KERN_TYPE_WBB3;
9548 dgst_size = DGST_SIZE_4_5;
9549 parse_func = wbb3_parse_hash;
9550 sort_by_digest = sort_by_digest_4_5;
9551 opti_type = OPTI_TYPE_ZERO_BYTE
9552 | OPTI_TYPE_PRECOMPUTE_INIT
9553 | OPTI_TYPE_NOT_ITERATED;
9554 dgst_pos0 = 3;
9555 dgst_pos1 = 4;
9556 dgst_pos2 = 2;
9557 dgst_pos3 = 1;
9558 break;
9559
9560 case 8500: hash_type = HASH_TYPE_DESRACF;
9561 salt_type = SALT_TYPE_EMBEDDED;
9562 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9563 opts_type = OPTS_TYPE_PT_GENERATE_LE
9564 | OPTS_TYPE_ST_UPPER;
9565 kern_type = KERN_TYPE_RACF;
9566 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9567 parse_func = racf_parse_hash;
9568 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9569 opti_type = OPTI_TYPE_ZERO_BYTE
9570 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9571 dgst_pos0 = 0;
9572 dgst_pos1 = 1;
9573 dgst_pos2 = 2;
9574 dgst_pos3 = 3;
9575 break;
9576
9577 case 8600: hash_type = HASH_TYPE_LOTUS5;
9578 salt_type = SALT_TYPE_NONE;
9579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9580 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9581 kern_type = KERN_TYPE_LOTUS5;
9582 dgst_size = DGST_SIZE_4_4;
9583 parse_func = lotus5_parse_hash;
9584 sort_by_digest = sort_by_digest_4_4;
9585 opti_type = OPTI_TYPE_EARLY_SKIP
9586 | OPTI_TYPE_NOT_ITERATED
9587 | OPTI_TYPE_NOT_SALTED
9588 | OPTI_TYPE_RAW_HASH;
9589 dgst_pos0 = 0;
9590 dgst_pos1 = 1;
9591 dgst_pos2 = 2;
9592 dgst_pos3 = 3;
9593 break;
9594
9595 case 8700: hash_type = HASH_TYPE_LOTUS6;
9596 salt_type = SALT_TYPE_EMBEDDED;
9597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9598 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9599 kern_type = KERN_TYPE_LOTUS6;
9600 dgst_size = DGST_SIZE_4_4;
9601 parse_func = lotus6_parse_hash;
9602 sort_by_digest = sort_by_digest_4_4;
9603 opti_type = OPTI_TYPE_EARLY_SKIP
9604 | OPTI_TYPE_NOT_ITERATED
9605 | OPTI_TYPE_RAW_HASH;
9606 dgst_pos0 = 0;
9607 dgst_pos1 = 1;
9608 dgst_pos2 = 2;
9609 dgst_pos3 = 3;
9610 break;
9611
9612 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9613 salt_type = SALT_TYPE_EMBEDDED;
9614 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9615 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9616 kern_type = KERN_TYPE_ANDROIDFDE;
9617 dgst_size = DGST_SIZE_4_4;
9618 parse_func = androidfde_parse_hash;
9619 sort_by_digest = sort_by_digest_4_4;
9620 opti_type = OPTI_TYPE_ZERO_BYTE;
9621 dgst_pos0 = 0;
9622 dgst_pos1 = 1;
9623 dgst_pos2 = 2;
9624 dgst_pos3 = 3;
9625 break;
9626
9627 case 8900: hash_type = HASH_TYPE_SCRYPT;
9628 salt_type = SALT_TYPE_EMBEDDED;
9629 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9630 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9631 kern_type = KERN_TYPE_SCRYPT;
9632 dgst_size = DGST_SIZE_4_8;
9633 parse_func = scrypt_parse_hash;
9634 sort_by_digest = sort_by_digest_4_8;
9635 opti_type = OPTI_TYPE_ZERO_BYTE;
9636 dgst_pos0 = 0;
9637 dgst_pos1 = 1;
9638 dgst_pos2 = 2;
9639 dgst_pos3 = 3;
9640 break;
9641
9642 case 9000: hash_type = HASH_TYPE_SHA1;
9643 salt_type = SALT_TYPE_EMBEDDED;
9644 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9645 opts_type = OPTS_TYPE_PT_GENERATE_LE
9646 | OPTS_TYPE_ST_GENERATE_LE;
9647 kern_type = KERN_TYPE_PSAFE2;
9648 dgst_size = DGST_SIZE_4_5;
9649 parse_func = psafe2_parse_hash;
9650 sort_by_digest = sort_by_digest_4_5;
9651 opti_type = OPTI_TYPE_ZERO_BYTE;
9652 dgst_pos0 = 0;
9653 dgst_pos1 = 1;
9654 dgst_pos2 = 2;
9655 dgst_pos3 = 3;
9656 break;
9657
9658 case 9100: hash_type = HASH_TYPE_LOTUS8;
9659 salt_type = SALT_TYPE_EMBEDDED;
9660 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9661 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9662 kern_type = KERN_TYPE_LOTUS8;
9663 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9664 parse_func = lotus8_parse_hash;
9665 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9666 opti_type = OPTI_TYPE_ZERO_BYTE;
9667 dgst_pos0 = 0;
9668 dgst_pos1 = 1;
9669 dgst_pos2 = 2;
9670 dgst_pos3 = 3;
9671 break;
9672
9673 case 9200: hash_type = HASH_TYPE_SHA256;
9674 salt_type = SALT_TYPE_EMBEDDED;
9675 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9676 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9677 kern_type = KERN_TYPE_PBKDF2_SHA256;
9678 dgst_size = DGST_SIZE_4_32;
9679 parse_func = cisco8_parse_hash;
9680 sort_by_digest = sort_by_digest_4_32;
9681 opti_type = OPTI_TYPE_ZERO_BYTE
9682 | OPTI_TYPE_SLOW_HASH_SIMD;
9683 dgst_pos0 = 0;
9684 dgst_pos1 = 1;
9685 dgst_pos2 = 2;
9686 dgst_pos3 = 3;
9687 break;
9688
9689 case 9300: hash_type = HASH_TYPE_SCRYPT;
9690 salt_type = SALT_TYPE_EMBEDDED;
9691 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9692 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9693 kern_type = KERN_TYPE_SCRYPT;
9694 dgst_size = DGST_SIZE_4_8;
9695 parse_func = cisco9_parse_hash;
9696 sort_by_digest = sort_by_digest_4_8;
9697 opti_type = OPTI_TYPE_ZERO_BYTE;
9698 dgst_pos0 = 0;
9699 dgst_pos1 = 1;
9700 dgst_pos2 = 2;
9701 dgst_pos3 = 3;
9702 break;
9703
9704 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9705 salt_type = SALT_TYPE_EMBEDDED;
9706 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9707 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9708 kern_type = KERN_TYPE_OFFICE2007;
9709 dgst_size = DGST_SIZE_4_4;
9710 parse_func = office2007_parse_hash;
9711 sort_by_digest = sort_by_digest_4_4;
9712 opti_type = OPTI_TYPE_ZERO_BYTE;
9713 dgst_pos0 = 0;
9714 dgst_pos1 = 1;
9715 dgst_pos2 = 2;
9716 dgst_pos3 = 3;
9717 break;
9718
9719 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9720 salt_type = SALT_TYPE_EMBEDDED;
9721 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9722 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9723 kern_type = KERN_TYPE_OFFICE2010;
9724 dgst_size = DGST_SIZE_4_4;
9725 parse_func = office2010_parse_hash;
9726 sort_by_digest = sort_by_digest_4_4;
9727 opti_type = OPTI_TYPE_ZERO_BYTE;
9728 dgst_pos0 = 0;
9729 dgst_pos1 = 1;
9730 dgst_pos2 = 2;
9731 dgst_pos3 = 3;
9732 break;
9733
9734 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9735 salt_type = SALT_TYPE_EMBEDDED;
9736 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9737 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9738 kern_type = KERN_TYPE_OFFICE2013;
9739 dgst_size = DGST_SIZE_4_4;
9740 parse_func = office2013_parse_hash;
9741 sort_by_digest = sort_by_digest_4_4;
9742 opti_type = OPTI_TYPE_ZERO_BYTE;
9743 dgst_pos0 = 0;
9744 dgst_pos1 = 1;
9745 dgst_pos2 = 2;
9746 dgst_pos3 = 3;
9747 break;
9748
9749 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9750 salt_type = SALT_TYPE_EMBEDDED;
9751 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9752 opts_type = OPTS_TYPE_PT_GENERATE_LE
9753 | OPTS_TYPE_PT_ADD80
9754 | OPTS_TYPE_PT_UNICODE;
9755 kern_type = KERN_TYPE_OLDOFFICE01;
9756 dgst_size = DGST_SIZE_4_4;
9757 parse_func = oldoffice01_parse_hash;
9758 sort_by_digest = sort_by_digest_4_4;
9759 opti_type = OPTI_TYPE_ZERO_BYTE
9760 | OPTI_TYPE_PRECOMPUTE_INIT
9761 | OPTI_TYPE_NOT_ITERATED;
9762 dgst_pos0 = 0;
9763 dgst_pos1 = 1;
9764 dgst_pos2 = 2;
9765 dgst_pos3 = 3;
9766 break;
9767
9768 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9769 salt_type = SALT_TYPE_EMBEDDED;
9770 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9771 opts_type = OPTS_TYPE_PT_GENERATE_LE
9772 | OPTS_TYPE_PT_ADD80;
9773 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9774 dgst_size = DGST_SIZE_4_4;
9775 parse_func = oldoffice01cm1_parse_hash;
9776 sort_by_digest = sort_by_digest_4_4;
9777 opti_type = OPTI_TYPE_ZERO_BYTE
9778 | OPTI_TYPE_PRECOMPUTE_INIT
9779 | OPTI_TYPE_NOT_ITERATED;
9780 dgst_pos0 = 0;
9781 dgst_pos1 = 1;
9782 dgst_pos2 = 2;
9783 dgst_pos3 = 3;
9784 break;
9785
9786 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9787 salt_type = SALT_TYPE_EMBEDDED;
9788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9789 opts_type = OPTS_TYPE_PT_GENERATE_LE
9790 | OPTS_TYPE_PT_ADD80
9791 | OPTS_TYPE_PT_UNICODE
9792 | OPTS_TYPE_PT_NEVERCRACK;
9793 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9794 dgst_size = DGST_SIZE_4_4;
9795 parse_func = oldoffice01cm2_parse_hash;
9796 sort_by_digest = sort_by_digest_4_4;
9797 opti_type = OPTI_TYPE_ZERO_BYTE
9798 | OPTI_TYPE_PRECOMPUTE_INIT
9799 | OPTI_TYPE_NOT_ITERATED;
9800 dgst_pos0 = 0;
9801 dgst_pos1 = 1;
9802 dgst_pos2 = 2;
9803 dgst_pos3 = 3;
9804 break;
9805
9806 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9807 salt_type = SALT_TYPE_EMBEDDED;
9808 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9809 opts_type = OPTS_TYPE_PT_GENERATE_BE
9810 | OPTS_TYPE_PT_ADD80
9811 | OPTS_TYPE_PT_UNICODE;
9812 kern_type = KERN_TYPE_OLDOFFICE34;
9813 dgst_size = DGST_SIZE_4_4;
9814 parse_func = oldoffice34_parse_hash;
9815 sort_by_digest = sort_by_digest_4_4;
9816 opti_type = OPTI_TYPE_ZERO_BYTE
9817 | OPTI_TYPE_PRECOMPUTE_INIT
9818 | OPTI_TYPE_NOT_ITERATED;
9819 dgst_pos0 = 0;
9820 dgst_pos1 = 1;
9821 dgst_pos2 = 2;
9822 dgst_pos3 = 3;
9823 break;
9824
9825 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9826 salt_type = SALT_TYPE_EMBEDDED;
9827 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9828 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9829 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9830 dgst_size = DGST_SIZE_4_4;
9831 parse_func = oldoffice34cm1_parse_hash;
9832 sort_by_digest = sort_by_digest_4_4;
9833 opti_type = OPTI_TYPE_ZERO_BYTE
9834 | OPTI_TYPE_PRECOMPUTE_INIT
9835 | OPTI_TYPE_NOT_ITERATED;
9836 dgst_pos0 = 0;
9837 dgst_pos1 = 1;
9838 dgst_pos2 = 2;
9839 dgst_pos3 = 3;
9840 break;
9841
9842 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9843 salt_type = SALT_TYPE_EMBEDDED;
9844 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9845 opts_type = OPTS_TYPE_PT_GENERATE_BE
9846 | OPTS_TYPE_PT_ADD80
9847 | OPTS_TYPE_PT_UNICODE
9848 | OPTS_TYPE_PT_NEVERCRACK;
9849 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9850 dgst_size = DGST_SIZE_4_4;
9851 parse_func = oldoffice34cm2_parse_hash;
9852 sort_by_digest = sort_by_digest_4_4;
9853 opti_type = OPTI_TYPE_ZERO_BYTE
9854 | OPTI_TYPE_PRECOMPUTE_INIT
9855 | OPTI_TYPE_NOT_ITERATED;
9856 dgst_pos0 = 0;
9857 dgst_pos1 = 1;
9858 dgst_pos2 = 2;
9859 dgst_pos3 = 3;
9860 break;
9861
9862 case 9900: hash_type = HASH_TYPE_MD5;
9863 salt_type = SALT_TYPE_NONE;
9864 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9865 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9866 kern_type = KERN_TYPE_RADMIN2;
9867 dgst_size = DGST_SIZE_4_4;
9868 parse_func = radmin2_parse_hash;
9869 sort_by_digest = sort_by_digest_4_4;
9870 opti_type = OPTI_TYPE_ZERO_BYTE
9871 | OPTI_TYPE_PRECOMPUTE_INIT
9872 | OPTI_TYPE_EARLY_SKIP
9873 | OPTI_TYPE_NOT_ITERATED
9874 | OPTI_TYPE_NOT_SALTED;
9875 dgst_pos0 = 0;
9876 dgst_pos1 = 3;
9877 dgst_pos2 = 2;
9878 dgst_pos3 = 1;
9879 break;
9880
9881 case 10000: hash_type = HASH_TYPE_SHA256;
9882 salt_type = SALT_TYPE_EMBEDDED;
9883 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9884 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9885 kern_type = KERN_TYPE_PBKDF2_SHA256;
9886 dgst_size = DGST_SIZE_4_32;
9887 parse_func = djangopbkdf2_parse_hash;
9888 sort_by_digest = sort_by_digest_4_32;
9889 opti_type = OPTI_TYPE_ZERO_BYTE
9890 | OPTI_TYPE_SLOW_HASH_SIMD;
9891 dgst_pos0 = 0;
9892 dgst_pos1 = 1;
9893 dgst_pos2 = 2;
9894 dgst_pos3 = 3;
9895 break;
9896
9897 case 10100: hash_type = HASH_TYPE_SIPHASH;
9898 salt_type = SALT_TYPE_EMBEDDED;
9899 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9900 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9901 kern_type = KERN_TYPE_SIPHASH;
9902 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9903 parse_func = siphash_parse_hash;
9904 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9905 opti_type = OPTI_TYPE_ZERO_BYTE
9906 | OPTI_TYPE_NOT_ITERATED
9907 | OPTI_TYPE_RAW_HASH;
9908 dgst_pos0 = 0;
9909 dgst_pos1 = 1;
9910 dgst_pos2 = 2;
9911 dgst_pos3 = 3;
9912 break;
9913
9914 case 10200: hash_type = HASH_TYPE_MD5;
9915 salt_type = SALT_TYPE_EMBEDDED;
9916 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9917 opts_type = OPTS_TYPE_PT_GENERATE_LE
9918 | OPTS_TYPE_ST_ADD80
9919 | OPTS_TYPE_ST_ADDBITS14;
9920 kern_type = KERN_TYPE_HMACMD5_PW;
9921 dgst_size = DGST_SIZE_4_4;
9922 parse_func = crammd5_parse_hash;
9923 sort_by_digest = sort_by_digest_4_4;
9924 opti_type = OPTI_TYPE_ZERO_BYTE
9925 | OPTI_TYPE_NOT_ITERATED;
9926 dgst_pos0 = 0;
9927 dgst_pos1 = 3;
9928 dgst_pos2 = 2;
9929 dgst_pos3 = 1;
9930 break;
9931
9932 case 10300: hash_type = HASH_TYPE_SHA1;
9933 salt_type = SALT_TYPE_EMBEDDED;
9934 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9935 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9936 kern_type = KERN_TYPE_SAPH_SHA1;
9937 dgst_size = DGST_SIZE_4_5;
9938 parse_func = saph_sha1_parse_hash;
9939 sort_by_digest = sort_by_digest_4_5;
9940 opti_type = OPTI_TYPE_ZERO_BYTE;
9941 dgst_pos0 = 0;
9942 dgst_pos1 = 1;
9943 dgst_pos2 = 2;
9944 dgst_pos3 = 3;
9945 break;
9946
9947 case 10400: hash_type = HASH_TYPE_PDFU16;
9948 salt_type = SALT_TYPE_EMBEDDED;
9949 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9950 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9951 kern_type = KERN_TYPE_PDF11;
9952 dgst_size = DGST_SIZE_4_4;
9953 parse_func = pdf11_parse_hash;
9954 sort_by_digest = sort_by_digest_4_4;
9955 opti_type = OPTI_TYPE_ZERO_BYTE
9956 | OPTI_TYPE_NOT_ITERATED;
9957 dgst_pos0 = 0;
9958 dgst_pos1 = 1;
9959 dgst_pos2 = 2;
9960 dgst_pos3 = 3;
9961 break;
9962
9963 case 10410: hash_type = HASH_TYPE_PDFU16;
9964 salt_type = SALT_TYPE_EMBEDDED;
9965 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9966 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9967 kern_type = KERN_TYPE_PDF11CM1;
9968 dgst_size = DGST_SIZE_4_4;
9969 parse_func = pdf11cm1_parse_hash;
9970 sort_by_digest = sort_by_digest_4_4;
9971 opti_type = OPTI_TYPE_ZERO_BYTE
9972 | OPTI_TYPE_NOT_ITERATED;
9973 dgst_pos0 = 0;
9974 dgst_pos1 = 1;
9975 dgst_pos2 = 2;
9976 dgst_pos3 = 3;
9977 break;
9978
9979 case 10420: hash_type = HASH_TYPE_PDFU16;
9980 salt_type = SALT_TYPE_EMBEDDED;
9981 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9982 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9983 kern_type = KERN_TYPE_PDF11CM2;
9984 dgst_size = DGST_SIZE_4_4;
9985 parse_func = pdf11cm2_parse_hash;
9986 sort_by_digest = sort_by_digest_4_4;
9987 opti_type = OPTI_TYPE_ZERO_BYTE
9988 | OPTI_TYPE_NOT_ITERATED;
9989 dgst_pos0 = 0;
9990 dgst_pos1 = 1;
9991 dgst_pos2 = 2;
9992 dgst_pos3 = 3;
9993 break;
9994
9995 case 10500: hash_type = HASH_TYPE_PDFU16;
9996 salt_type = SALT_TYPE_EMBEDDED;
9997 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9998 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9999 kern_type = KERN_TYPE_PDF14;
10000 dgst_size = DGST_SIZE_4_4;
10001 parse_func = pdf14_parse_hash;
10002 sort_by_digest = sort_by_digest_4_4;
10003 opti_type = OPTI_TYPE_ZERO_BYTE
10004 | OPTI_TYPE_NOT_ITERATED;
10005 dgst_pos0 = 0;
10006 dgst_pos1 = 1;
10007 dgst_pos2 = 2;
10008 dgst_pos3 = 3;
10009 break;
10010
10011 case 10600: hash_type = HASH_TYPE_SHA256;
10012 salt_type = SALT_TYPE_EMBEDDED;
10013 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10014 opts_type = OPTS_TYPE_PT_GENERATE_BE
10015 | OPTS_TYPE_ST_ADD80
10016 | OPTS_TYPE_ST_ADDBITS15
10017 | OPTS_TYPE_HASH_COPY;
10018 kern_type = KERN_TYPE_SHA256_PWSLT;
10019 dgst_size = DGST_SIZE_4_8;
10020 parse_func = pdf17l3_parse_hash;
10021 sort_by_digest = sort_by_digest_4_8;
10022 opti_type = OPTI_TYPE_ZERO_BYTE
10023 | OPTI_TYPE_PRECOMPUTE_INIT
10024 | OPTI_TYPE_PRECOMPUTE_MERKLE
10025 | OPTI_TYPE_EARLY_SKIP
10026 | OPTI_TYPE_NOT_ITERATED
10027 | OPTI_TYPE_APPENDED_SALT
10028 | OPTI_TYPE_RAW_HASH;
10029 dgst_pos0 = 3;
10030 dgst_pos1 = 7;
10031 dgst_pos2 = 2;
10032 dgst_pos3 = 6;
10033 break;
10034
10035 case 10700: hash_type = HASH_TYPE_PDFU32;
10036 salt_type = SALT_TYPE_EMBEDDED;
10037 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10038 opts_type = OPTS_TYPE_PT_GENERATE_LE
10039 | OPTS_TYPE_HASH_COPY;
10040 kern_type = KERN_TYPE_PDF17L8;
10041 dgst_size = DGST_SIZE_4_8;
10042 parse_func = pdf17l8_parse_hash;
10043 sort_by_digest = sort_by_digest_4_8;
10044 opti_type = OPTI_TYPE_ZERO_BYTE
10045 | OPTI_TYPE_NOT_ITERATED;
10046 dgst_pos0 = 0;
10047 dgst_pos1 = 1;
10048 dgst_pos2 = 2;
10049 dgst_pos3 = 3;
10050 break;
10051
10052 case 10800: hash_type = HASH_TYPE_SHA384;
10053 salt_type = SALT_TYPE_NONE;
10054 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10055 opts_type = OPTS_TYPE_PT_GENERATE_BE
10056 | OPTS_TYPE_PT_ADD80
10057 | OPTS_TYPE_PT_ADDBITS15;
10058 kern_type = KERN_TYPE_SHA384;
10059 dgst_size = DGST_SIZE_8_8;
10060 parse_func = sha384_parse_hash;
10061 sort_by_digest = sort_by_digest_8_8;
10062 opti_type = OPTI_TYPE_ZERO_BYTE
10063 | OPTI_TYPE_PRECOMPUTE_INIT
10064 | OPTI_TYPE_PRECOMPUTE_MERKLE
10065 | OPTI_TYPE_EARLY_SKIP
10066 | OPTI_TYPE_NOT_ITERATED
10067 | OPTI_TYPE_NOT_SALTED
10068 | OPTI_TYPE_USES_BITS_64
10069 | OPTI_TYPE_RAW_HASH;
10070 dgst_pos0 = 6;
10071 dgst_pos1 = 7;
10072 dgst_pos2 = 4;
10073 dgst_pos3 = 5;
10074 break;
10075
10076 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10077 salt_type = SALT_TYPE_EMBEDDED;
10078 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10079 opts_type = OPTS_TYPE_PT_GENERATE_LE
10080 | OPTS_TYPE_ST_BASE64
10081 | OPTS_TYPE_HASH_COPY;
10082 kern_type = KERN_TYPE_PBKDF2_SHA256;
10083 dgst_size = DGST_SIZE_4_32;
10084 parse_func = pbkdf2_sha256_parse_hash;
10085 sort_by_digest = sort_by_digest_4_32;
10086 opti_type = OPTI_TYPE_ZERO_BYTE
10087 | OPTI_TYPE_SLOW_HASH_SIMD;
10088 dgst_pos0 = 0;
10089 dgst_pos1 = 1;
10090 dgst_pos2 = 2;
10091 dgst_pos3 = 3;
10092 break;
10093
10094 case 11000: hash_type = HASH_TYPE_MD5;
10095 salt_type = SALT_TYPE_INTERN;
10096 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10097 opts_type = OPTS_TYPE_PT_GENERATE_LE
10098 | OPTS_TYPE_PT_ADD80;
10099 kern_type = KERN_TYPE_PRESTASHOP;
10100 dgst_size = DGST_SIZE_4_4;
10101 parse_func = prestashop_parse_hash;
10102 sort_by_digest = sort_by_digest_4_4;
10103 opti_type = OPTI_TYPE_ZERO_BYTE
10104 | OPTI_TYPE_PRECOMPUTE_INIT
10105 | OPTI_TYPE_NOT_ITERATED
10106 | OPTI_TYPE_PREPENDED_SALT;
10107 dgst_pos0 = 0;
10108 dgst_pos1 = 3;
10109 dgst_pos2 = 2;
10110 dgst_pos3 = 1;
10111 break;
10112
10113 case 11100: hash_type = HASH_TYPE_MD5;
10114 salt_type = SALT_TYPE_EMBEDDED;
10115 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10116 opts_type = OPTS_TYPE_PT_GENERATE_LE
10117 | OPTS_TYPE_ST_ADD80;
10118 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10119 dgst_size = DGST_SIZE_4_4;
10120 parse_func = postgresql_auth_parse_hash;
10121 sort_by_digest = sort_by_digest_4_4;
10122 opti_type = OPTI_TYPE_ZERO_BYTE
10123 | OPTI_TYPE_PRECOMPUTE_INIT
10124 | OPTI_TYPE_PRECOMPUTE_MERKLE
10125 | OPTI_TYPE_EARLY_SKIP;
10126 dgst_pos0 = 0;
10127 dgst_pos1 = 3;
10128 dgst_pos2 = 2;
10129 dgst_pos3 = 1;
10130 break;
10131
10132 case 11200: hash_type = HASH_TYPE_SHA1;
10133 salt_type = SALT_TYPE_EMBEDDED;
10134 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10135 opts_type = OPTS_TYPE_PT_GENERATE_BE
10136 | OPTS_TYPE_PT_ADD80
10137 | OPTS_TYPE_ST_HEX;
10138 kern_type = KERN_TYPE_MYSQL_AUTH;
10139 dgst_size = DGST_SIZE_4_5;
10140 parse_func = mysql_auth_parse_hash;
10141 sort_by_digest = sort_by_digest_4_5;
10142 opti_type = OPTI_TYPE_ZERO_BYTE
10143 | OPTI_TYPE_EARLY_SKIP;
10144 dgst_pos0 = 3;
10145 dgst_pos1 = 4;
10146 dgst_pos2 = 2;
10147 dgst_pos3 = 1;
10148 break;
10149
10150 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10151 salt_type = SALT_TYPE_EMBEDDED;
10152 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10153 opts_type = OPTS_TYPE_PT_GENERATE_LE
10154 | OPTS_TYPE_ST_HEX
10155 | OPTS_TYPE_ST_ADD80;
10156 kern_type = KERN_TYPE_BITCOIN_WALLET;
10157 dgst_size = DGST_SIZE_4_4;
10158 parse_func = bitcoin_wallet_parse_hash;
10159 sort_by_digest = sort_by_digest_4_4;
10160 opti_type = OPTI_TYPE_ZERO_BYTE;
10161 dgst_pos0 = 0;
10162 dgst_pos1 = 1;
10163 dgst_pos2 = 2;
10164 dgst_pos3 = 3;
10165 break;
10166
10167 case 11400: hash_type = HASH_TYPE_MD5;
10168 salt_type = SALT_TYPE_EMBEDDED;
10169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10170 opts_type = OPTS_TYPE_PT_GENERATE_LE
10171 | OPTS_TYPE_PT_ADD80
10172 | OPTS_TYPE_HASH_COPY;
10173 kern_type = KERN_TYPE_SIP_AUTH;
10174 dgst_size = DGST_SIZE_4_4;
10175 parse_func = sip_auth_parse_hash;
10176 sort_by_digest = sort_by_digest_4_4;
10177 opti_type = OPTI_TYPE_ZERO_BYTE;
10178 dgst_pos0 = 0;
10179 dgst_pos1 = 3;
10180 dgst_pos2 = 2;
10181 dgst_pos3 = 1;
10182 break;
10183
10184 case 11500: hash_type = HASH_TYPE_CRC32;
10185 salt_type = SALT_TYPE_INTERN;
10186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10187 opts_type = OPTS_TYPE_PT_GENERATE_LE
10188 | OPTS_TYPE_ST_GENERATE_LE
10189 | OPTS_TYPE_ST_HEX;
10190 kern_type = KERN_TYPE_CRC32;
10191 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10192 parse_func = crc32_parse_hash;
10193 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10194 opti_type = OPTI_TYPE_ZERO_BYTE;
10195 dgst_pos0 = 0;
10196 dgst_pos1 = 1;
10197 dgst_pos2 = 2;
10198 dgst_pos3 = 3;
10199 break;
10200
10201 case 11600: hash_type = HASH_TYPE_AES;
10202 salt_type = SALT_TYPE_EMBEDDED;
10203 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10204 opts_type = OPTS_TYPE_PT_GENERATE_LE
10205 | OPTS_TYPE_PT_NEVERCRACK;
10206 kern_type = KERN_TYPE_SEVEN_ZIP;
10207 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10208 parse_func = seven_zip_parse_hash;
10209 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10210 opti_type = OPTI_TYPE_ZERO_BYTE;
10211 dgst_pos0 = 0;
10212 dgst_pos1 = 1;
10213 dgst_pos2 = 2;
10214 dgst_pos3 = 3;
10215 break;
10216
10217 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10218 salt_type = SALT_TYPE_NONE;
10219 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10220 opts_type = OPTS_TYPE_PT_GENERATE_LE
10221 | OPTS_TYPE_PT_ADD01;
10222 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10223 dgst_size = DGST_SIZE_4_8;
10224 parse_func = gost2012sbog_256_parse_hash;
10225 sort_by_digest = sort_by_digest_4_8;
10226 opti_type = OPTI_TYPE_ZERO_BYTE;
10227 dgst_pos0 = 0;
10228 dgst_pos1 = 1;
10229 dgst_pos2 = 2;
10230 dgst_pos3 = 3;
10231 break;
10232
10233 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10234 salt_type = SALT_TYPE_NONE;
10235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10236 opts_type = OPTS_TYPE_PT_GENERATE_LE
10237 | OPTS_TYPE_PT_ADD01;
10238 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10239 dgst_size = DGST_SIZE_4_16;
10240 parse_func = gost2012sbog_512_parse_hash;
10241 sort_by_digest = sort_by_digest_4_16;
10242 opti_type = OPTI_TYPE_ZERO_BYTE;
10243 dgst_pos0 = 0;
10244 dgst_pos1 = 1;
10245 dgst_pos2 = 2;
10246 dgst_pos3 = 3;
10247 break;
10248
10249 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10250 salt_type = SALT_TYPE_EMBEDDED;
10251 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10252 opts_type = OPTS_TYPE_PT_GENERATE_LE
10253 | OPTS_TYPE_ST_BASE64
10254 | OPTS_TYPE_HASH_COPY;
10255 kern_type = KERN_TYPE_PBKDF2_MD5;
10256 dgst_size = DGST_SIZE_4_32;
10257 parse_func = pbkdf2_md5_parse_hash;
10258 sort_by_digest = sort_by_digest_4_32;
10259 opti_type = OPTI_TYPE_ZERO_BYTE
10260 | OPTI_TYPE_SLOW_HASH_SIMD;
10261 dgst_pos0 = 0;
10262 dgst_pos1 = 1;
10263 dgst_pos2 = 2;
10264 dgst_pos3 = 3;
10265 break;
10266
10267 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10268 salt_type = SALT_TYPE_EMBEDDED;
10269 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10270 opts_type = OPTS_TYPE_PT_GENERATE_LE
10271 | OPTS_TYPE_ST_BASE64
10272 | OPTS_TYPE_HASH_COPY;
10273 kern_type = KERN_TYPE_PBKDF2_SHA1;
10274 dgst_size = DGST_SIZE_4_32;
10275 parse_func = pbkdf2_sha1_parse_hash;
10276 sort_by_digest = sort_by_digest_4_32;
10277 opti_type = OPTI_TYPE_ZERO_BYTE
10278 | OPTI_TYPE_SLOW_HASH_SIMD;
10279 dgst_pos0 = 0;
10280 dgst_pos1 = 1;
10281 dgst_pos2 = 2;
10282 dgst_pos3 = 3;
10283 break;
10284
10285 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10286 salt_type = SALT_TYPE_EMBEDDED;
10287 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10288 opts_type = OPTS_TYPE_PT_GENERATE_LE
10289 | OPTS_TYPE_ST_BASE64
10290 | OPTS_TYPE_HASH_COPY;
10291 kern_type = KERN_TYPE_PBKDF2_SHA512;
10292 dgst_size = DGST_SIZE_8_16;
10293 parse_func = pbkdf2_sha512_parse_hash;
10294 sort_by_digest = sort_by_digest_8_16;
10295 opti_type = OPTI_TYPE_ZERO_BYTE
10296 | OPTI_TYPE_USES_BITS_64
10297 | OPTI_TYPE_SLOW_HASH_SIMD;
10298 dgst_pos0 = 0;
10299 dgst_pos1 = 1;
10300 dgst_pos2 = 2;
10301 dgst_pos3 = 3;
10302 break;
10303
10304 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10305 salt_type = SALT_TYPE_EMBEDDED;
10306 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10307 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10308 kern_type = KERN_TYPE_ECRYPTFS;
10309 dgst_size = DGST_SIZE_8_8;
10310 parse_func = ecryptfs_parse_hash;
10311 sort_by_digest = sort_by_digest_8_8;
10312 opti_type = OPTI_TYPE_ZERO_BYTE
10313 | OPTI_TYPE_USES_BITS_64;
10314 dgst_pos0 = 0;
10315 dgst_pos1 = 1;
10316 dgst_pos2 = 2;
10317 dgst_pos3 = 3;
10318 break;
10319
10320 case 12300: hash_type = HASH_TYPE_ORACLET;
10321 salt_type = SALT_TYPE_EMBEDDED;
10322 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10323 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10324 kern_type = KERN_TYPE_ORACLET;
10325 dgst_size = DGST_SIZE_8_16;
10326 parse_func = oraclet_parse_hash;
10327 sort_by_digest = sort_by_digest_8_16;
10328 opti_type = OPTI_TYPE_ZERO_BYTE
10329 | OPTI_TYPE_USES_BITS_64;
10330 dgst_pos0 = 0;
10331 dgst_pos1 = 1;
10332 dgst_pos2 = 2;
10333 dgst_pos3 = 3;
10334 break;
10335
10336 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10337 salt_type = SALT_TYPE_EMBEDDED;
10338 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10339 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10340 kern_type = KERN_TYPE_BSDICRYPT;
10341 dgst_size = DGST_SIZE_4_4;
10342 parse_func = bsdicrypt_parse_hash;
10343 sort_by_digest = sort_by_digest_4_4;
10344 opti_type = OPTI_TYPE_ZERO_BYTE
10345 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10346 dgst_pos0 = 0;
10347 dgst_pos1 = 1;
10348 dgst_pos2 = 2;
10349 dgst_pos3 = 3;
10350 break;
10351
10352 case 12500: hash_type = HASH_TYPE_RAR3HP;
10353 salt_type = SALT_TYPE_EMBEDDED;
10354 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10355 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10356 kern_type = KERN_TYPE_RAR3;
10357 dgst_size = DGST_SIZE_4_4;
10358 parse_func = rar3hp_parse_hash;
10359 sort_by_digest = sort_by_digest_4_4;
10360 opti_type = OPTI_TYPE_ZERO_BYTE;
10361 dgst_pos0 = 0;
10362 dgst_pos1 = 1;
10363 dgst_pos2 = 2;
10364 dgst_pos3 = 3;
10365 break;
10366
10367 case 12600: hash_type = HASH_TYPE_SHA256;
10368 salt_type = SALT_TYPE_INTERN;
10369 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10370 opts_type = OPTS_TYPE_PT_GENERATE_BE
10371 | OPTS_TYPE_PT_ADD80;
10372 kern_type = KERN_TYPE_CF10;
10373 dgst_size = DGST_SIZE_4_8;
10374 parse_func = cf10_parse_hash;
10375 sort_by_digest = sort_by_digest_4_8;
10376 opti_type = OPTI_TYPE_ZERO_BYTE
10377 | OPTI_TYPE_PRECOMPUTE_INIT
10378 | OPTI_TYPE_EARLY_SKIP
10379 | OPTI_TYPE_NOT_ITERATED;
10380 dgst_pos0 = 3;
10381 dgst_pos1 = 7;
10382 dgst_pos2 = 2;
10383 dgst_pos3 = 6;
10384 break;
10385
10386 case 12700: hash_type = HASH_TYPE_AES;
10387 salt_type = SALT_TYPE_EMBEDDED;
10388 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10389 opts_type = OPTS_TYPE_PT_GENERATE_LE
10390 | OPTS_TYPE_HASH_COPY;
10391 kern_type = KERN_TYPE_MYWALLET;
10392 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10393 parse_func = mywallet_parse_hash;
10394 sort_by_digest = sort_by_digest_4_5;
10395 opti_type = OPTI_TYPE_ZERO_BYTE;
10396 dgst_pos0 = 0;
10397 dgst_pos1 = 1;
10398 dgst_pos2 = 2;
10399 dgst_pos3 = 3;
10400 break;
10401
10402 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10403 salt_type = SALT_TYPE_EMBEDDED;
10404 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10405 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10406 kern_type = KERN_TYPE_MS_DRSR;
10407 dgst_size = DGST_SIZE_4_8;
10408 parse_func = ms_drsr_parse_hash;
10409 sort_by_digest = sort_by_digest_4_8;
10410 opti_type = OPTI_TYPE_ZERO_BYTE;
10411 dgst_pos0 = 0;
10412 dgst_pos1 = 1;
10413 dgst_pos2 = 2;
10414 dgst_pos3 = 3;
10415 break;
10416
10417 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10418 salt_type = SALT_TYPE_EMBEDDED;
10419 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10420 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10421 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10422 dgst_size = DGST_SIZE_4_8;
10423 parse_func = androidfde_samsung_parse_hash;
10424 sort_by_digest = sort_by_digest_4_8;
10425 opti_type = OPTI_TYPE_ZERO_BYTE;
10426 dgst_pos0 = 0;
10427 dgst_pos1 = 1;
10428 dgst_pos2 = 2;
10429 dgst_pos3 = 3;
10430 break;
10431
10432 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10433 salt_type = SALT_TYPE_EMBEDDED;
10434 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10435 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10436 kern_type = KERN_TYPE_RAR5;
10437 dgst_size = DGST_SIZE_4_4;
10438 parse_func = rar5_parse_hash;
10439 sort_by_digest = sort_by_digest_4_4;
10440 opti_type = OPTI_TYPE_ZERO_BYTE;
10441 dgst_pos0 = 0;
10442 dgst_pos1 = 1;
10443 dgst_pos2 = 2;
10444 dgst_pos3 = 3;
10445 break;
10446
10447 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10448 salt_type = SALT_TYPE_EMBEDDED;
10449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10450 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10451 kern_type = KERN_TYPE_KRB5TGS;
10452 dgst_size = DGST_SIZE_4_4;
10453 parse_func = krb5tgs_parse_hash;
10454 sort_by_digest = sort_by_digest_4_4;
10455 opti_type = OPTI_TYPE_ZERO_BYTE
10456 | OPTI_TYPE_NOT_ITERATED;
10457 dgst_pos0 = 0;
10458 dgst_pos1 = 1;
10459 dgst_pos2 = 2;
10460 dgst_pos3 = 3;
10461 break;
10462
10463 case 13200: hash_type = HASH_TYPE_AES;
10464 salt_type = SALT_TYPE_EMBEDDED;
10465 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10466 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10467 kern_type = KERN_TYPE_AXCRYPT;
10468 dgst_size = DGST_SIZE_4_4;
10469 parse_func = axcrypt_parse_hash;
10470 sort_by_digest = sort_by_digest_4_4;
10471 opti_type = OPTI_TYPE_ZERO_BYTE;
10472 dgst_pos0 = 0;
10473 dgst_pos1 = 1;
10474 dgst_pos2 = 2;
10475 dgst_pos3 = 3;
10476 break;
10477
10478 case 13300: hash_type = HASH_TYPE_SHA1;
10479 salt_type = SALT_TYPE_NONE;
10480 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10481 opts_type = OPTS_TYPE_PT_GENERATE_BE
10482 | OPTS_TYPE_PT_ADD80
10483 | OPTS_TYPE_PT_ADDBITS15;
10484 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10485 dgst_size = DGST_SIZE_4_5;
10486 parse_func = sha1axcrypt_parse_hash;
10487 sort_by_digest = sort_by_digest_4_5;
10488 opti_type = OPTI_TYPE_ZERO_BYTE
10489 | OPTI_TYPE_PRECOMPUTE_INIT
10490 | OPTI_TYPE_EARLY_SKIP
10491 | OPTI_TYPE_NOT_ITERATED
10492 | OPTI_TYPE_NOT_SALTED;
10493 dgst_pos0 = 0;
10494 dgst_pos1 = 4;
10495 dgst_pos2 = 3;
10496 dgst_pos3 = 2;
10497 break;
10498
10499 case 13400: hash_type = HASH_TYPE_AES;
10500 salt_type = SALT_TYPE_EMBEDDED;
10501 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10502 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10503 kern_type = KERN_TYPE_KEEPASS;
10504 dgst_size = DGST_SIZE_4_4;
10505 parse_func = keepass_parse_hash;
10506 sort_by_digest = sort_by_digest_4_4;
10507 opti_type = OPTI_TYPE_ZERO_BYTE;
10508 dgst_pos0 = 0;
10509 dgst_pos1 = 1;
10510 dgst_pos2 = 2;
10511 dgst_pos3 = 3;
10512 break;
10513
10514 case 13500: hash_type = HASH_TYPE_SHA1;
10515 salt_type = SALT_TYPE_EMBEDDED;
10516 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10517 opts_type = OPTS_TYPE_PT_GENERATE_BE
10518 | OPTS_TYPE_PT_UNICODE
10519 | OPTS_TYPE_PT_ADD80;
10520 kern_type = KERN_TYPE_PSTOKEN;
10521 dgst_size = DGST_SIZE_4_5;
10522 parse_func = pstoken_parse_hash;
10523 sort_by_digest = sort_by_digest_4_5;
10524 opti_type = OPTI_TYPE_ZERO_BYTE
10525 | OPTI_TYPE_PRECOMPUTE_INIT
10526 | OPTI_TYPE_EARLY_SKIP
10527 | OPTI_TYPE_NOT_ITERATED
10528 | OPTI_TYPE_PREPENDED_SALT
10529 | OPTI_TYPE_RAW_HASH;
10530 dgst_pos0 = 3;
10531 dgst_pos1 = 4;
10532 dgst_pos2 = 2;
10533 dgst_pos3 = 1;
10534 break;
10535
10536 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10537 salt_type = SALT_TYPE_EMBEDDED;
10538 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10539 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10540 kern_type = KERN_TYPE_ZIP2;
10541 dgst_size = DGST_SIZE_4_4;
10542 parse_func = zip2_parse_hash;
10543 sort_by_digest = sort_by_digest_4_4;
10544 opti_type = OPTI_TYPE_ZERO_BYTE;
10545 dgst_pos0 = 0;
10546 dgst_pos1 = 1;
10547 dgst_pos2 = 2;
10548 dgst_pos3 = 3;
10549 break;
10550
10551 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10552 salt_type = SALT_TYPE_EMBEDDED;
10553 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10554 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10555 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10556 dgst_size = DGST_SIZE_4_5;
10557 parse_func = veracrypt_parse_hash_655331;
10558 sort_by_digest = sort_by_digest_4_5;
10559 opti_type = OPTI_TYPE_ZERO_BYTE;
10560 dgst_pos0 = 0;
10561 dgst_pos1 = 1;
10562 dgst_pos2 = 2;
10563 dgst_pos3 = 3;
10564 break;
10565
10566 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10567 salt_type = SALT_TYPE_EMBEDDED;
10568 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10569 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10570 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10571 dgst_size = DGST_SIZE_4_5;
10572 parse_func = veracrypt_parse_hash_655331;
10573 sort_by_digest = sort_by_digest_4_5;
10574 opti_type = OPTI_TYPE_ZERO_BYTE;
10575 dgst_pos0 = 0;
10576 dgst_pos1 = 1;
10577 dgst_pos2 = 2;
10578 dgst_pos3 = 3;
10579 break;
10580
10581 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10582 salt_type = SALT_TYPE_EMBEDDED;
10583 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10584 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10585 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10586 dgst_size = DGST_SIZE_4_5;
10587 parse_func = veracrypt_parse_hash_655331;
10588 sort_by_digest = sort_by_digest_4_5;
10589 opti_type = OPTI_TYPE_ZERO_BYTE;
10590 dgst_pos0 = 0;
10591 dgst_pos1 = 1;
10592 dgst_pos2 = 2;
10593 dgst_pos3 = 3;
10594 break;
10595
10596 case 13721: hash_type = HASH_TYPE_SHA512;
10597 salt_type = SALT_TYPE_EMBEDDED;
10598 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10599 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10600 kern_type = KERN_TYPE_TCSHA512_XTS512;
10601 dgst_size = DGST_SIZE_8_8;
10602 parse_func = veracrypt_parse_hash_500000;
10603 sort_by_digest = sort_by_digest_8_8;
10604 opti_type = OPTI_TYPE_ZERO_BYTE
10605 | OPTI_TYPE_USES_BITS_64;
10606 dgst_pos0 = 0;
10607 dgst_pos1 = 1;
10608 dgst_pos2 = 2;
10609 dgst_pos3 = 3;
10610 break;
10611
10612 case 13722: hash_type = HASH_TYPE_SHA512;
10613 salt_type = SALT_TYPE_EMBEDDED;
10614 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10615 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10616 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10617 dgst_size = DGST_SIZE_8_8;
10618 parse_func = veracrypt_parse_hash_500000;
10619 sort_by_digest = sort_by_digest_8_8;
10620 opti_type = OPTI_TYPE_ZERO_BYTE
10621 | OPTI_TYPE_USES_BITS_64;
10622 dgst_pos0 = 0;
10623 dgst_pos1 = 1;
10624 dgst_pos2 = 2;
10625 dgst_pos3 = 3;
10626 break;
10627
10628 case 13723: hash_type = HASH_TYPE_SHA512;
10629 salt_type = SALT_TYPE_EMBEDDED;
10630 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10631 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10632 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10633 dgst_size = DGST_SIZE_8_8;
10634 parse_func = veracrypt_parse_hash_500000;
10635 sort_by_digest = sort_by_digest_8_8;
10636 opti_type = OPTI_TYPE_ZERO_BYTE
10637 | OPTI_TYPE_USES_BITS_64;
10638 dgst_pos0 = 0;
10639 dgst_pos1 = 1;
10640 dgst_pos2 = 2;
10641 dgst_pos3 = 3;
10642 break;
10643
10644 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10645 salt_type = SALT_TYPE_EMBEDDED;
10646 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10647 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10648 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10649 dgst_size = DGST_SIZE_4_8;
10650 parse_func = veracrypt_parse_hash_500000;
10651 sort_by_digest = sort_by_digest_4_8;
10652 opti_type = OPTI_TYPE_ZERO_BYTE;
10653 dgst_pos0 = 0;
10654 dgst_pos1 = 1;
10655 dgst_pos2 = 2;
10656 dgst_pos3 = 3;
10657 break;
10658
10659 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10660 salt_type = SALT_TYPE_EMBEDDED;
10661 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10662 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10663 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10664 dgst_size = DGST_SIZE_4_8;
10665 parse_func = veracrypt_parse_hash_500000;
10666 sort_by_digest = sort_by_digest_4_8;
10667 opti_type = OPTI_TYPE_ZERO_BYTE;
10668 dgst_pos0 = 0;
10669 dgst_pos1 = 1;
10670 dgst_pos2 = 2;
10671 dgst_pos3 = 3;
10672 break;
10673
10674 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10675 salt_type = SALT_TYPE_EMBEDDED;
10676 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10677 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10678 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10679 dgst_size = DGST_SIZE_4_8;
10680 parse_func = veracrypt_parse_hash_500000;
10681 sort_by_digest = sort_by_digest_4_8;
10682 opti_type = OPTI_TYPE_ZERO_BYTE;
10683 dgst_pos0 = 0;
10684 dgst_pos1 = 1;
10685 dgst_pos2 = 2;
10686 dgst_pos3 = 3;
10687 break;
10688
10689 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10690 salt_type = SALT_TYPE_EMBEDDED;
10691 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10692 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10693 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10694 dgst_size = DGST_SIZE_4_5;
10695 parse_func = veracrypt_parse_hash_327661;
10696 sort_by_digest = sort_by_digest_4_5;
10697 opti_type = OPTI_TYPE_ZERO_BYTE;
10698 dgst_pos0 = 0;
10699 dgst_pos1 = 1;
10700 dgst_pos2 = 2;
10701 dgst_pos3 = 3;
10702 break;
10703
10704 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10705 salt_type = SALT_TYPE_EMBEDDED;
10706 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10707 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10708 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10709 dgst_size = DGST_SIZE_4_5;
10710 parse_func = veracrypt_parse_hash_327661;
10711 sort_by_digest = sort_by_digest_4_5;
10712 opti_type = OPTI_TYPE_ZERO_BYTE;
10713 dgst_pos0 = 0;
10714 dgst_pos1 = 1;
10715 dgst_pos2 = 2;
10716 dgst_pos3 = 3;
10717 break;
10718
10719 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10720 salt_type = SALT_TYPE_EMBEDDED;
10721 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10722 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10723 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10724 dgst_size = DGST_SIZE_4_5;
10725 parse_func = veracrypt_parse_hash_327661;
10726 sort_by_digest = sort_by_digest_4_5;
10727 opti_type = OPTI_TYPE_ZERO_BYTE;
10728 dgst_pos0 = 0;
10729 dgst_pos1 = 1;
10730 dgst_pos2 = 2;
10731 dgst_pos3 = 3;
10732 break;
10733
10734 case 13751: hash_type = HASH_TYPE_SHA256;
10735 salt_type = SALT_TYPE_EMBEDDED;
10736 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10737 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10738 kern_type = KERN_TYPE_VCSHA256_XTS512;
10739 dgst_size = DGST_SIZE_4_8;
10740 parse_func = veracrypt_parse_hash_500000;
10741 sort_by_digest = sort_by_digest_4_8;
10742 opti_type = OPTI_TYPE_ZERO_BYTE;
10743 dgst_pos0 = 0;
10744 dgst_pos1 = 1;
10745 dgst_pos2 = 2;
10746 dgst_pos3 = 3;
10747 break;
10748
10749 case 13752: hash_type = HASH_TYPE_SHA256;
10750 salt_type = SALT_TYPE_EMBEDDED;
10751 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10752 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10753 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10754 dgst_size = DGST_SIZE_4_8;
10755 parse_func = veracrypt_parse_hash_500000;
10756 sort_by_digest = sort_by_digest_4_8;
10757 opti_type = OPTI_TYPE_ZERO_BYTE;
10758 dgst_pos0 = 0;
10759 dgst_pos1 = 1;
10760 dgst_pos2 = 2;
10761 dgst_pos3 = 3;
10762 break;
10763
10764 case 13753: hash_type = HASH_TYPE_SHA256;
10765 salt_type = SALT_TYPE_EMBEDDED;
10766 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10767 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10768 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10769 dgst_size = DGST_SIZE_4_8;
10770 parse_func = veracrypt_parse_hash_500000;
10771 sort_by_digest = sort_by_digest_4_8;
10772 opti_type = OPTI_TYPE_ZERO_BYTE;
10773 dgst_pos0 = 0;
10774 dgst_pos1 = 1;
10775 dgst_pos2 = 2;
10776 dgst_pos3 = 3;
10777 break;
10778
10779 case 13761: hash_type = HASH_TYPE_SHA256;
10780 salt_type = SALT_TYPE_EMBEDDED;
10781 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10782 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10783 kern_type = KERN_TYPE_VCSHA256_XTS512;
10784 dgst_size = DGST_SIZE_4_8;
10785 parse_func = veracrypt_parse_hash_200000;
10786 sort_by_digest = sort_by_digest_4_8;
10787 opti_type = OPTI_TYPE_ZERO_BYTE;
10788 dgst_pos0 = 0;
10789 dgst_pos1 = 1;
10790 dgst_pos2 = 2;
10791 dgst_pos3 = 3;
10792 break;
10793
10794 case 13762: hash_type = HASH_TYPE_SHA256;
10795 salt_type = SALT_TYPE_EMBEDDED;
10796 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10797 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10798 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10799 dgst_size = DGST_SIZE_4_8;
10800 parse_func = veracrypt_parse_hash_200000;
10801 sort_by_digest = sort_by_digest_4_8;
10802 opti_type = OPTI_TYPE_ZERO_BYTE;
10803 dgst_pos0 = 0;
10804 dgst_pos1 = 1;
10805 dgst_pos2 = 2;
10806 dgst_pos3 = 3;
10807 break;
10808
10809 case 13763: hash_type = HASH_TYPE_SHA256;
10810 salt_type = SALT_TYPE_EMBEDDED;
10811 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10812 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10813 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10814 dgst_size = DGST_SIZE_4_8;
10815 parse_func = veracrypt_parse_hash_200000;
10816 sort_by_digest = sort_by_digest_4_8;
10817 opti_type = OPTI_TYPE_ZERO_BYTE;
10818 dgst_pos0 = 0;
10819 dgst_pos1 = 1;
10820 dgst_pos2 = 2;
10821 dgst_pos3 = 3;
10822 break;
10823
10824 case 13800: hash_type = HASH_TYPE_SHA256;
10825 salt_type = SALT_TYPE_EMBEDDED;
10826 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10827 opts_type = OPTS_TYPE_PT_GENERATE_BE
10828 | OPTS_TYPE_PT_UNICODE;
10829 kern_type = KERN_TYPE_WIN8PHONE;
10830 dgst_size = DGST_SIZE_4_8;
10831 parse_func = win8phone_parse_hash;
10832 sort_by_digest = sort_by_digest_4_8;
10833 opti_type = OPTI_TYPE_ZERO_BYTE
10834 | OPTI_TYPE_PRECOMPUTE_INIT
10835 | OPTI_TYPE_EARLY_SKIP
10836 | OPTI_TYPE_NOT_ITERATED
10837 | OPTI_TYPE_RAW_HASH;
10838 dgst_pos0 = 3;
10839 dgst_pos1 = 7;
10840 dgst_pos2 = 2;
10841 dgst_pos3 = 6;
10842 break;
10843
10844
10845 default: usage_mini_print (PROGNAME); return (-1);
10846 }
10847
10848 /**
10849 * parser
10850 */
10851
10852 data.parse_func = parse_func;
10853
10854 /**
10855 * misc stuff
10856 */
10857
10858 if (hex_salt)
10859 {
10860 if (salt_type == SALT_TYPE_INTERN)
10861 {
10862 opts_type |= OPTS_TYPE_ST_HEX;
10863 }
10864 else
10865 {
10866 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10867
10868 return (-1);
10869 }
10870 }
10871
10872 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10873 | (salt_type == SALT_TYPE_EXTERN)
10874 | (salt_type == SALT_TYPE_EMBEDDED)
10875 | (salt_type == SALT_TYPE_VIRTUAL));
10876
10877 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10878
10879 data.hash_type = hash_type;
10880 data.attack_mode = attack_mode;
10881 data.attack_kern = attack_kern;
10882 data.attack_exec = attack_exec;
10883 data.kern_type = kern_type;
10884 data.opts_type = opts_type;
10885 data.dgst_size = dgst_size;
10886 data.salt_type = salt_type;
10887 data.isSalted = isSalted;
10888 data.sort_by_digest = sort_by_digest;
10889 data.dgst_pos0 = dgst_pos0;
10890 data.dgst_pos1 = dgst_pos1;
10891 data.dgst_pos2 = dgst_pos2;
10892 data.dgst_pos3 = dgst_pos3;
10893
10894 esalt_size = 0;
10895
10896 switch (hash_mode)
10897 {
10898 case 2500: esalt_size = sizeof (wpa_t); break;
10899 case 5300: esalt_size = sizeof (ikepsk_t); break;
10900 case 5400: esalt_size = sizeof (ikepsk_t); break;
10901 case 5500: esalt_size = sizeof (netntlm_t); break;
10902 case 5600: esalt_size = sizeof (netntlm_t); break;
10903 case 6211: esalt_size = sizeof (tc_t); break;
10904 case 6212: esalt_size = sizeof (tc_t); break;
10905 case 6213: esalt_size = sizeof (tc_t); break;
10906 case 6221: esalt_size = sizeof (tc_t); break;
10907 case 6222: esalt_size = sizeof (tc_t); break;
10908 case 6223: esalt_size = sizeof (tc_t); break;
10909 case 6231: esalt_size = sizeof (tc_t); break;
10910 case 6232: esalt_size = sizeof (tc_t); break;
10911 case 6233: esalt_size = sizeof (tc_t); break;
10912 case 6241: esalt_size = sizeof (tc_t); break;
10913 case 6242: esalt_size = sizeof (tc_t); break;
10914 case 6243: esalt_size = sizeof (tc_t); break;
10915 case 6600: esalt_size = sizeof (agilekey_t); break;
10916 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10917 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10918 case 7300: esalt_size = sizeof (rakp_t); break;
10919 case 7500: esalt_size = sizeof (krb5pa_t); break;
10920 case 8200: esalt_size = sizeof (cloudkey_t); break;
10921 case 8800: esalt_size = sizeof (androidfde_t); break;
10922 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10923 case 9400: esalt_size = sizeof (office2007_t); break;
10924 case 9500: esalt_size = sizeof (office2010_t); break;
10925 case 9600: esalt_size = sizeof (office2013_t); break;
10926 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10927 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10928 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10929 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10930 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10931 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10932 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10933 case 10200: esalt_size = sizeof (cram_md5_t); break;
10934 case 10400: esalt_size = sizeof (pdf_t); break;
10935 case 10410: esalt_size = sizeof (pdf_t); break;
10936 case 10420: esalt_size = sizeof (pdf_t); break;
10937 case 10500: esalt_size = sizeof (pdf_t); break;
10938 case 10600: esalt_size = sizeof (pdf_t); break;
10939 case 10700: esalt_size = sizeof (pdf_t); break;
10940 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10941 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10942 case 11400: esalt_size = sizeof (sip_t); break;
10943 case 11600: esalt_size = sizeof (seven_zip_t); break;
10944 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10945 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10946 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10947 case 13000: esalt_size = sizeof (rar5_t); break;
10948 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10949 case 13400: esalt_size = sizeof (keepass_t); break;
10950 case 13500: esalt_size = sizeof (pstoken_t); break;
10951 case 13600: esalt_size = sizeof (zip2_t); break;
10952 case 13711: esalt_size = sizeof (tc_t); break;
10953 case 13712: esalt_size = sizeof (tc_t); break;
10954 case 13713: esalt_size = sizeof (tc_t); break;
10955 case 13721: esalt_size = sizeof (tc_t); break;
10956 case 13722: esalt_size = sizeof (tc_t); break;
10957 case 13723: esalt_size = sizeof (tc_t); break;
10958 case 13731: esalt_size = sizeof (tc_t); break;
10959 case 13732: esalt_size = sizeof (tc_t); break;
10960 case 13733: esalt_size = sizeof (tc_t); break;
10961 case 13741: esalt_size = sizeof (tc_t); break;
10962 case 13742: esalt_size = sizeof (tc_t); break;
10963 case 13743: esalt_size = sizeof (tc_t); break;
10964 case 13751: esalt_size = sizeof (tc_t); break;
10965 case 13752: esalt_size = sizeof (tc_t); break;
10966 case 13753: esalt_size = sizeof (tc_t); break;
10967 case 13761: esalt_size = sizeof (tc_t); break;
10968 case 13762: esalt_size = sizeof (tc_t); break;
10969 case 13763: esalt_size = sizeof (tc_t); break;
10970 case 13800: esalt_size = sizeof (win8phone_t); break;
10971 }
10972
10973 data.esalt_size = esalt_size;
10974
10975 /**
10976 * choose dictionary parser
10977 */
10978
10979 if (hash_type == HASH_TYPE_LM)
10980 {
10981 get_next_word_func = get_next_word_lm;
10982 }
10983 else if (opts_type & OPTS_TYPE_PT_UPPER)
10984 {
10985 get_next_word_func = get_next_word_uc;
10986 }
10987 else
10988 {
10989 get_next_word_func = get_next_word_std;
10990 }
10991
10992 /**
10993 * dictstat
10994 */
10995
10996 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10997
10998 #ifdef _POSIX
10999 size_t dictstat_nmemb = 0;
11000 #endif
11001
11002 #ifdef _WIN
11003 uint dictstat_nmemb = 0;
11004 #endif
11005
11006 char dictstat[256] = { 0 };
11007
11008 FILE *dictstat_fp = NULL;
11009
11010 if (keyspace == 0)
11011 {
11012 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11013
11014 dictstat_fp = fopen (dictstat, "rb");
11015
11016 if (dictstat_fp)
11017 {
11018 #ifdef _POSIX
11019 struct stat tmpstat;
11020
11021 fstat (fileno (dictstat_fp), &tmpstat);
11022 #endif
11023
11024 #ifdef _WIN
11025 struct stat64 tmpstat;
11026
11027 _fstat64 (fileno (dictstat_fp), &tmpstat);
11028 #endif
11029
11030 if (tmpstat.st_mtime < COMPTIME)
11031 {
11032 /* with v0.15 the format changed so we have to ensure user is using a good version
11033 since there is no version-header in the dictstat file */
11034
11035 fclose (dictstat_fp);
11036
11037 unlink (dictstat);
11038 }
11039 else
11040 {
11041 while (!feof (dictstat_fp))
11042 {
11043 dictstat_t d;
11044
11045 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11046
11047 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11048
11049 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11050 {
11051 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11052
11053 return -1;
11054 }
11055 }
11056
11057 fclose (dictstat_fp);
11058 }
11059 }
11060 }
11061
11062 /**
11063 * potfile
11064 */
11065
11066 char potfile[256] = { 0 };
11067
11068 if (potfile_path == NULL)
11069 {
11070 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11071 }
11072 else
11073 {
11074 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11075 }
11076
11077 data.pot_fp = NULL;
11078
11079 FILE *out_fp = NULL;
11080 FILE *pot_fp = NULL;
11081
11082 if (show == 1 || left == 1)
11083 {
11084 pot_fp = fopen (potfile, "rb");
11085
11086 if (pot_fp == NULL)
11087 {
11088 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11089
11090 return (-1);
11091 }
11092
11093 if (outfile != NULL)
11094 {
11095 if ((out_fp = fopen (outfile, "ab")) == NULL)
11096 {
11097 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11098
11099 fclose (pot_fp);
11100
11101 return (-1);
11102 }
11103 }
11104 else
11105 {
11106 out_fp = stdout;
11107 }
11108 }
11109 else
11110 {
11111 if (potfile_disable == 0)
11112 {
11113 pot_fp = fopen (potfile, "ab");
11114
11115 if (pot_fp == NULL)
11116 {
11117 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11118
11119 return (-1);
11120 }
11121
11122 data.pot_fp = pot_fp;
11123 }
11124 }
11125
11126 pot_t *pot = NULL;
11127
11128 uint pot_cnt = 0;
11129 uint pot_avail = 0;
11130
11131 if (show == 1 || left == 1)
11132 {
11133 SUPPRESS_OUTPUT = 1;
11134
11135 pot_avail = count_lines (pot_fp);
11136
11137 rewind (pot_fp);
11138
11139 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11140
11141 uint pot_hashes_avail = 0;
11142
11143 uint line_num = 0;
11144
11145 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11146
11147 while (!feof (pot_fp))
11148 {
11149 line_num++;
11150
11151 int line_len = fgetl (pot_fp, line_buf);
11152
11153 if (line_len == 0) continue;
11154
11155 char *plain_buf = line_buf + line_len;
11156
11157 pot_t *pot_ptr = &pot[pot_cnt];
11158
11159 hash_t *hashes_buf = &pot_ptr->hash;
11160
11161 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11162 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11163
11164 if (pot_cnt == pot_hashes_avail)
11165 {
11166 uint pos = 0;
11167
11168 for (pos = 0; pos < INCR_POT; pos++)
11169 {
11170 if ((pot_cnt + pos) >= pot_avail) break;
11171
11172 pot_t *tmp_pot = &pot[pot_cnt + pos];
11173
11174 hash_t *tmp_hash = &tmp_pot->hash;
11175
11176 tmp_hash->digest = mymalloc (dgst_size);
11177
11178 if (isSalted)
11179 {
11180 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11181 }
11182
11183 if (esalt_size)
11184 {
11185 tmp_hash->esalt = mymalloc (esalt_size);
11186 }
11187
11188 pot_hashes_avail++;
11189 }
11190 }
11191
11192 int plain_len = 0;
11193
11194 int parser_status;
11195
11196 int iter = MAX_CUT_TRIES;
11197
11198 do
11199 {
11200 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11201 {
11202 if (line_buf[i] == ':')
11203 {
11204 line_len--;
11205
11206 break;
11207 }
11208 }
11209
11210 if (data.hash_mode != 2500)
11211 {
11212 parser_status = parse_func (line_buf, line_len, hashes_buf);
11213 }
11214 else
11215 {
11216 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11217
11218 if (line_len > max_salt_size)
11219 {
11220 parser_status = PARSER_GLOBAL_LENGTH;
11221 }
11222 else
11223 {
11224 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11225
11226 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11227
11228 hashes_buf->salt->salt_len = line_len;
11229
11230 parser_status = PARSER_OK;
11231 }
11232 }
11233
11234 // if NOT parsed without error, we add the ":" to the plain
11235
11236 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11237 {
11238 plain_len++;
11239 plain_buf--;
11240 }
11241
11242 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11243
11244 if (parser_status < PARSER_GLOBAL_ZERO)
11245 {
11246 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11247
11248 continue;
11249 }
11250
11251 if (plain_len >= 255) continue;
11252
11253 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11254
11255 pot_ptr->plain_len = plain_len;
11256
11257 pot_cnt++;
11258 }
11259
11260 myfree (line_buf);
11261
11262 fclose (pot_fp);
11263
11264 SUPPRESS_OUTPUT = 0;
11265
11266 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11267 }
11268
11269 /**
11270 * word len
11271 */
11272
11273 uint pw_min = PW_MIN;
11274 uint pw_max = PW_MAX;
11275
11276 switch (hash_mode)
11277 {
11278 case 125: if (pw_max > 32) pw_max = 32;
11279 break;
11280 case 400: if (pw_max > 40) pw_max = 40;
11281 break;
11282 case 500: if (pw_max > 16) pw_max = 16;
11283 break;
11284 case 1500: if (pw_max > 8) pw_max = 8;
11285 break;
11286 case 1600: if (pw_max > 16) pw_max = 16;
11287 break;
11288 case 1800: if (pw_max > 16) pw_max = 16;
11289 break;
11290 case 2100: if (pw_max > 16) pw_max = 16;
11291 break;
11292 case 2500: if (pw_min < 8) pw_min = 8;
11293 break;
11294 case 3000: if (pw_max > 7) pw_max = 7;
11295 break;
11296 case 5200: if (pw_max > 24) pw_max = 24;
11297 break;
11298 case 5800: if (pw_max > 16) pw_max = 16;
11299 break;
11300 case 6300: if (pw_max > 16) pw_max = 16;
11301 break;
11302 case 7400: if (pw_max > 16) pw_max = 16;
11303 break;
11304 case 7700: if (pw_max > 8) pw_max = 8;
11305 break;
11306 case 7900: if (pw_max > 48) pw_max = 48;
11307 break;
11308 case 8500: if (pw_max > 8) pw_max = 8;
11309 break;
11310 case 8600: if (pw_max > 16) pw_max = 16;
11311 break;
11312 case 9710: pw_min = 5;
11313 pw_max = 5;
11314 break;
11315 case 9810: pw_min = 5;
11316 pw_max = 5;
11317 break;
11318 case 10410: pw_min = 5;
11319 pw_max = 5;
11320 break;
11321 case 10300: if (pw_max < 3) pw_min = 3;
11322 if (pw_max > 40) pw_max = 40;
11323 break;
11324 case 10500: if (pw_max < 3) pw_min = 3;
11325 if (pw_max > 40) pw_max = 40;
11326 break;
11327 case 10700: if (pw_max > 16) pw_max = 16;
11328 break;
11329 case 11300: if (pw_max > 40) pw_max = 40;
11330 break;
11331 case 11600: if (pw_max > 32) pw_max = 32;
11332 break;
11333 case 12500: if (pw_max > 20) pw_max = 20;
11334 break;
11335 case 12800: if (pw_max > 24) pw_max = 24;
11336 break;
11337 }
11338
11339 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11340 {
11341 switch (attack_kern)
11342 {
11343 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11344 break;
11345 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11346 break;
11347 }
11348 }
11349
11350 /**
11351 * charsets : keep them together for more easy maintainnce
11352 */
11353
11354 cs_t mp_sys[6] = { { { 0 }, 0 } };
11355 cs_t mp_usr[4] = { { { 0 }, 0 } };
11356
11357 mp_setup_sys (mp_sys);
11358
11359 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11360 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11361 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11362 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11363
11364 /**
11365 * load hashes, part I: find input mode, count hashes
11366 */
11367
11368 uint hashlist_mode = 0;
11369 uint hashlist_format = HLFMT_HASHCAT;
11370
11371 uint hashes_avail = 0;
11372
11373 if (benchmark == 0)
11374 {
11375 struct stat f;
11376
11377 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11378
11379 if ((hash_mode == 2500) ||
11380 (hash_mode == 5200) ||
11381 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11382 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11383 (hash_mode == 9000))
11384 {
11385 hashlist_mode = HL_MODE_ARG;
11386
11387 char *hashfile = myargv[optind];
11388
11389 data.hashfile = hashfile;
11390
11391 logfile_top_var_string ("target", hashfile);
11392 }
11393
11394 if (hashlist_mode == HL_MODE_ARG)
11395 {
11396 if (hash_mode == 2500)
11397 {
11398 struct stat st;
11399
11400 if (stat (data.hashfile, &st) == -1)
11401 {
11402 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11403
11404 return (-1);
11405 }
11406
11407 hashes_avail = st.st_size / sizeof (hccap_t);
11408 }
11409 else
11410 {
11411 hashes_avail = 1;
11412 }
11413 }
11414 else if (hashlist_mode == HL_MODE_FILE)
11415 {
11416 char *hashfile = myargv[optind];
11417
11418 data.hashfile = hashfile;
11419
11420 logfile_top_var_string ("target", hashfile);
11421
11422 FILE *fp = NULL;
11423
11424 if ((fp = fopen (hashfile, "rb")) == NULL)
11425 {
11426 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11427
11428 return (-1);
11429 }
11430
11431 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11432
11433 hashes_avail = count_lines (fp);
11434
11435 rewind (fp);
11436
11437 if (hashes_avail == 0)
11438 {
11439 log_error ("ERROR: hashfile is empty or corrupt");
11440
11441 fclose (fp);
11442
11443 return (-1);
11444 }
11445
11446 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11447
11448 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11449 {
11450 log_error ("ERROR: remove not supported in native hashfile-format mode");
11451
11452 fclose (fp);
11453
11454 return (-1);
11455 }
11456
11457 fclose (fp);
11458 }
11459 }
11460 else
11461 {
11462 hashlist_mode = HL_MODE_ARG;
11463
11464 hashes_avail = 1;
11465 }
11466
11467 if (hash_mode == 3000) hashes_avail *= 2;
11468
11469 data.hashlist_mode = hashlist_mode;
11470 data.hashlist_format = hashlist_format;
11471
11472 logfile_top_uint (hashlist_mode);
11473 logfile_top_uint (hashlist_format);
11474
11475 /**
11476 * load hashes, part II: allocate required memory, set pointers
11477 */
11478
11479 hash_t *hashes_buf = NULL;
11480 void *digests_buf = NULL;
11481 salt_t *salts_buf = NULL;
11482 void *esalts_buf = NULL;
11483
11484 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11485
11486 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11487
11488 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11489 {
11490 u32 hash_pos;
11491
11492 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11493 {
11494 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11495
11496 hashes_buf[hash_pos].hash_info = hash_info;
11497
11498 if (username && (remove || show || left))
11499 {
11500 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11501 }
11502
11503 if (benchmark)
11504 {
11505 hash_info->orighash = (char *) mymalloc (256);
11506 }
11507 }
11508 }
11509
11510 if (isSalted)
11511 {
11512 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11513
11514 if (esalt_size)
11515 {
11516 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11517 }
11518 }
11519 else
11520 {
11521 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11522 }
11523
11524 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11525 {
11526 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11527
11528 if (isSalted)
11529 {
11530 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11531
11532 if (esalt_size)
11533 {
11534 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11535 }
11536 }
11537 else
11538 {
11539 hashes_buf[hash_pos].salt = &salts_buf[0];
11540 }
11541 }
11542
11543 /**
11544 * load hashes, part III: parse hashes or generate them if benchmark
11545 */
11546
11547 uint hashes_cnt = 0;
11548
11549 if (benchmark == 0)
11550 {
11551 if (keyspace == 1)
11552 {
11553 // useless to read hash file for keyspace, cheat a little bit w/ optind
11554 }
11555 else if (hashes_avail == 0)
11556 {
11557 }
11558 else if (hashlist_mode == HL_MODE_ARG)
11559 {
11560 char *input_buf = myargv[optind];
11561
11562 uint input_len = strlen (input_buf);
11563
11564 logfile_top_var_string ("target", input_buf);
11565
11566 char *hash_buf = NULL;
11567 int hash_len = 0;
11568
11569 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11570
11571 bool hash_fmt_error = 0;
11572
11573 if (hash_len < 1) hash_fmt_error = 1;
11574 if (hash_buf == NULL) hash_fmt_error = 1;
11575
11576 if (hash_fmt_error)
11577 {
11578 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11579 }
11580 else
11581 {
11582 if (opts_type & OPTS_TYPE_HASH_COPY)
11583 {
11584 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11585
11586 hash_info_tmp->orighash = mystrdup (hash_buf);
11587 }
11588
11589 if (isSalted)
11590 {
11591 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11592 }
11593
11594 int parser_status = PARSER_OK;
11595
11596 if (hash_mode == 2500)
11597 {
11598 if (hash_len == 0)
11599 {
11600 log_error ("ERROR: hccap file not specified");
11601
11602 return (-1);
11603 }
11604
11605 hashlist_mode = HL_MODE_FILE;
11606
11607 data.hashlist_mode = hashlist_mode;
11608
11609 FILE *fp = fopen (hash_buf, "rb");
11610
11611 if (fp == NULL)
11612 {
11613 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11614
11615 return (-1);
11616 }
11617
11618 if (hashes_avail < 1)
11619 {
11620 log_error ("ERROR: hccap file is empty or corrupt");
11621
11622 fclose (fp);
11623
11624 return (-1);
11625 }
11626
11627 uint hccap_size = sizeof (hccap_t);
11628
11629 char *in = (char *) mymalloc (hccap_size);
11630
11631 while (!feof (fp))
11632 {
11633 int n = fread (in, hccap_size, 1, fp);
11634
11635 if (n != 1)
11636 {
11637 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11638
11639 break;
11640 }
11641
11642 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11643
11644 if (parser_status != PARSER_OK)
11645 {
11646 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11647
11648 continue;
11649 }
11650
11651 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11652
11653 if ((show == 1) || (left == 1))
11654 {
11655 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11656
11657 char *salt_ptr = (char *) tmp_salt->salt_buf;
11658
11659 int cur_pos = tmp_salt->salt_len;
11660 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11661
11662 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11663
11664 // do the appending task
11665
11666 snprintf (salt_ptr + cur_pos,
11667 rem_len,
11668 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11669 wpa->orig_mac1[0],
11670 wpa->orig_mac1[1],
11671 wpa->orig_mac1[2],
11672 wpa->orig_mac1[3],
11673 wpa->orig_mac1[4],
11674 wpa->orig_mac1[5],
11675 wpa->orig_mac2[0],
11676 wpa->orig_mac2[1],
11677 wpa->orig_mac2[2],
11678 wpa->orig_mac2[3],
11679 wpa->orig_mac2[4],
11680 wpa->orig_mac2[5]);
11681
11682 // memset () the remaining part of the salt
11683
11684 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11685 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11686
11687 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11688
11689 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11690 }
11691
11692 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);
11693 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);
11694
11695 hashes_cnt++;
11696 }
11697
11698 fclose (fp);
11699
11700 myfree (in);
11701 }
11702 else if (hash_mode == 3000)
11703 {
11704 if (hash_len == 32)
11705 {
11706 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11707
11708 hash_t *lm_hash_left = NULL;
11709
11710 if (parser_status == PARSER_OK)
11711 {
11712 lm_hash_left = &hashes_buf[hashes_cnt];
11713
11714 hashes_cnt++;
11715 }
11716 else
11717 {
11718 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11719 }
11720
11721 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11722
11723 hash_t *lm_hash_right = NULL;
11724
11725 if (parser_status == PARSER_OK)
11726 {
11727 lm_hash_right = &hashes_buf[hashes_cnt];
11728
11729 hashes_cnt++;
11730 }
11731 else
11732 {
11733 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11734 }
11735
11736 // show / left
11737
11738 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11739 {
11740 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);
11741 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);
11742 }
11743 }
11744 else
11745 {
11746 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11747
11748 if (parser_status == PARSER_OK)
11749 {
11750 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11751 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11752 }
11753
11754 if (parser_status == PARSER_OK)
11755 {
11756 hashes_cnt++;
11757 }
11758 else
11759 {
11760 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11761 }
11762 }
11763 }
11764 else
11765 {
11766 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11767
11768 if (parser_status == PARSER_OK)
11769 {
11770 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11771 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11772 }
11773
11774 if (parser_status == PARSER_OK)
11775 {
11776 hashes_cnt++;
11777 }
11778 else
11779 {
11780 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11781 }
11782 }
11783 }
11784 }
11785 else if (hashlist_mode == HL_MODE_FILE)
11786 {
11787 char *hashfile = data.hashfile;
11788
11789 FILE *fp;
11790
11791 if ((fp = fopen (hashfile, "rb")) == NULL)
11792 {
11793 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11794
11795 return (-1);
11796 }
11797
11798 uint line_num = 0;
11799
11800 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11801
11802 while (!feof (fp))
11803 {
11804 line_num++;
11805
11806 int line_len = fgetl (fp, line_buf);
11807
11808 if (line_len == 0) continue;
11809
11810 char *hash_buf = NULL;
11811 int hash_len = 0;
11812
11813 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11814
11815 bool hash_fmt_error = 0;
11816
11817 if (hash_len < 1) hash_fmt_error = 1;
11818 if (hash_buf == NULL) hash_fmt_error = 1;
11819
11820 if (hash_fmt_error)
11821 {
11822 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11823
11824 continue;
11825 }
11826
11827 if (username)
11828 {
11829 char *user_buf = NULL;
11830 int user_len = 0;
11831
11832 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11833
11834 if (remove || show)
11835 {
11836 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11837
11838 *user = (user_t *) mymalloc (sizeof (user_t));
11839
11840 user_t *user_ptr = *user;
11841
11842 if (user_buf != NULL)
11843 {
11844 user_ptr->user_name = mystrdup (user_buf);
11845 }
11846 else
11847 {
11848 user_ptr->user_name = mystrdup ("");
11849 }
11850
11851 user_ptr->user_len = user_len;
11852 }
11853 }
11854
11855 if (opts_type & OPTS_TYPE_HASH_COPY)
11856 {
11857 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11858
11859 hash_info_tmp->orighash = mystrdup (hash_buf);
11860 }
11861
11862 if (isSalted)
11863 {
11864 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11865 }
11866
11867 if (hash_mode == 3000)
11868 {
11869 if (hash_len == 32)
11870 {
11871 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11872
11873 if (parser_status < PARSER_GLOBAL_ZERO)
11874 {
11875 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11876
11877 continue;
11878 }
11879
11880 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11881
11882 hashes_cnt++;
11883
11884 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11885
11886 if (parser_status < PARSER_GLOBAL_ZERO)
11887 {
11888 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11889
11890 continue;
11891 }
11892
11893 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11894
11895 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);
11896
11897 hashes_cnt++;
11898
11899 // show / left
11900
11901 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);
11902 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);
11903 }
11904 else
11905 {
11906 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11907
11908 if (parser_status < PARSER_GLOBAL_ZERO)
11909 {
11910 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11911
11912 continue;
11913 }
11914
11915 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);
11916
11917 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11918 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11919
11920 hashes_cnt++;
11921 }
11922 }
11923 else
11924 {
11925 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11926
11927 if (parser_status < PARSER_GLOBAL_ZERO)
11928 {
11929 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11930
11931 continue;
11932 }
11933
11934 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);
11935
11936 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11937 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11938
11939 hashes_cnt++;
11940 }
11941 }
11942
11943 myfree (line_buf);
11944
11945 fclose (fp);
11946
11947 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11948
11949 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11950 }
11951 }
11952 else
11953 {
11954 if (isSalted)
11955 {
11956 hashes_buf[0].salt->salt_len = 8;
11957
11958 // special salt handling
11959
11960 switch (hash_mode)
11961 {
11962 case 1500: hashes_buf[0].salt->salt_len = 2;
11963 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11964 break;
11965 case 1731: hashes_buf[0].salt->salt_len = 4;
11966 break;
11967 case 2410: hashes_buf[0].salt->salt_len = 4;
11968 break;
11969 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11970 break;
11971 case 3100: hashes_buf[0].salt->salt_len = 1;
11972 break;
11973 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11974 break;
11975 case 5800: hashes_buf[0].salt->salt_len = 16;
11976 break;
11977 case 6800: hashes_buf[0].salt->salt_len = 32;
11978 break;
11979 case 8400: hashes_buf[0].salt->salt_len = 40;
11980 break;
11981 case 8800: hashes_buf[0].salt->salt_len = 16;
11982 break;
11983 case 8900: hashes_buf[0].salt->salt_len = 16;
11984 hashes_buf[0].salt->scrypt_N = 1024;
11985 hashes_buf[0].salt->scrypt_r = 1;
11986 hashes_buf[0].salt->scrypt_p = 1;
11987 break;
11988 case 9100: hashes_buf[0].salt->salt_len = 16;
11989 break;
11990 case 9300: hashes_buf[0].salt->salt_len = 14;
11991 hashes_buf[0].salt->scrypt_N = 16384;
11992 hashes_buf[0].salt->scrypt_r = 1;
11993 hashes_buf[0].salt->scrypt_p = 1;
11994 break;
11995 case 9400: hashes_buf[0].salt->salt_len = 16;
11996 break;
11997 case 9500: hashes_buf[0].salt->salt_len = 16;
11998 break;
11999 case 9600: hashes_buf[0].salt->salt_len = 16;
12000 break;
12001 case 9700: hashes_buf[0].salt->salt_len = 16;
12002 break;
12003 case 9710: hashes_buf[0].salt->salt_len = 16;
12004 break;
12005 case 9720: hashes_buf[0].salt->salt_len = 16;
12006 break;
12007 case 9800: hashes_buf[0].salt->salt_len = 16;
12008 break;
12009 case 9810: hashes_buf[0].salt->salt_len = 16;
12010 break;
12011 case 9820: hashes_buf[0].salt->salt_len = 16;
12012 break;
12013 case 10300: hashes_buf[0].salt->salt_len = 12;
12014 break;
12015 case 11500: hashes_buf[0].salt->salt_len = 4;
12016 break;
12017 case 11600: hashes_buf[0].salt->salt_len = 4;
12018 break;
12019 case 12400: hashes_buf[0].salt->salt_len = 4;
12020 break;
12021 case 12500: hashes_buf[0].salt->salt_len = 8;
12022 break;
12023 case 12600: hashes_buf[0].salt->salt_len = 64;
12024 break;
12025 }
12026
12027 // special esalt handling
12028
12029 switch (hash_mode)
12030 {
12031 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12032 break;
12033 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12034 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12035 break;
12036 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12037 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12038 break;
12039 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12040 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12041 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12042 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12043 break;
12044 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12045 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12046 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12047 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12048 break;
12049 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12050 break;
12051 case 10400: ((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 10410: ((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 10420: ((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 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12064 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12065 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12066 break;
12067 case 10600: ((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 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12072 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12073 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12074 break;
12075 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12076 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12077 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12078 break;
12079 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12080 break;
12081 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12082 break;
12083 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12084 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12085 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12086 break;
12087 }
12088 }
12089
12090 // set hashfile
12091
12092 switch (hash_mode)
12093 {
12094 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12095 break;
12096 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12097 break;
12098 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12099 break;
12100 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12101 break;
12102 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12103 break;
12104 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12105 break;
12106 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12107 break;
12108 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12109 break;
12110 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12111 break;
12112 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12113 break;
12114 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12115 break;
12116 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12117 break;
12118 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12119 break;
12120 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12121 break;
12122 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12123 break;
12124 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12125 break;
12126 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12127 break;
12128 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12129 break;
12130 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12131 break;
12132 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12133 break;
12134 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12135 break;
12136 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12137 break;
12138 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12139 break;
12140 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12141 break;
12142 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12143 break;
12144 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12145 break;
12146 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12147 break;
12148 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12149 break;
12150 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12151 break;
12152 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12153 break;
12154 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12155 break;
12156 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12157 break;
12158 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12159 break;
12160 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12161 break;
12162 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12163 break;
12164 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12165 break;
12166 }
12167
12168 // set default iterations
12169
12170 switch (hash_mode)
12171 {
12172 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12173 break;
12174 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12175 break;
12176 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12177 break;
12178 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12179 break;
12180 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12181 break;
12182 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12183 break;
12184 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12185 break;
12186 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12187 break;
12188 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12189 break;
12190 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12191 break;
12192 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12193 break;
12194 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12195 break;
12196 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12197 break;
12198 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12199 break;
12200 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12201 break;
12202 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12203 break;
12204 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12205 break;
12206 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12207 break;
12208 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12209 break;
12210 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12211 break;
12212 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12213 break;
12214 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12215 break;
12216 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12217 break;
12218 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12219 break;
12220 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12221 break;
12222 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12223 break;
12224 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12225 break;
12226 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12227 break;
12228 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12229 break;
12230 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12231 break;
12232 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12233 break;
12234 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12235 break;
12236 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12237 break;
12238 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12239 break;
12240 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12241 break;
12242 case 8900: hashes_buf[0].salt->salt_iter = 1;
12243 break;
12244 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12245 break;
12246 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12247 break;
12248 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12249 break;
12250 case 9300: hashes_buf[0].salt->salt_iter = 1;
12251 break;
12252 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12253 break;
12254 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12255 break;
12256 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12257 break;
12258 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12259 break;
12260 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12261 break;
12262 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12263 break;
12264 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12265 break;
12266 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12267 break;
12268 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12269 break;
12270 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12271 break;
12272 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12273 break;
12274 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12275 break;
12276 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12277 break;
12278 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12279 break;
12280 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12281 break;
12282 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12283 break;
12284 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12285 break;
12286 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12287 break;
12288 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12289 break;
12290 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12291 break;
12292 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12293 break;
12294 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12295 break;
12296 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12297 break;
12298 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12299 break;
12300 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12301 break;
12302 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12303 break;
12304 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12305 break;
12306 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12307 break;
12308 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12309 break;
12310 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12311 break;
12312 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12313 break;
12314 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12315 break;
12316 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12317 break;
12318 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12319 break;
12320 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12321 break;
12322 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12323 break;
12324 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12325 break;
12326 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12327 break;
12328 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12329 break;
12330 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12331 break;
12332 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12333 break;
12334 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12335 break;
12336 }
12337
12338 hashes_cnt = 1;
12339 }
12340
12341 if (show == 1 || left == 1)
12342 {
12343 for (uint i = 0; i < pot_cnt; i++)
12344 {
12345 pot_t *pot_ptr = &pot[i];
12346
12347 hash_t *hashes_buf = &pot_ptr->hash;
12348
12349 local_free (hashes_buf->digest);
12350
12351 if (isSalted)
12352 {
12353 local_free (hashes_buf->salt);
12354 }
12355 }
12356
12357 local_free (pot);
12358
12359 if (data.quiet == 0) log_info_nn ("");
12360
12361 return (0);
12362 }
12363
12364 if (keyspace == 0)
12365 {
12366 if (hashes_cnt == 0)
12367 {
12368 log_error ("ERROR: No hashes loaded");
12369
12370 return (-1);
12371 }
12372 }
12373
12374 /**
12375 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12376 */
12377
12378 if (data.outfile != NULL)
12379 {
12380 if (data.hashfile != NULL)
12381 {
12382 #ifdef _POSIX
12383 struct stat tmpstat_outfile;
12384 struct stat tmpstat_hashfile;
12385 #endif
12386
12387 #ifdef _WIN
12388 struct stat64 tmpstat_outfile;
12389 struct stat64 tmpstat_hashfile;
12390 #endif
12391
12392 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12393
12394 if (tmp_outfile_fp)
12395 {
12396 #ifdef _POSIX
12397 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12398 #endif
12399
12400 #ifdef _WIN
12401 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12402 #endif
12403
12404 fclose (tmp_outfile_fp);
12405 }
12406
12407 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12408
12409 if (tmp_hashfile_fp)
12410 {
12411 #ifdef _POSIX
12412 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12413 #endif
12414
12415 #ifdef _WIN
12416 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12417 #endif
12418
12419 fclose (tmp_hashfile_fp);
12420 }
12421
12422 if (tmp_outfile_fp && tmp_outfile_fp)
12423 {
12424 tmpstat_outfile.st_mode = 0;
12425 tmpstat_outfile.st_nlink = 0;
12426 tmpstat_outfile.st_uid = 0;
12427 tmpstat_outfile.st_gid = 0;
12428 tmpstat_outfile.st_rdev = 0;
12429 tmpstat_outfile.st_atime = 0;
12430
12431 tmpstat_hashfile.st_mode = 0;
12432 tmpstat_hashfile.st_nlink = 0;
12433 tmpstat_hashfile.st_uid = 0;
12434 tmpstat_hashfile.st_gid = 0;
12435 tmpstat_hashfile.st_rdev = 0;
12436 tmpstat_hashfile.st_atime = 0;
12437
12438 #ifdef _POSIX
12439 tmpstat_outfile.st_blksize = 0;
12440 tmpstat_outfile.st_blocks = 0;
12441
12442 tmpstat_hashfile.st_blksize = 0;
12443 tmpstat_hashfile.st_blocks = 0;
12444 #endif
12445
12446 #ifdef _POSIX
12447 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12448 {
12449 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12450
12451 return (-1);
12452 }
12453 #endif
12454
12455 #ifdef _WIN
12456 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12457 {
12458 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12459
12460 return (-1);
12461 }
12462 #endif
12463 }
12464 }
12465 }
12466
12467 /**
12468 * Remove duplicates
12469 */
12470
12471 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12472
12473 if (isSalted)
12474 {
12475 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12476 }
12477 else
12478 {
12479 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12480 }
12481
12482 uint hashes_cnt_orig = hashes_cnt;
12483
12484 hashes_cnt = 1;
12485
12486 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12487 {
12488 if (isSalted)
12489 {
12490 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12491 {
12492 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12493 }
12494 }
12495 else
12496 {
12497 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12498 }
12499
12500 if (hashes_pos > hashes_cnt)
12501 {
12502 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12503 }
12504
12505 hashes_cnt++;
12506 }
12507
12508 /**
12509 * Potfile removes
12510 */
12511
12512 uint potfile_remove_cracks = 0;
12513
12514 if (potfile_disable == 0)
12515 {
12516 hash_t hash_buf;
12517
12518 hash_buf.digest = mymalloc (dgst_size);
12519 hash_buf.salt = NULL;
12520 hash_buf.esalt = NULL;
12521 hash_buf.hash_info = NULL;
12522 hash_buf.cracked = 0;
12523
12524 if (isSalted)
12525 {
12526 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12527 }
12528
12529 if (esalt_size)
12530 {
12531 hash_buf.esalt = mymalloc (esalt_size);
12532 }
12533
12534 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12535
12536 // no solution for these special hash types (for instane because they use hashfile in output etc)
12537 if ((hash_mode != 5200) &&
12538 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12539 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12540 (hash_mode != 9000))
12541 {
12542 FILE *fp = fopen (potfile, "rb");
12543
12544 if (fp != NULL)
12545 {
12546 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12547
12548 // to be safe work with a copy (because of line_len loop, i etc)
12549 // moved up here because it's easier to handle continue case
12550 // it's just 64kb
12551
12552 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12553
12554 while (!feof (fp))
12555 {
12556 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12557
12558 if (ptr == NULL) break;
12559
12560 int line_len = strlen (line_buf);
12561
12562 if (line_len == 0) continue;
12563
12564 int iter = MAX_CUT_TRIES;
12565
12566 for (int i = line_len - 1; i && iter; i--, line_len--)
12567 {
12568 if (line_buf[i] != ':') continue;
12569
12570 if (isSalted)
12571 {
12572 memset (hash_buf.salt, 0, sizeof (salt_t));
12573 }
12574
12575 hash_t *found = NULL;
12576
12577 if (hash_mode == 6800)
12578 {
12579 if (i < 64) // 64 = 16 * uint in salt_buf[]
12580 {
12581 // manipulate salt_buf
12582 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12583
12584 hash_buf.salt->salt_len = i;
12585
12586 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12587 }
12588 }
12589 else if (hash_mode == 2500)
12590 {
12591 if (i < 64) // 64 = 16 * uint in salt_buf[]
12592 {
12593 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12594 // manipulate salt_buf
12595
12596 memcpy (line_buf_cpy, line_buf, i);
12597
12598 char *mac2_pos = strrchr (line_buf_cpy, ':');
12599
12600 if (mac2_pos == NULL) continue;
12601
12602 mac2_pos[0] = 0;
12603 mac2_pos++;
12604
12605 if (strlen (mac2_pos) != 12) continue;
12606
12607 char *mac1_pos = strrchr (line_buf_cpy, ':');
12608
12609 if (mac1_pos == NULL) continue;
12610
12611 mac1_pos[0] = 0;
12612 mac1_pos++;
12613
12614 if (strlen (mac1_pos) != 12) continue;
12615
12616 uint essid_length = mac1_pos - line_buf_cpy - 1;
12617
12618 // here we need the ESSID
12619 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12620
12621 hash_buf.salt->salt_len = essid_length;
12622
12623 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12624
12625 if (found)
12626 {
12627 wpa_t *wpa = (wpa_t *) found->esalt;
12628
12629 // compare hex string(s) vs binary MAC address(es)
12630
12631 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12632 {
12633 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12634 {
12635 found = NULL;
12636
12637 break;
12638 }
12639 }
12640
12641 // early skip ;)
12642 if (!found) continue;
12643
12644 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12645 {
12646 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12647 {
12648 found = NULL;
12649
12650 break;
12651 }
12652 }
12653 }
12654 }
12655 }
12656 else
12657 {
12658 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12659
12660 if (parser_status == PARSER_OK)
12661 {
12662 if (isSalted)
12663 {
12664 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12665 }
12666 else
12667 {
12668 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12669 }
12670 }
12671 }
12672
12673 if (found == NULL) continue;
12674
12675 if (!found->cracked) potfile_remove_cracks++;
12676
12677 found->cracked = 1;
12678
12679 if (found) break;
12680
12681 iter--;
12682 }
12683 }
12684
12685 myfree (line_buf_cpy);
12686
12687 myfree (line_buf);
12688
12689 fclose (fp);
12690 }
12691 }
12692
12693 if (esalt_size)
12694 {
12695 local_free (hash_buf.esalt);
12696 }
12697
12698 if (isSalted)
12699 {
12700 local_free (hash_buf.salt);
12701 }
12702
12703 local_free (hash_buf.digest);
12704 }
12705
12706 /**
12707 * Now generate all the buffers required for later
12708 */
12709
12710 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12711
12712 salt_t *salts_buf_new = NULL;
12713 void *esalts_buf_new = NULL;
12714
12715 if (isSalted)
12716 {
12717 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12718
12719 if (esalt_size)
12720 {
12721 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12722 }
12723 }
12724 else
12725 {
12726 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12727 }
12728
12729 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12730
12731 uint digests_cnt = hashes_cnt;
12732 uint digests_done = 0;
12733
12734 size_t size_digests = digests_cnt * dgst_size;
12735 size_t size_shown = digests_cnt * sizeof (uint);
12736
12737 uint *digests_shown = (uint *) mymalloc (size_shown);
12738 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12739
12740 uint salts_cnt = 0;
12741 uint salts_done = 0;
12742
12743 hashinfo_t **hash_info = NULL;
12744
12745 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12746 {
12747 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12748
12749 if (username && (remove || show))
12750 {
12751 uint user_pos;
12752
12753 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12754 {
12755 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12756
12757 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12758 }
12759 }
12760 }
12761
12762 uint *salts_shown = (uint *) mymalloc (size_shown);
12763
12764 salt_t *salt_buf;
12765
12766 {
12767 // copied from inner loop
12768
12769 salt_buf = &salts_buf_new[salts_cnt];
12770
12771 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12772
12773 if (esalt_size)
12774 {
12775 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12776 }
12777
12778 salt_buf->digests_cnt = 0;
12779 salt_buf->digests_done = 0;
12780 salt_buf->digests_offset = 0;
12781
12782 salts_cnt++;
12783 }
12784
12785 if (hashes_buf[0].cracked == 1)
12786 {
12787 digests_shown[0] = 1;
12788
12789 digests_done++;
12790
12791 salt_buf->digests_done++;
12792 }
12793
12794 salt_buf->digests_cnt++;
12795
12796 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12797
12798 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12799 {
12800 hash_info[0] = hashes_buf[0].hash_info;
12801 }
12802
12803 // copy from inner loop
12804
12805 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12806 {
12807 if (isSalted)
12808 {
12809 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12810 {
12811 salt_buf = &salts_buf_new[salts_cnt];
12812
12813 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12814
12815 if (esalt_size)
12816 {
12817 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12818 }
12819
12820 salt_buf->digests_cnt = 0;
12821 salt_buf->digests_done = 0;
12822 salt_buf->digests_offset = hashes_pos;
12823
12824 salts_cnt++;
12825 }
12826 }
12827
12828 if (hashes_buf[hashes_pos].cracked == 1)
12829 {
12830 digests_shown[hashes_pos] = 1;
12831
12832 digests_done++;
12833
12834 salt_buf->digests_done++;
12835 }
12836
12837 salt_buf->digests_cnt++;
12838
12839 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12840
12841 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12842 {
12843 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12844 }
12845 }
12846
12847 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12848 {
12849 salt_t *salt_buf = &salts_buf_new[salt_pos];
12850
12851 if (salt_buf->digests_done == salt_buf->digests_cnt)
12852 {
12853 salts_shown[salt_pos] = 1;
12854
12855 salts_done++;
12856 }
12857
12858 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12859 }
12860
12861 local_free (digests_buf);
12862 local_free (salts_buf);
12863 local_free (esalts_buf);
12864
12865 digests_buf = digests_buf_new;
12866 salts_buf = salts_buf_new;
12867 esalts_buf = esalts_buf_new;
12868
12869 local_free (hashes_buf);
12870
12871 /**
12872 * special modification not set from parser
12873 */
12874
12875 switch (hash_mode)
12876 {
12877 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12878 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12879 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12880 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12881 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12882 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12883 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12884 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12885 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12886 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12887 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12888 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12889 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12890 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12891 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12892 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12893 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12894 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12895 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12896 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12897 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12898 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12899 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12900 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12901 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12902 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12903 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12904 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12905 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12906 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12907 }
12908
12909 if (truecrypt_keyfiles)
12910 {
12911 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12912
12913 char *keyfiles = strdup (truecrypt_keyfiles);
12914
12915 char *keyfile = strtok (keyfiles, ",");
12916
12917 do
12918 {
12919 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12920
12921 } while ((keyfile = strtok (NULL, ",")) != NULL);
12922
12923 free (keyfiles);
12924 }
12925
12926 if (veracrypt_keyfiles)
12927 {
12928 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12929
12930 char *keyfiles = strdup (veracrypt_keyfiles);
12931
12932 char *keyfile = strtok (keyfiles, ",");
12933
12934 do
12935 {
12936 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12937
12938 } while ((keyfile = strtok (NULL, ",")) != NULL);
12939
12940 free (keyfiles);
12941 }
12942
12943 data.digests_cnt = digests_cnt;
12944 data.digests_done = digests_done;
12945 data.digests_buf = digests_buf;
12946 data.digests_shown = digests_shown;
12947 data.digests_shown_tmp = digests_shown_tmp;
12948
12949 data.salts_cnt = salts_cnt;
12950 data.salts_done = salts_done;
12951 data.salts_buf = salts_buf;
12952 data.salts_shown = salts_shown;
12953
12954 data.esalts_buf = esalts_buf;
12955 data.hash_info = hash_info;
12956
12957 /**
12958 * Automatic Optimizers
12959 */
12960
12961 if (salts_cnt == 1)
12962 opti_type |= OPTI_TYPE_SINGLE_SALT;
12963
12964 if (digests_cnt == 1)
12965 opti_type |= OPTI_TYPE_SINGLE_HASH;
12966
12967 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12968 opti_type |= OPTI_TYPE_NOT_ITERATED;
12969
12970 if (attack_mode == ATTACK_MODE_BF)
12971 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12972
12973 data.opti_type = opti_type;
12974
12975 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12976 {
12977 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12978 {
12979 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12980 {
12981 if (opts_type & OPTS_TYPE_ST_ADD80)
12982 {
12983 opts_type &= ~OPTS_TYPE_ST_ADD80;
12984 opts_type |= OPTS_TYPE_PT_ADD80;
12985 }
12986
12987 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12988 {
12989 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12990 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12991 }
12992
12993 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12994 {
12995 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12996 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12997 }
12998 }
12999 }
13000 }
13001
13002 /**
13003 * Some algorithm, like descrypt, can benefit from JIT compilation
13004 */
13005
13006 int force_jit_compilation = -1;
13007
13008 if (hash_mode == 8900)
13009 {
13010 force_jit_compilation = 8900;
13011 }
13012 else if (hash_mode == 9300)
13013 {
13014 force_jit_compilation = 8900;
13015 }
13016 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13017 {
13018 force_jit_compilation = 1500;
13019 }
13020
13021 /**
13022 * generate bitmap tables
13023 */
13024
13025 const uint bitmap_shift1 = 5;
13026 const uint bitmap_shift2 = 13;
13027
13028 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13029
13030 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13031 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13032 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13033 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13034 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13035 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13036 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13037 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13038
13039 uint bitmap_bits;
13040 uint bitmap_nums;
13041 uint bitmap_mask;
13042 uint bitmap_size;
13043
13044 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13045 {
13046 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13047
13048 bitmap_nums = 1 << bitmap_bits;
13049
13050 bitmap_mask = bitmap_nums - 1;
13051
13052 bitmap_size = bitmap_nums * sizeof (uint);
13053
13054 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13055
13056 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;
13057 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;
13058
13059 break;
13060 }
13061
13062 bitmap_nums = 1 << bitmap_bits;
13063
13064 bitmap_mask = bitmap_nums - 1;
13065
13066 bitmap_size = bitmap_nums * sizeof (uint);
13067
13068 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);
13069 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);
13070
13071 /**
13072 * prepare quick rule
13073 */
13074
13075 data.rule_buf_l = rule_buf_l;
13076 data.rule_buf_r = rule_buf_r;
13077
13078 int rule_len_l = (int) strlen (rule_buf_l);
13079 int rule_len_r = (int) strlen (rule_buf_r);
13080
13081 data.rule_len_l = rule_len_l;
13082 data.rule_len_r = rule_len_r;
13083
13084 /**
13085 * load rules
13086 */
13087
13088 uint *all_kernel_rules_cnt = NULL;
13089
13090 kernel_rule_t **all_kernel_rules_buf = NULL;
13091
13092 if (rp_files_cnt)
13093 {
13094 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13095
13096 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13097 }
13098
13099 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13100
13101 int rule_len = 0;
13102
13103 for (uint i = 0; i < rp_files_cnt; i++)
13104 {
13105 uint kernel_rules_avail = 0;
13106
13107 uint kernel_rules_cnt = 0;
13108
13109 kernel_rule_t *kernel_rules_buf = NULL;
13110
13111 char *rp_file = rp_files[i];
13112
13113 char in[BLOCK_SIZE] = { 0 };
13114 char out[BLOCK_SIZE] = { 0 };
13115
13116 FILE *fp = NULL;
13117
13118 uint rule_line = 0;
13119
13120 if ((fp = fopen (rp_file, "rb")) == NULL)
13121 {
13122 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13123
13124 return (-1);
13125 }
13126
13127 while (!feof (fp))
13128 {
13129 memset (rule_buf, 0, HCBUFSIZ);
13130
13131 rule_len = fgetl (fp, rule_buf);
13132
13133 rule_line++;
13134
13135 if (rule_len == 0) continue;
13136
13137 if (rule_buf[0] == '#') continue;
13138
13139 if (kernel_rules_avail == kernel_rules_cnt)
13140 {
13141 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13142
13143 kernel_rules_avail += INCR_RULES;
13144 }
13145
13146 memset (in, 0, BLOCK_SIZE);
13147 memset (out, 0, BLOCK_SIZE);
13148
13149 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13150
13151 if (result == -1)
13152 {
13153 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13154
13155 continue;
13156 }
13157
13158 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13159 {
13160 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13161
13162 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13163
13164 continue;
13165 }
13166
13167 /* its so slow
13168 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13169 {
13170 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13171
13172 continue;
13173 }
13174 */
13175
13176 kernel_rules_cnt++;
13177 }
13178
13179 fclose (fp);
13180
13181 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13182
13183 all_kernel_rules_buf[i] = kernel_rules_buf;
13184 }
13185
13186 /**
13187 * merge rules or automatic rule generator
13188 */
13189
13190 uint kernel_rules_cnt = 0;
13191
13192 kernel_rule_t *kernel_rules_buf = NULL;
13193
13194 if (attack_mode == ATTACK_MODE_STRAIGHT)
13195 {
13196 if (rp_files_cnt)
13197 {
13198 kernel_rules_cnt = 1;
13199
13200 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13201
13202 repeats[0] = kernel_rules_cnt;
13203
13204 for (uint i = 0; i < rp_files_cnt; i++)
13205 {
13206 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13207
13208 repeats[i + 1] = kernel_rules_cnt;
13209 }
13210
13211 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13212
13213 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13214
13215 for (uint i = 0; i < kernel_rules_cnt; i++)
13216 {
13217 uint out_pos = 0;
13218
13219 kernel_rule_t *out = &kernel_rules_buf[i];
13220
13221 for (uint j = 0; j < rp_files_cnt; j++)
13222 {
13223 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13224 uint in_pos;
13225
13226 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13227
13228 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13229 {
13230 if (out_pos == RULES_MAX - 1)
13231 {
13232 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13233
13234 break;
13235 }
13236
13237 out->cmds[out_pos] = in->cmds[in_pos];
13238 }
13239 }
13240 }
13241
13242 local_free (repeats);
13243 }
13244 else if (rp_gen)
13245 {
13246 uint kernel_rules_avail = 0;
13247
13248 while (kernel_rules_cnt < rp_gen)
13249 {
13250 if (kernel_rules_avail == kernel_rules_cnt)
13251 {
13252 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13253
13254 kernel_rules_avail += INCR_RULES;
13255 }
13256
13257 memset (rule_buf, 0, HCBUFSIZ);
13258
13259 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13260
13261 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13262
13263 kernel_rules_cnt++;
13264 }
13265 }
13266 }
13267
13268 myfree (rule_buf);
13269
13270 /**
13271 * generate NOP rules
13272 */
13273
13274 if (kernel_rules_cnt == 0)
13275 {
13276 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13277
13278 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13279
13280 kernel_rules_cnt++;
13281 }
13282
13283 data.kernel_rules_cnt = kernel_rules_cnt;
13284 data.kernel_rules_buf = kernel_rules_buf;
13285
13286 /**
13287 * OpenCL platforms: detect
13288 */
13289
13290 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13291 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13292
13293 cl_uint platforms_cnt = 0;
13294 cl_uint platform_devices_cnt = 0;
13295
13296 if (keyspace == 0)
13297 {
13298 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13299
13300 if (platforms_cnt == 0)
13301 {
13302 log_info ("");
13303 log_info ("ATTENTION! No OpenCL compatible platform found");
13304 log_info ("");
13305 log_info ("You're probably missing the OpenCL runtime installation");
13306 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13307 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13308 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13309 log_info ("");
13310
13311 return (-1);
13312 }
13313
13314 if (opencl_platforms_filter != (uint) -1)
13315 {
13316 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13317
13318 if (opencl_platforms_filter > platform_cnt_mask)
13319 {
13320 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13321
13322 return (-1);
13323 }
13324 }
13325 }
13326
13327 /**
13328 * OpenCL device types:
13329 * 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.
13330 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13331 */
13332
13333 if (opencl_device_types == NULL)
13334 {
13335 cl_device_type device_types_all = 0;
13336
13337 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13338 {
13339 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13340
13341 cl_platform_id platform = platforms[platform_id];
13342
13343 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13344
13345 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13346 {
13347 cl_device_id device = platform_devices[platform_devices_id];
13348
13349 cl_device_type device_type;
13350
13351 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13352
13353 device_types_all |= device_type;
13354 }
13355 }
13356
13357 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13358 {
13359 device_types_filter |= CL_DEVICE_TYPE_CPU;
13360 }
13361 }
13362
13363 /**
13364 * OpenCL devices: simply push all devices from all platforms into the same device array
13365 */
13366
13367 int need_adl = 0;
13368 int need_nvapi = 0;
13369 int need_nvml = 0;
13370
13371 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13372
13373 data.devices_param = devices_param;
13374
13375 uint devices_cnt = 0;
13376
13377 uint devices_active = 0;
13378
13379 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13380 {
13381 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13382
13383 cl_platform_id platform = platforms[platform_id];
13384
13385 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13386
13387 char platform_vendor[INFOSZ] = { 0 };
13388
13389 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13390
13391 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13392 // this causes trouble with vendor id based macros
13393 // we'll assign generic to those without special optimization available
13394
13395 cl_uint platform_vendor_id = 0;
13396
13397 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13398 {
13399 platform_vendor_id = VENDOR_ID_AMD;
13400 }
13401 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13402 {
13403 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13404 }
13405 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13406 {
13407 platform_vendor_id = VENDOR_ID_APPLE;
13408 }
13409 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13410 {
13411 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13412 }
13413 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13414 {
13415 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13416 }
13417 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13418 {
13419 platform_vendor_id = VENDOR_ID_MESA;
13420 }
13421 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13422 {
13423 platform_vendor_id = VENDOR_ID_NV;
13424 }
13425 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13426 {
13427 platform_vendor_id = VENDOR_ID_POCL;
13428 }
13429 else
13430 {
13431 platform_vendor_id = VENDOR_ID_GENERIC;
13432 }
13433
13434 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13435 {
13436 size_t param_value_size = 0;
13437
13438 const uint device_id = devices_cnt;
13439
13440 hc_device_param_t *device_param = &data.devices_param[device_id];
13441
13442 device_param->platform_vendor_id = platform_vendor_id;
13443
13444 device_param->device = platform_devices[platform_devices_id];
13445
13446 device_param->device_id = device_id;
13447
13448 device_param->platform_devices_id = platform_devices_id;
13449
13450 // device_type
13451
13452 cl_device_type device_type;
13453
13454 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13455
13456 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13457
13458 device_param->device_type = device_type;
13459
13460 // device_name
13461
13462 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13463
13464 char *device_name = (char *) mymalloc (param_value_size);
13465
13466 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13467
13468 device_param->device_name = device_name;
13469
13470 // device_vendor
13471
13472 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13473
13474 char *device_vendor = (char *) mymalloc (param_value_size);
13475
13476 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13477
13478 device_param->device_vendor = device_vendor;
13479
13480 cl_uint device_vendor_id = 0;
13481
13482 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13483 {
13484 device_vendor_id = VENDOR_ID_AMD;
13485 }
13486 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13487 {
13488 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13489 }
13490 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13491 {
13492 device_vendor_id = VENDOR_ID_APPLE;
13493 }
13494 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13495 {
13496 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13497 }
13498 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13499 {
13500 device_vendor_id = VENDOR_ID_INTEL_SDK;
13501 }
13502 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13503 {
13504 device_vendor_id = VENDOR_ID_MESA;
13505 }
13506 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13507 {
13508 device_vendor_id = VENDOR_ID_NV;
13509 }
13510 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13511 {
13512 device_vendor_id = VENDOR_ID_POCL;
13513 }
13514 else
13515 {
13516 device_vendor_id = VENDOR_ID_GENERIC;
13517 }
13518
13519 device_param->device_vendor_id = device_vendor_id;
13520
13521 // tuning db
13522
13523 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13524
13525 // device_version
13526
13527 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13528
13529 char *device_version = (char *) mymalloc (param_value_size);
13530
13531 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13532
13533 device_param->device_version = device_version;
13534
13535 // device_opencl_version
13536
13537 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13538
13539 char *device_opencl_version = (char *) mymalloc (param_value_size);
13540
13541 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13542
13543 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13544
13545 myfree (device_opencl_version);
13546
13547 // vector_width
13548
13549 cl_uint vector_width;
13550
13551 if (opencl_vector_width_chgd == 0)
13552 {
13553 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13554 {
13555 if (opti_type & OPTI_TYPE_USES_BITS_64)
13556 {
13557 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13558 }
13559 else
13560 {
13561 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13562 }
13563 }
13564 else
13565 {
13566 vector_width = (cl_uint) tuningdb_entry->vector_width;
13567 }
13568 }
13569 else
13570 {
13571 vector_width = opencl_vector_width;
13572 }
13573
13574 if (vector_width > 16) vector_width = 16;
13575
13576 device_param->vector_width = vector_width;
13577
13578 // max_compute_units
13579
13580 cl_uint device_processors;
13581
13582 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13583
13584 device_param->device_processors = device_processors;
13585
13586 // device_maxmem_alloc
13587 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13588
13589 cl_ulong device_maxmem_alloc;
13590
13591 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13592
13593 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13594
13595 // device_global_mem
13596
13597 cl_ulong device_global_mem;
13598
13599 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13600
13601 device_param->device_global_mem = device_global_mem;
13602
13603 // max_work_group_size
13604
13605 size_t device_maxworkgroup_size;
13606
13607 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13608
13609 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13610
13611 // max_clock_frequency
13612
13613 cl_uint device_maxclock_frequency;
13614
13615 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13616
13617 device_param->device_maxclock_frequency = device_maxclock_frequency;
13618
13619 // device_endian_little
13620
13621 cl_bool device_endian_little;
13622
13623 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13624
13625 if (device_endian_little == CL_FALSE)
13626 {
13627 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13628
13629 device_param->skipped = 1;
13630 }
13631
13632 // device_available
13633
13634 cl_bool device_available;
13635
13636 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13637
13638 if (device_available == CL_FALSE)
13639 {
13640 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13641
13642 device_param->skipped = 1;
13643 }
13644
13645 // device_compiler_available
13646
13647 cl_bool device_compiler_available;
13648
13649 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13650
13651 if (device_compiler_available == CL_FALSE)
13652 {
13653 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13654
13655 device_param->skipped = 1;
13656 }
13657
13658 // device_execution_capabilities
13659
13660 cl_device_exec_capabilities device_execution_capabilities;
13661
13662 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13663
13664 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13665 {
13666 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13667
13668 device_param->skipped = 1;
13669 }
13670
13671 // device_extensions
13672
13673 size_t device_extensions_size;
13674
13675 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13676
13677 char *device_extensions = mymalloc (device_extensions_size + 1);
13678
13679 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13680
13681 if (strstr (device_extensions, "base_atomics") == 0)
13682 {
13683 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13684
13685 device_param->skipped = 1;
13686 }
13687
13688 if (strstr (device_extensions, "byte_addressable_store") == 0)
13689 {
13690 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13691
13692 device_param->skipped = 1;
13693 }
13694
13695 myfree (device_extensions);
13696
13697 // device_local_mem_size
13698
13699 cl_ulong device_local_mem_size;
13700
13701 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13702
13703 if (device_local_mem_size < 32768)
13704 {
13705 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13706
13707 device_param->skipped = 1;
13708 }
13709
13710 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13711 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13712 // This results in both utilizing it for 50%
13713 // However, Intel has much better SIMD control over their own hardware
13714 // It makes sense to give them full control over their own hardware
13715
13716 if (device_type & CL_DEVICE_TYPE_CPU)
13717 {
13718 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13719 {
13720 if (data.force == 0)
13721 {
13722 if (algorithm_pos == 0)
13723 {
13724 log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
13725 log_info (" You can use --force to override this but do not post error reports if you do so");
13726 }
13727
13728 device_param->skipped = 1;
13729 }
13730 }
13731 }
13732
13733 // skipped
13734
13735 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13736 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13737
13738 // driver_version
13739
13740 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13741
13742 char *driver_version = (char *) mymalloc (param_value_size);
13743
13744 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13745
13746 device_param->driver_version = driver_version;
13747
13748 // device_name_chksum
13749
13750 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13751
13752 #if __x86_64__
13753 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);
13754 #else
13755 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);
13756 #endif
13757
13758 uint device_name_digest[4] = { 0 };
13759
13760 md5_64 ((uint *) device_name_chksum, device_name_digest);
13761
13762 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13763
13764 device_param->device_name_chksum = device_name_chksum;
13765
13766 // device_processor_cores
13767
13768 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
13769 {
13770 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
13771 {
13772 need_adl = 1;
13773 }
13774
13775 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
13776 {
13777 need_nvml = 1;
13778
13779 #ifdef _WIN
13780 need_nvapi = 1;
13781 #endif
13782 }
13783 }
13784
13785 // device_processor_cores
13786
13787 if (device_type & CL_DEVICE_TYPE_CPU)
13788 {
13789 cl_uint device_processor_cores = 1;
13790
13791 device_param->device_processor_cores = device_processor_cores;
13792 }
13793
13794 if (device_type & CL_DEVICE_TYPE_GPU)
13795 {
13796 if (device_vendor_id == VENDOR_ID_AMD)
13797 {
13798 cl_uint device_processor_cores = 0;
13799
13800 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13801
13802 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13803
13804 device_param->device_processor_cores = device_processor_cores;
13805 }
13806 else if (device_vendor_id == VENDOR_ID_NV)
13807 {
13808 cl_uint kernel_exec_timeout = 0;
13809
13810 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13811
13812 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13813
13814 device_param->kernel_exec_timeout = kernel_exec_timeout;
13815
13816 cl_uint device_processor_cores = 0;
13817
13818 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13819
13820 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13821
13822 device_param->device_processor_cores = device_processor_cores;
13823
13824 cl_uint sm_minor = 0;
13825 cl_uint sm_major = 0;
13826
13827 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13828 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13829
13830 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13831 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13832
13833 device_param->sm_minor = sm_minor;
13834 device_param->sm_major = sm_major;
13835 }
13836 else
13837 {
13838 cl_uint device_processor_cores = 1;
13839
13840 device_param->device_processor_cores = device_processor_cores;
13841 }
13842 }
13843
13844 // display results
13845
13846 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13847 {
13848 if (machine_readable == 0)
13849 {
13850 if (device_param->skipped == 0)
13851 {
13852 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13853 device_id + 1,
13854 device_name,
13855 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13856 (unsigned int) (device_global_mem / 1024 / 1024),
13857 (unsigned int) device_processors);
13858 }
13859 else
13860 {
13861 log_info ("Device #%u: %s, skipped",
13862 device_id + 1,
13863 device_name);
13864 }
13865 }
13866 }
13867
13868 // common driver check
13869
13870 if (device_param->skipped == 0)
13871 {
13872 if (device_type & CL_DEVICE_TYPE_GPU)
13873 {
13874 if (platform_vendor_id == VENDOR_ID_AMD)
13875 {
13876 int catalyst_check = (force == 1) ? 0 : 1;
13877
13878 int catalyst_warn = 0;
13879
13880 int catalyst_broken = 0;
13881
13882 if (catalyst_check == 1)
13883 {
13884 catalyst_warn = 1;
13885
13886 // v14.9 and higher
13887 if (atoi (device_param->driver_version) >= 1573)
13888 {
13889 catalyst_warn = 0;
13890 }
13891
13892 catalyst_check = 0;
13893 }
13894
13895 if (catalyst_broken == 1)
13896 {
13897 log_info ("");
13898 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13899 log_info ("It will pass over cracked hashes and does not report them as cracked");
13900 log_info ("You are STRONGLY encouraged not to use it");
13901 log_info ("You can use --force to override this but do not post error reports if you do so");
13902 log_info ("");
13903
13904 return (-1);
13905 }
13906
13907 if (catalyst_warn == 1)
13908 {
13909 log_info ("");
13910 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13911 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13912 log_info ("See hashcat's homepage for official supported catalyst drivers");
13913 #ifdef _WIN
13914 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13915 #endif
13916 log_info ("You can use --force to override this but do not post error reports if you do so");
13917 log_info ("");
13918
13919 return (-1);
13920 }
13921 }
13922 else if (platform_vendor_id == VENDOR_ID_NV)
13923 {
13924 if (device_param->kernel_exec_timeout != 0)
13925 {
13926 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);
13927 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13928 }
13929 }
13930 }
13931
13932 /* turns out pocl still creates segfaults (because of llvm)
13933 if (device_type & CL_DEVICE_TYPE_CPU)
13934 {
13935 if (platform_vendor_id == VENDOR_ID_AMD)
13936 {
13937 if (force == 0)
13938 {
13939 log_info ("");
13940 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13941 log_info ("You are STRONGLY encouraged not to use it");
13942 log_info ("You can use --force to override this but do not post error reports if you do so");
13943 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13944 log_info ("");
13945
13946 return (-1);
13947 }
13948 }
13949 }
13950 */
13951
13952 /**
13953 * kernel accel and loops tuning db adjustment
13954 */
13955
13956 device_param->kernel_accel_min = 1;
13957 device_param->kernel_accel_max = 1024;
13958
13959 device_param->kernel_loops_min = 1;
13960 device_param->kernel_loops_max = 1024;
13961
13962 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13963
13964 if (tuningdb_entry)
13965 {
13966 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13967 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13968
13969 if (_kernel_accel)
13970 {
13971 device_param->kernel_accel_min = _kernel_accel;
13972 device_param->kernel_accel_max = _kernel_accel;
13973 }
13974
13975 if (_kernel_loops)
13976 {
13977 if (workload_profile == 1)
13978 {
13979 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13980 }
13981 else if (workload_profile == 2)
13982 {
13983 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13984 }
13985
13986 device_param->kernel_loops_min = _kernel_loops;
13987 device_param->kernel_loops_max = _kernel_loops;
13988 }
13989 }
13990
13991 // commandline parameters overwrite tuningdb entries
13992
13993 if (kernel_accel)
13994 {
13995 device_param->kernel_accel_min = kernel_accel;
13996 device_param->kernel_accel_max = kernel_accel;
13997 }
13998
13999 if (kernel_loops)
14000 {
14001 device_param->kernel_loops_min = kernel_loops;
14002 device_param->kernel_loops_max = kernel_loops;
14003 }
14004
14005 /**
14006 * activate device
14007 */
14008
14009 devices_active++;
14010 }
14011
14012 // next please
14013
14014 devices_cnt++;
14015 }
14016 }
14017
14018 if (keyspace == 0 && devices_active == 0)
14019 {
14020 log_error ("ERROR: No devices found/left");
14021
14022 return (-1);
14023 }
14024
14025 // 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)
14026
14027 if (devices_filter != (uint) -1)
14028 {
14029 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14030
14031 if (devices_filter > devices_cnt_mask)
14032 {
14033 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14034
14035 return (-1);
14036 }
14037 }
14038
14039 data.devices_cnt = devices_cnt;
14040
14041 data.devices_active = devices_active;
14042
14043 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14044 {
14045 if (machine_readable == 0)
14046 {
14047 log_info ("");
14048 }
14049 }
14050
14051 /**
14052 * HM devices: init
14053 */
14054
14055 #ifdef HAVE_HWMON
14056 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14057 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14058 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14059
14060 if (gpu_temp_disable == 0)
14061 {
14062 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14063 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14064 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14065
14066 data.hm_adl = NULL;
14067 data.hm_nvapi = NULL;
14068 data.hm_nvml = NULL;
14069
14070 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14071 {
14072 data.hm_nvml = nvml;
14073 }
14074
14075 if (data.hm_nvml)
14076 {
14077 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14078 {
14079 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14080
14081 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14082
14083 int tmp_out = 0;
14084
14085 for (int i = 0; i < tmp_in; i++)
14086 {
14087 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14088 }
14089
14090 for (int i = 0; i < tmp_out; i++)
14091 {
14092 unsigned int speed;
14093
14094 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14095
14096 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14097
14098 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14099 }
14100 }
14101 }
14102
14103 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14104 {
14105 data.hm_nvapi = nvapi;
14106 }
14107
14108 if (data.hm_nvapi)
14109 {
14110 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14111 {
14112 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14113
14114 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14115
14116 int tmp_out = 0;
14117
14118 for (int i = 0; i < tmp_in; i++)
14119 {
14120 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14121 }
14122 }
14123 }
14124
14125 if ((need_adl == 1) && (adl_init (adl) == 0))
14126 {
14127 data.hm_adl = adl;
14128 }
14129
14130 if (data.hm_adl)
14131 {
14132 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14133 {
14134 // total number of adapters
14135
14136 int hm_adapters_num;
14137
14138 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14139
14140 // adapter info
14141
14142 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14143
14144 if (lpAdapterInfo == NULL) return (-1);
14145
14146 // get a list (of ids of) valid/usable adapters
14147
14148 int num_adl_adapters = 0;
14149
14150 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14151
14152 if (num_adl_adapters > 0)
14153 {
14154 hc_thread_mutex_lock (mux_adl);
14155
14156 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14157
14158 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14159
14160 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14161 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14162
14163 hc_thread_mutex_unlock (mux_adl);
14164 }
14165
14166 myfree (valid_adl_device_list);
14167 myfree (lpAdapterInfo);
14168 }
14169 }
14170
14171 if (data.hm_adl == NULL && data.hm_nvml == NULL)
14172 {
14173 gpu_temp_disable = 1;
14174 }
14175 }
14176
14177 /**
14178 * OpenCL devices: allocate buffer for device specific information
14179 */
14180
14181 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14182 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14183
14184 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14185
14186 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14187
14188 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14189
14190 /**
14191 * User-defined GPU temp handling
14192 */
14193
14194 if (gpu_temp_disable == 1)
14195 {
14196 gpu_temp_abort = 0;
14197 gpu_temp_retain = 0;
14198 }
14199
14200 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14201 {
14202 if (gpu_temp_abort < gpu_temp_retain)
14203 {
14204 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14205
14206 return (-1);
14207 }
14208 }
14209
14210 data.gpu_temp_disable = gpu_temp_disable;
14211 data.gpu_temp_abort = gpu_temp_abort;
14212 data.gpu_temp_retain = gpu_temp_retain;
14213 #endif
14214
14215 /**
14216 * enable custom signal handler(s)
14217 */
14218
14219 if (benchmark == 0)
14220 {
14221 hc_signal (sigHandler_default);
14222 }
14223 else
14224 {
14225 hc_signal (sigHandler_benchmark);
14226 }
14227
14228 /**
14229 * inform the user
14230 */
14231
14232 if (data.quiet == 0)
14233 {
14234 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14235
14236 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);
14237
14238 if (attack_mode == ATTACK_MODE_STRAIGHT)
14239 {
14240 log_info ("Rules: %u", kernel_rules_cnt);
14241 }
14242
14243 if (opti_type)
14244 {
14245 log_info ("Applicable Optimizers:");
14246
14247 for (uint i = 0; i < 32; i++)
14248 {
14249 const uint opti_bit = 1u << i;
14250
14251 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14252 }
14253 }
14254
14255 /**
14256 * Watchdog and Temperature balance
14257 */
14258
14259 #ifdef HAVE_HWMON
14260 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL)
14261 {
14262 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14263 }
14264
14265 if (gpu_temp_abort == 0)
14266 {
14267 log_info ("Watchdog: Temperature abort trigger disabled");
14268 }
14269 else
14270 {
14271 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14272 }
14273
14274 if (gpu_temp_retain == 0)
14275 {
14276 log_info ("Watchdog: Temperature retain trigger disabled");
14277 }
14278 else
14279 {
14280 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14281 }
14282
14283 if (data.quiet == 0) log_info ("");
14284 #endif
14285 }
14286
14287 #ifdef HAVE_HWMON
14288
14289 /**
14290 * HM devices: copy
14291 */
14292
14293 if (gpu_temp_disable == 0)
14294 {
14295 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14296 {
14297 hc_device_param_t *device_param = &data.devices_param[device_id];
14298
14299 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14300
14301 if (device_param->skipped) continue;
14302
14303 const uint platform_devices_id = device_param->platform_devices_id;
14304
14305 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14306 {
14307 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14308 data.hm_device[device_id].nvapi = 0;
14309 data.hm_device[device_id].nvml = 0;
14310 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14311 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14312 data.hm_device[device_id].fan_set_supported = hm_adapters_adl[platform_devices_id].fan_set_supported;
14313 }
14314
14315 if (device_param->device_vendor_id == VENDOR_ID_NV)
14316 {
14317 data.hm_device[device_id].adl = 0;
14318 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14319 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14320 data.hm_device[device_id].od_version = 0;
14321 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14322 data.hm_device[device_id].fan_set_supported = 0;
14323 }
14324 }
14325 }
14326
14327 /**
14328 * powertune on user request
14329 */
14330
14331 if (powertune_enable == 1)
14332 {
14333 hc_thread_mutex_lock (mux_adl);
14334
14335 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14336 {
14337 hc_device_param_t *device_param = &data.devices_param[device_id];
14338
14339 if (device_param->skipped) continue;
14340
14341 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14342 {
14343 /**
14344 * Temporary fix:
14345 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14346 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14347 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14348 * Driver / ADL bug?
14349 */
14350
14351 if (data.hm_device[device_id].od_version == 6)
14352 {
14353 int ADL_rc;
14354
14355 // check powertune capabilities first, if not available then skip device
14356
14357 int powertune_supported = 0;
14358
14359 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14360 {
14361 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14362
14363 return (-1);
14364 }
14365
14366 // first backup current value, we will restore it later
14367
14368 if (powertune_supported != 0)
14369 {
14370 // powercontrol settings
14371
14372 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14373
14374 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14375 {
14376 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14377 }
14378
14379 if (ADL_rc != ADL_OK)
14380 {
14381 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14382
14383 return (-1);
14384 }
14385
14386 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14387 {
14388 log_error ("ERROR: Failed to set new ADL PowerControl values");
14389
14390 return (-1);
14391 }
14392
14393 // clocks
14394
14395 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14396
14397 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14398
14399 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)
14400 {
14401 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14402
14403 return (-1);
14404 }
14405
14406 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14407
14408 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14409
14410 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14411 {
14412 log_error ("ERROR: Failed to get ADL device capabilities");
14413
14414 return (-1);
14415 }
14416
14417 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14418 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14419
14420 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14421 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14422
14423 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14424 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14425
14426 // warning if profile has too low max values
14427
14428 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14429 {
14430 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14431 }
14432
14433 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14434 {
14435 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14436 }
14437
14438 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14439
14440 performance_state->iNumberOfPerformanceLevels = 2;
14441
14442 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14443 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14444 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14445 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14446
14447 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)
14448 {
14449 log_info ("ERROR: Failed to set ADL performance state");
14450
14451 return (-1);
14452 }
14453
14454 local_free (performance_state);
14455 }
14456
14457 // set powertune value only
14458
14459 if (powertune_supported != 0)
14460 {
14461 // powertune set
14462 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14463
14464 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14465 {
14466 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14467
14468 return (-1);
14469 }
14470
14471 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14472 {
14473 log_error ("ERROR: Failed to set new ADL PowerControl values");
14474
14475 return (-1);
14476 }
14477 }
14478 }
14479 }
14480
14481 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14482 {
14483 // first backup current value, we will restore it later
14484
14485 unsigned int limit;
14486
14487 int powertune_supported = 0;
14488
14489 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14490 {
14491 powertune_supported = 1;
14492 }
14493
14494 // if backup worked, activate the maximum allowed
14495
14496 if (powertune_supported != 0)
14497 {
14498 unsigned int minLimit;
14499 unsigned int maxLimit;
14500
14501 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14502 {
14503 if (maxLimit > 0)
14504 {
14505 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14506 {
14507 // now we can be sure we need to reset later
14508
14509 nvml_power_limit[device_id] = limit;
14510 }
14511 }
14512 }
14513 }
14514 }
14515 }
14516
14517 hc_thread_mutex_unlock (mux_adl);
14518 }
14519
14520 #endif // HAVE_HWMON
14521
14522 #ifdef DEBUG
14523 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14524 #endif
14525
14526 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14527
14528 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14529 {
14530 /**
14531 * host buffer
14532 */
14533
14534 hc_device_param_t *device_param = &data.devices_param[device_id];
14535
14536 if (device_param->skipped) continue;
14537
14538 /**
14539 * device properties
14540 */
14541
14542 const char *device_name_chksum = device_param->device_name_chksum;
14543 const u32 device_processors = device_param->device_processors;
14544 const u32 device_processor_cores = device_param->device_processor_cores;
14545
14546 /**
14547 * create context for each device
14548 */
14549
14550 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14551
14552 /**
14553 * create command-queue
14554 */
14555
14556 // not supported with NV
14557 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14558
14559 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14560
14561 /**
14562 * kernel threads: some algorithms need a fixed kernel-threads count
14563 * because of shared memory usage or bitslice
14564 * there needs to be some upper limit, otherwise there's too much overhead
14565 */
14566
14567 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14568
14569 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14570 {
14571 kernel_threads = KERNEL_THREADS_MAX_CPU;
14572 }
14573
14574 if (hash_mode == 1500) kernel_threads = 64; // DES
14575 if (hash_mode == 3000) kernel_threads = 64; // DES
14576 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14577 if (hash_mode == 7500) kernel_threads = 64; // RC4
14578 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14579 if (hash_mode == 9700) kernel_threads = 64; // RC4
14580 if (hash_mode == 9710) kernel_threads = 64; // RC4
14581 if (hash_mode == 9800) kernel_threads = 64; // RC4
14582 if (hash_mode == 9810) kernel_threads = 64; // RC4
14583 if (hash_mode == 10400) kernel_threads = 64; // RC4
14584 if (hash_mode == 10410) kernel_threads = 64; // RC4
14585 if (hash_mode == 10500) kernel_threads = 64; // RC4
14586 if (hash_mode == 13100) kernel_threads = 64; // RC4
14587
14588 device_param->kernel_threads = kernel_threads;
14589
14590 device_param->hardware_power = device_processors * kernel_threads;
14591
14592 /**
14593 * create input buffers on device : calculate size of fixed memory buffers
14594 */
14595
14596 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14597 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14598
14599 device_param->size_root_css = size_root_css;
14600 device_param->size_markov_css = size_markov_css;
14601
14602 size_t size_results = sizeof (uint);
14603
14604 device_param->size_results = size_results;
14605
14606 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14607 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14608
14609 size_t size_plains = digests_cnt * sizeof (plain_t);
14610 size_t size_salts = salts_cnt * sizeof (salt_t);
14611 size_t size_esalts = salts_cnt * esalt_size;
14612
14613 device_param->size_plains = size_plains;
14614 device_param->size_digests = size_digests;
14615 device_param->size_shown = size_shown;
14616 device_param->size_salts = size_salts;
14617
14618 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14619 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14620 size_t size_tm = 32 * sizeof (bs_word_t);
14621
14622 // scryptV stuff
14623
14624 size_t size_scryptV = 1;
14625
14626 if ((hash_mode == 8900) || (hash_mode == 9300))
14627 {
14628 uint tmto_start = 0;
14629 uint tmto_stop = 10;
14630
14631 if (scrypt_tmto)
14632 {
14633 tmto_start = scrypt_tmto;
14634 }
14635 else
14636 {
14637 // in case the user did not specify the tmto manually
14638 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14639 // but set the lower end only in case the user has a device with too less memory
14640
14641 if (hash_mode == 8900)
14642 {
14643 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14644 {
14645 tmto_start = 1;
14646 }
14647 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14648 {
14649 tmto_start = 2;
14650 }
14651 }
14652 else if (hash_mode == 9300)
14653 {
14654 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14655 {
14656 tmto_start = 2;
14657 }
14658 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14659 {
14660 tmto_start = 2;
14661 }
14662 }
14663 }
14664
14665 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14666 {
14667 // TODO: in theory the following calculation needs to be done per salt, not global
14668 // we assume all hashes have the same scrypt settings
14669
14670 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14671
14672 size_scryptV /= 1 << tmto;
14673
14674 size_scryptV *= device_processors * device_processor_cores;
14675
14676 if (size_scryptV > device_param->device_maxmem_alloc)
14677 {
14678 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14679
14680 continue;
14681 }
14682
14683 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14684 {
14685 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14686 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14687 }
14688
14689 break;
14690 }
14691
14692 if (data.salts_buf[0].scrypt_phy == 0)
14693 {
14694 log_error ("ERROR: can't allocate enough device memory");
14695
14696 return -1;
14697 }
14698
14699 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14700 }
14701
14702 /**
14703 * some algorithms need a fixed kernel-loops count
14704 */
14705
14706 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
14707 {
14708 const u32 kernel_loops_fixed = 1024;
14709
14710 device_param->kernel_loops_min = kernel_loops_fixed;
14711 device_param->kernel_loops_max = kernel_loops_fixed;
14712 }
14713
14714 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
14715 {
14716 const u32 kernel_loops_fixed = 1024;
14717
14718 device_param->kernel_loops_min = kernel_loops_fixed;
14719 device_param->kernel_loops_max = kernel_loops_fixed;
14720 }
14721
14722 if (hash_mode == 8900)
14723 {
14724 const u32 kernel_loops_fixed = 1;
14725
14726 device_param->kernel_loops_min = kernel_loops_fixed;
14727 device_param->kernel_loops_max = kernel_loops_fixed;
14728 }
14729
14730 if (hash_mode == 9300)
14731 {
14732 const u32 kernel_loops_fixed = 1;
14733
14734 device_param->kernel_loops_min = kernel_loops_fixed;
14735 device_param->kernel_loops_max = kernel_loops_fixed;
14736 }
14737
14738 if (hash_mode == 12500)
14739 {
14740 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14741
14742 device_param->kernel_loops_min = kernel_loops_fixed;
14743 device_param->kernel_loops_max = kernel_loops_fixed;
14744 }
14745
14746 /**
14747 * some algorithms have a maximum kernel-loops count
14748 */
14749
14750 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14751 {
14752 u32 innerloop_cnt = 0;
14753
14754 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14755 {
14756 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14757 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14758 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14759 }
14760 else
14761 {
14762 innerloop_cnt = data.salts_buf[0].salt_iter;
14763 }
14764
14765 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14766 (innerloop_cnt <= device_param->kernel_loops_max))
14767 {
14768 device_param->kernel_loops_max = innerloop_cnt;
14769 }
14770 }
14771
14772 u32 kernel_accel_min = device_param->kernel_accel_min;
14773 u32 kernel_accel_max = device_param->kernel_accel_max;
14774
14775 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14776
14777 size_t size_pws = 4;
14778 size_t size_tmps = 4;
14779 size_t size_hooks = 4;
14780
14781 while (kernel_accel_max >= kernel_accel_min)
14782 {
14783 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14784
14785 // size_pws
14786
14787 size_pws = kernel_power_max * sizeof (pw_t);
14788
14789 // size_tmps
14790
14791 switch (hash_mode)
14792 {
14793 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14794 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14795 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14796 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14797 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14798 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14799 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14800 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14801 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14802 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14803 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14804 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14805 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14806 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14807 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14808 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14809 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14810 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14811 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14812 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14813 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14814 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14815 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14816 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14817 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14818 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14819 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14820 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14821 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14822 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14823 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14824 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14825 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14826 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14827 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14828 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14829 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14830 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14831 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14832 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14833 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14834 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14835 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14836 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14837 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14838 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14839 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14840 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14841 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14842 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14843 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14844 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14845 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14846 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14847 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14848 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14849 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14850 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14851 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14852 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14853 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14854 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14855 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14856 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14857 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14858 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14859 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14860 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14861 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14862 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14863 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14864 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14865 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14866 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14867 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14868 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14869 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14870 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14871 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14872 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14873 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14874 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14875 };
14876
14877 // size_hooks
14878
14879 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14880 {
14881 // none yet
14882 }
14883
14884 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14885 // if not, decrease amplifier and try again
14886
14887 int skip = 0;
14888
14889 const u64 size_total
14890 = bitmap_size
14891 + bitmap_size
14892 + bitmap_size
14893 + bitmap_size
14894 + bitmap_size
14895 + bitmap_size
14896 + bitmap_size
14897 + bitmap_size
14898 + size_bfs
14899 + size_combs
14900 + size_digests
14901 + size_esalts
14902 + size_hooks
14903 + size_markov_css
14904 + size_plains
14905 + size_pws
14906 + size_pws // not a bug
14907 + size_results
14908 + size_root_css
14909 + size_rules
14910 + size_rules_c
14911 + size_salts
14912 + size_scryptV
14913 + size_shown
14914 + size_tm
14915 + size_tmps;
14916
14917 // Don't ask me, ask AMD!
14918
14919 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14920 if (size_total > device_param->device_global_mem) skip = 1;
14921
14922 if (skip == 1)
14923 {
14924 kernel_accel_max--;
14925
14926 continue;
14927 }
14928
14929 break;
14930 }
14931
14932 /*
14933 if (kernel_accel_max == 0)
14934 {
14935 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14936
14937 return -1;
14938 }
14939 */
14940
14941 device_param->kernel_accel_min = kernel_accel_min;
14942 device_param->kernel_accel_max = kernel_accel_max;
14943
14944 /*
14945 if (kernel_accel_max < kernel_accel)
14946 {
14947 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14948
14949 device_param->kernel_accel = kernel_accel_max;
14950 }
14951 */
14952
14953 device_param->size_bfs = size_bfs;
14954 device_param->size_combs = size_combs;
14955 device_param->size_rules = size_rules;
14956 device_param->size_rules_c = size_rules_c;
14957 device_param->size_pws = size_pws;
14958 device_param->size_tmps = size_tmps;
14959 device_param->size_hooks = size_hooks;
14960
14961 /**
14962 * default building options
14963 */
14964
14965 char build_opts[1024] = { 0 };
14966
14967 // we don't have sm_* on vendors not NV but it doesn't matter
14968
14969 #if _WIN
14970 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);
14971 #else
14972 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);
14973 #endif
14974
14975 char build_opts_new[1024] = { 0 };
14976
14977 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);
14978
14979 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14980
14981 /*
14982 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14983 {
14984 // we do vectorizing much better than the auto-vectorizer
14985
14986 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14987
14988 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14989 }
14990 */
14991
14992 #ifdef DEBUG
14993 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14994 #endif
14995
14996 /**
14997 * main kernel
14998 */
14999
15000 {
15001 /**
15002 * kernel source filename
15003 */
15004
15005 char source_file[256] = { 0 };
15006
15007 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15008
15009 struct stat sst;
15010
15011 if (stat (source_file, &sst) == -1)
15012 {
15013 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15014
15015 return -1;
15016 }
15017
15018 /**
15019 * kernel cached filename
15020 */
15021
15022 char cached_file[256] = { 0 };
15023
15024 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15025
15026 int cached = 1;
15027
15028 struct stat cst;
15029
15030 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15031 {
15032 cached = 0;
15033 }
15034
15035 /**
15036 * kernel compile or load
15037 */
15038
15039 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15040
15041 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15042
15043 if (force_jit_compilation == -1)
15044 {
15045 if (cached == 0)
15046 {
15047 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15048
15049 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15050
15051 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15052
15053 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15054
15055 #ifdef DEBUG
15056 size_t build_log_size = 0;
15057
15058 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15059
15060 if (build_log_size > 1)
15061 {
15062 char *build_log = (char *) malloc (build_log_size + 1);
15063
15064 memset (build_log, 0, build_log_size + 1);
15065
15066 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15067
15068 puts (build_log);
15069
15070 free (build_log);
15071 }
15072 #endif
15073
15074 if (rc != 0)
15075 {
15076 device_param->skipped = true;
15077
15078 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15079
15080 continue;
15081 }
15082
15083 size_t binary_size;
15084
15085 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15086
15087 u8 *binary = (u8 *) mymalloc (binary_size);
15088
15089 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15090
15091 writeProgramBin (cached_file, binary, binary_size);
15092
15093 local_free (binary);
15094 }
15095 else
15096 {
15097 #ifdef DEBUG
15098 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15099 #endif
15100
15101 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15102
15103 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15104
15105 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15106 }
15107 }
15108 else
15109 {
15110 #ifdef DEBUG
15111 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15112 #endif
15113
15114 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15115
15116 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15117
15118 char build_opts_update[1024] = { 0 };
15119
15120 if (force_jit_compilation == 1500)
15121 {
15122 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15123 }
15124 else if (force_jit_compilation == 8900)
15125 {
15126 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);
15127 }
15128 else
15129 {
15130 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15131 }
15132
15133 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15134
15135 #ifdef DEBUG
15136 size_t build_log_size = 0;
15137
15138 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15139
15140 if (build_log_size > 1)
15141 {
15142 char *build_log = (char *) malloc (build_log_size + 1);
15143
15144 memset (build_log, 0, build_log_size + 1);
15145
15146 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15147
15148 puts (build_log);
15149
15150 free (build_log);
15151 }
15152 #endif
15153
15154 if (rc != 0)
15155 {
15156 device_param->skipped = true;
15157
15158 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15159 }
15160 }
15161
15162 local_free (kernel_lengths);
15163 local_free (kernel_sources[0]);
15164 local_free (kernel_sources);
15165 }
15166
15167 /**
15168 * word generator kernel
15169 */
15170
15171 if (attack_mode != ATTACK_MODE_STRAIGHT)
15172 {
15173 /**
15174 * kernel mp source filename
15175 */
15176
15177 char source_file[256] = { 0 };
15178
15179 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15180
15181 struct stat sst;
15182
15183 if (stat (source_file, &sst) == -1)
15184 {
15185 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15186
15187 return -1;
15188 }
15189
15190 /**
15191 * kernel mp cached filename
15192 */
15193
15194 char cached_file[256] = { 0 };
15195
15196 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15197
15198 int cached = 1;
15199
15200 struct stat cst;
15201
15202 if (stat (cached_file, &cst) == -1)
15203 {
15204 cached = 0;
15205 }
15206
15207 /**
15208 * kernel compile or load
15209 */
15210
15211 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15212
15213 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15214
15215 if (cached == 0)
15216 {
15217 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15218 if (quiet == 0) log_info ("");
15219
15220 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15221
15222 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15223
15224 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15225
15226 if (rc != 0)
15227 {
15228 device_param->skipped = true;
15229
15230 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15231
15232 continue;
15233 }
15234
15235 size_t binary_size;
15236
15237 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15238
15239 u8 *binary = (u8 *) mymalloc (binary_size);
15240
15241 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15242
15243 writeProgramBin (cached_file, binary, binary_size);
15244
15245 local_free (binary);
15246 }
15247 else
15248 {
15249 #ifdef DEBUG
15250 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15251 #endif
15252
15253 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15254
15255 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15256
15257 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15258 }
15259
15260 local_free (kernel_lengths);
15261 local_free (kernel_sources[0]);
15262 local_free (kernel_sources);
15263 }
15264
15265 /**
15266 * amplifier kernel
15267 */
15268
15269 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15270 {
15271
15272 }
15273 else
15274 {
15275 /**
15276 * kernel amp source filename
15277 */
15278
15279 char source_file[256] = { 0 };
15280
15281 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15282
15283 struct stat sst;
15284
15285 if (stat (source_file, &sst) == -1)
15286 {
15287 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15288
15289 return -1;
15290 }
15291
15292 /**
15293 * kernel amp cached filename
15294 */
15295
15296 char cached_file[256] = { 0 };
15297
15298 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15299
15300 int cached = 1;
15301
15302 struct stat cst;
15303
15304 if (stat (cached_file, &cst) == -1)
15305 {
15306 cached = 0;
15307 }
15308
15309 /**
15310 * kernel compile or load
15311 */
15312
15313 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15314
15315 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15316
15317 if (cached == 0)
15318 {
15319 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15320 if (quiet == 0) log_info ("");
15321
15322 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15323
15324 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15325
15326 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15327
15328 if (rc != 0)
15329 {
15330 device_param->skipped = true;
15331
15332 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15333
15334 continue;
15335 }
15336
15337 size_t binary_size;
15338
15339 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15340
15341 u8 *binary = (u8 *) mymalloc (binary_size);
15342
15343 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15344
15345 writeProgramBin (cached_file, binary, binary_size);
15346
15347 local_free (binary);
15348 }
15349 else
15350 {
15351 #ifdef DEBUG
15352 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15353 #endif
15354
15355 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15356
15357 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15358
15359 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15360 }
15361
15362 local_free (kernel_lengths);
15363 local_free (kernel_sources[0]);
15364 local_free (kernel_sources);
15365 }
15366
15367 // some algorithm collide too fast, make that impossible
15368
15369 if (benchmark == 1)
15370 {
15371 ((uint *) digests_buf)[0] = -1;
15372 ((uint *) digests_buf)[1] = -1;
15373 ((uint *) digests_buf)[2] = -1;
15374 ((uint *) digests_buf)[3] = -1;
15375 }
15376
15377 /**
15378 * global buffers
15379 */
15380
15381 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15382 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15383 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15384 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15385 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15386 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15387 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15388 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15389 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15390 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15391 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15392 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15393 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15394 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15395 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15396 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15397 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15398 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15399
15400 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);
15401 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);
15402 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);
15403 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);
15404 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);
15405 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);
15406 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);
15407 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);
15408 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15409 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15410 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15411
15412 /**
15413 * special buffers
15414 */
15415
15416 if (attack_kern == ATTACK_KERN_STRAIGHT)
15417 {
15418 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15419 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15420
15421 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15422 }
15423 else if (attack_kern == ATTACK_KERN_COMBI)
15424 {
15425 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15426 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15427 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15428 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15429 }
15430 else if (attack_kern == ATTACK_KERN_BF)
15431 {
15432 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15433 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15434 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15435 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15436 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15437 }
15438
15439 if (size_esalts)
15440 {
15441 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15442
15443 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15444 }
15445
15446 /**
15447 * main host data
15448 */
15449
15450 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15451
15452 device_param->pws_buf = pws_buf;
15453
15454 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15455
15456 device_param->combs_buf = combs_buf;
15457
15458 void *hooks_buf = mymalloc (size_hooks);
15459
15460 device_param->hooks_buf = hooks_buf;
15461
15462 /**
15463 * kernel args
15464 */
15465
15466 device_param->kernel_params_buf32[21] = bitmap_mask;
15467 device_param->kernel_params_buf32[22] = bitmap_shift1;
15468 device_param->kernel_params_buf32[23] = bitmap_shift2;
15469 device_param->kernel_params_buf32[24] = 0; // salt_pos
15470 device_param->kernel_params_buf32[25] = 0; // loop_pos
15471 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15472 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15473 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15474 device_param->kernel_params_buf32[29] = 0; // digests_offset
15475 device_param->kernel_params_buf32[30] = 0; // combs_mode
15476 device_param->kernel_params_buf32[31] = 0; // gid_max
15477
15478 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15479 ? &device_param->d_pws_buf
15480 : &device_param->d_pws_amp_buf;
15481 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15482 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15483 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15484 device_param->kernel_params[ 4] = &device_param->d_tmps;
15485 device_param->kernel_params[ 5] = &device_param->d_hooks;
15486 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15487 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15488 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15489 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15490 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15491 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15492 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15493 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15494 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15495 device_param->kernel_params[15] = &device_param->d_digests_buf;
15496 device_param->kernel_params[16] = &device_param->d_digests_shown;
15497 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15498 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15499 device_param->kernel_params[19] = &device_param->d_result;
15500 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15501 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15502 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15503 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15504 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15505 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15506 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15507 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15508 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15509 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15510 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15511 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15512
15513 device_param->kernel_params_mp_buf64[3] = 0;
15514 device_param->kernel_params_mp_buf32[4] = 0;
15515 device_param->kernel_params_mp_buf32[5] = 0;
15516 device_param->kernel_params_mp_buf32[6] = 0;
15517 device_param->kernel_params_mp_buf32[7] = 0;
15518 device_param->kernel_params_mp_buf32[8] = 0;
15519
15520 device_param->kernel_params_mp[0] = NULL;
15521 device_param->kernel_params_mp[1] = NULL;
15522 device_param->kernel_params_mp[2] = NULL;
15523 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15524 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15525 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15526 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15527 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15528 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15529
15530 device_param->kernel_params_mp_l_buf64[3] = 0;
15531 device_param->kernel_params_mp_l_buf32[4] = 0;
15532 device_param->kernel_params_mp_l_buf32[5] = 0;
15533 device_param->kernel_params_mp_l_buf32[6] = 0;
15534 device_param->kernel_params_mp_l_buf32[7] = 0;
15535 device_param->kernel_params_mp_l_buf32[8] = 0;
15536 device_param->kernel_params_mp_l_buf32[9] = 0;
15537
15538 device_param->kernel_params_mp_l[0] = NULL;
15539 device_param->kernel_params_mp_l[1] = NULL;
15540 device_param->kernel_params_mp_l[2] = NULL;
15541 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15542 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15543 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15544 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15545 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15546 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15547 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15548
15549 device_param->kernel_params_mp_r_buf64[3] = 0;
15550 device_param->kernel_params_mp_r_buf32[4] = 0;
15551 device_param->kernel_params_mp_r_buf32[5] = 0;
15552 device_param->kernel_params_mp_r_buf32[6] = 0;
15553 device_param->kernel_params_mp_r_buf32[7] = 0;
15554 device_param->kernel_params_mp_r_buf32[8] = 0;
15555
15556 device_param->kernel_params_mp_r[0] = NULL;
15557 device_param->kernel_params_mp_r[1] = NULL;
15558 device_param->kernel_params_mp_r[2] = NULL;
15559 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15560 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15561 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15562 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15563 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15564 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15565
15566 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15567 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15568
15569 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15570 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15571 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15572 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15573 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15574 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15575 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15576
15577 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15578 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15579
15580 device_param->kernel_params_memset_buf32[1] = 0; // value
15581 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15582
15583 device_param->kernel_params_memset[0] = NULL;
15584 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15585 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15586
15587 /**
15588 * kernel name
15589 */
15590
15591 size_t kernel_wgs_tmp;
15592
15593 char kernel_name[64] = { 0 };
15594
15595 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15596 {
15597 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15598 {
15599 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15600
15601 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15602
15603 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15604
15605 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15606
15607 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15608
15609 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15610 }
15611 else
15612 {
15613 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15614
15615 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15616
15617 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15618
15619 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15620
15621 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15622
15623 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15624 }
15625
15626 if (data.attack_mode == ATTACK_MODE_BF)
15627 {
15628 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15629 {
15630 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15631
15632 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15633
15634 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);
15635 }
15636 }
15637 }
15638 else
15639 {
15640 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15641
15642 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15643
15644 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15645
15646 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15647
15648 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15649
15650 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15651
15652 if (opts_type & OPTS_TYPE_HOOK12)
15653 {
15654 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15655
15656 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15657
15658 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);
15659 }
15660
15661 if (opts_type & OPTS_TYPE_HOOK23)
15662 {
15663 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15664
15665 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15666
15667 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);
15668 }
15669 }
15670
15671 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);
15672 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);
15673 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);
15674
15675 for (uint i = 0; i <= 20; i++)
15676 {
15677 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15678 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15679 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15680
15681 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15682 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15683 }
15684
15685 for (uint i = 21; i <= 31; i++)
15686 {
15687 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15688 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15689 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15690
15691 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15692 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15693 }
15694
15695 // GPU memset
15696
15697 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15698
15699 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);
15700
15701 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15702 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15703 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15704
15705 // MP start
15706
15707 if (attack_mode == ATTACK_MODE_BF)
15708 {
15709 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15710 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15711
15712 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);
15713 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);
15714
15715 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15716 {
15717 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15718 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15719 }
15720 }
15721 else if (attack_mode == ATTACK_MODE_HYBRID1)
15722 {
15723 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15724
15725 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);
15726 }
15727 else if (attack_mode == ATTACK_MODE_HYBRID2)
15728 {
15729 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15730
15731 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);
15732 }
15733
15734 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15735 {
15736 // nothing to do
15737 }
15738 else
15739 {
15740 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15741
15742 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);
15743 }
15744
15745 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15746 {
15747 // nothing to do
15748 }
15749 else
15750 {
15751 for (uint i = 0; i < 5; i++)
15752 {
15753 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15754 }
15755
15756 for (uint i = 5; i < 7; i++)
15757 {
15758 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15759 }
15760 }
15761
15762 // maybe this has been updated by clGetKernelWorkGroupInfo()
15763 // value can only be decreased, so we don't need to reallocate buffers
15764
15765 device_param->kernel_threads = kernel_threads;
15766
15767 // zero some data buffers
15768
15769 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15770 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15771 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15772 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15773 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15774 run_kernel_bzero (device_param, device_param->d_result, size_results);
15775
15776 /**
15777 * special buffers
15778 */
15779
15780 if (attack_kern == ATTACK_KERN_STRAIGHT)
15781 {
15782 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15783 }
15784 else if (attack_kern == ATTACK_KERN_COMBI)
15785 {
15786 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15787 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15788 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15789 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15790 }
15791 else if (attack_kern == ATTACK_KERN_BF)
15792 {
15793 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15794 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15795 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15796 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15797 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15798 }
15799
15800 #if defined(HAVE_HWMON)
15801
15802 /**
15803 * Store initial fanspeed if gpu_temp_retain is enabled
15804 */
15805
15806 if (gpu_temp_disable == 0)
15807 {
15808 if (gpu_temp_retain != 0)
15809 {
15810 hc_thread_mutex_lock (mux_adl);
15811
15812 if (data.hm_device[device_id].fan_get_supported == 1)
15813 {
15814 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
15815 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
15816
15817 temp_retain_fanspeed_value[device_id] = fanspeed;
15818 temp_retain_fanpolicy_value[device_id] = fanpolicy;
15819
15820 // we also set it to tell the OS we take control over the fan and it's automatic controller
15821 // if it was set to automatic. we do not control user-defined fanspeeds.
15822
15823 if (fanpolicy == 1)
15824 {
15825 data.hm_device[device_id].fan_set_supported = 1;
15826
15827 int rc = -1;
15828
15829 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15830 {
15831 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
15832 }
15833 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15834 {
15835
15836 }
15837
15838 if (rc == 0)
15839 {
15840 data.hm_device[device_id].fan_set_supported = 1;
15841 }
15842 else
15843 {
15844 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
15845
15846 data.hm_device[device_id].fan_set_supported = 0;
15847 }
15848 }
15849 else
15850 {
15851 data.hm_device[device_id].fan_set_supported = 0;
15852 }
15853 }
15854
15855 hc_thread_mutex_unlock (mux_adl);
15856 }
15857 }
15858
15859 #endif // HAVE_HWMON
15860 }
15861
15862 if (data.quiet == 0) log_info_nn ("");
15863
15864 /**
15865 * In benchmark-mode, inform user which algorithm is checked
15866 */
15867
15868 if (benchmark == 1)
15869 {
15870 if (machine_readable == 0)
15871 {
15872 quiet = 0;
15873
15874 data.quiet = quiet;
15875
15876 char *hash_type = strhashtype (data.hash_mode); // not a bug
15877
15878 log_info ("Hashtype: %s", hash_type);
15879 log_info ("");
15880 }
15881 }
15882
15883 /**
15884 * keep track of the progress
15885 */
15886
15887 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15888 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15889 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15890
15891 /**
15892 * open filehandles
15893 */
15894
15895 #if _WIN
15896 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15897 {
15898 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15899
15900 return (-1);
15901 }
15902
15903 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15904 {
15905 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15906
15907 return (-1);
15908 }
15909
15910 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15911 {
15912 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15913
15914 return (-1);
15915 }
15916 #endif
15917
15918 /**
15919 * dictionary pad
15920 */
15921
15922 segment_size *= (1024 * 1024);
15923
15924 data.segment_size = segment_size;
15925
15926 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15927
15928 wl_data->buf = (char *) mymalloc (segment_size);
15929 wl_data->avail = segment_size;
15930 wl_data->incr = segment_size;
15931 wl_data->cnt = 0;
15932 wl_data->pos = 0;
15933
15934 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15935
15936 data.wordlist_mode = wordlist_mode;
15937
15938 cs_t *css_buf = NULL;
15939 uint css_cnt = 0;
15940 uint dictcnt = 0;
15941 uint maskcnt = 1;
15942 char **masks = NULL;
15943 char **dictfiles = NULL;
15944
15945 uint mask_from_file = 0;
15946
15947 if (attack_mode == ATTACK_MODE_STRAIGHT)
15948 {
15949 if (wordlist_mode == WL_MODE_FILE)
15950 {
15951 int wls_left = myargc - (optind + 1);
15952
15953 for (int i = 0; i < wls_left; i++)
15954 {
15955 char *l0_filename = myargv[optind + 1 + i];
15956
15957 struct stat l0_stat;
15958
15959 if (stat (l0_filename, &l0_stat) == -1)
15960 {
15961 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15962
15963 return (-1);
15964 }
15965
15966 uint is_dir = S_ISDIR (l0_stat.st_mode);
15967
15968 if (is_dir == 0)
15969 {
15970 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15971
15972 dictcnt++;
15973
15974 dictfiles[dictcnt - 1] = l0_filename;
15975 }
15976 else
15977 {
15978 // do not allow --keyspace w/ a directory
15979
15980 if (keyspace == 1)
15981 {
15982 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15983
15984 return (-1);
15985 }
15986
15987 char **dictionary_files = NULL;
15988
15989 dictionary_files = scan_directory (l0_filename);
15990
15991 if (dictionary_files != NULL)
15992 {
15993 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15994
15995 for (int d = 0; dictionary_files[d] != NULL; d++)
15996 {
15997 char *l1_filename = dictionary_files[d];
15998
15999 struct stat l1_stat;
16000
16001 if (stat (l1_filename, &l1_stat) == -1)
16002 {
16003 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16004
16005 return (-1);
16006 }
16007
16008 if (S_ISREG (l1_stat.st_mode))
16009 {
16010 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16011
16012 dictcnt++;
16013
16014 dictfiles[dictcnt - 1] = strdup (l1_filename);
16015 }
16016 }
16017 }
16018
16019 local_free (dictionary_files);
16020 }
16021 }
16022
16023 if (dictcnt < 1)
16024 {
16025 log_error ("ERROR: No usable dictionary file found.");
16026
16027 return (-1);
16028 }
16029 }
16030 else if (wordlist_mode == WL_MODE_STDIN)
16031 {
16032 dictcnt = 1;
16033 }
16034 }
16035 else if (attack_mode == ATTACK_MODE_COMBI)
16036 {
16037 // display
16038
16039 char *dictfile1 = myargv[optind + 1 + 0];
16040 char *dictfile2 = myargv[optind + 1 + 1];
16041
16042 // find the bigger dictionary and use as base
16043
16044 FILE *fp1 = NULL;
16045 FILE *fp2 = NULL;
16046
16047 struct stat tmp_stat;
16048
16049 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16050 {
16051 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16052
16053 return (-1);
16054 }
16055
16056 if (stat (dictfile1, &tmp_stat) == -1)
16057 {
16058 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16059
16060 fclose (fp1);
16061
16062 return (-1);
16063 }
16064
16065 if (S_ISDIR (tmp_stat.st_mode))
16066 {
16067 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16068
16069 fclose (fp1);
16070
16071 return (-1);
16072 }
16073
16074 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16075 {
16076 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16077
16078 fclose (fp1);
16079
16080 return (-1);
16081 }
16082
16083 if (stat (dictfile2, &tmp_stat) == -1)
16084 {
16085 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16086
16087 fclose (fp1);
16088 fclose (fp2);
16089
16090 return (-1);
16091 }
16092
16093 if (S_ISDIR (tmp_stat.st_mode))
16094 {
16095 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16096
16097 fclose (fp1);
16098 fclose (fp2);
16099
16100 return (-1);
16101 }
16102
16103 data.combs_cnt = 1;
16104
16105 data.quiet = 1;
16106
16107 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16108
16109 data.quiet = quiet;
16110
16111 if (words1_cnt == 0)
16112 {
16113 log_error ("ERROR: %s: empty file", dictfile1);
16114
16115 fclose (fp1);
16116 fclose (fp2);
16117
16118 return (-1);
16119 }
16120
16121 data.combs_cnt = 1;
16122
16123 data.quiet = 1;
16124
16125 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16126
16127 data.quiet = quiet;
16128
16129 if (words2_cnt == 0)
16130 {
16131 log_error ("ERROR: %s: empty file", dictfile2);
16132
16133 fclose (fp1);
16134 fclose (fp2);
16135
16136 return (-1);
16137 }
16138
16139 fclose (fp1);
16140 fclose (fp2);
16141
16142 data.dictfile = dictfile1;
16143 data.dictfile2 = dictfile2;
16144
16145 if (words1_cnt >= words2_cnt)
16146 {
16147 data.combs_cnt = words2_cnt;
16148 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16149
16150 dictfiles = &data.dictfile;
16151
16152 dictcnt = 1;
16153 }
16154 else
16155 {
16156 data.combs_cnt = words1_cnt;
16157 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16158
16159 dictfiles = &data.dictfile2;
16160
16161 dictcnt = 1;
16162
16163 // we also have to switch wordlist related rules!
16164
16165 char *tmpc = data.rule_buf_l;
16166
16167 data.rule_buf_l = data.rule_buf_r;
16168 data.rule_buf_r = tmpc;
16169
16170 int tmpi = data.rule_len_l;
16171
16172 data.rule_len_l = data.rule_len_r;
16173 data.rule_len_r = tmpi;
16174 }
16175 }
16176 else if (attack_mode == ATTACK_MODE_BF)
16177 {
16178 char *mask = NULL;
16179
16180 maskcnt = 0;
16181
16182 if (benchmark == 0)
16183 {
16184 mask = myargv[optind + 1];
16185
16186 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16187
16188 if ((optind + 2) <= myargc)
16189 {
16190 struct stat file_stat;
16191
16192 if (stat (mask, &file_stat) == -1)
16193 {
16194 maskcnt = 1;
16195
16196 masks[maskcnt - 1] = mystrdup (mask);
16197 }
16198 else
16199 {
16200 int wls_left = myargc - (optind + 1);
16201
16202 uint masks_avail = INCR_MASKS;
16203
16204 for (int i = 0; i < wls_left; i++)
16205 {
16206 if (i != 0)
16207 {
16208 mask = myargv[optind + 1 + i];
16209
16210 if (stat (mask, &file_stat) == -1)
16211 {
16212 log_error ("ERROR: %s: %s", mask, strerror (errno));
16213
16214 return (-1);
16215 }
16216 }
16217
16218 uint is_file = S_ISREG (file_stat.st_mode);
16219
16220 if (is_file == 1)
16221 {
16222 FILE *mask_fp;
16223
16224 if ((mask_fp = fopen (mask, "r")) == NULL)
16225 {
16226 log_error ("ERROR: %s: %s", mask, strerror (errno));
16227
16228 return (-1);
16229 }
16230
16231 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16232
16233 while (!feof (mask_fp))
16234 {
16235 memset (line_buf, 0, HCBUFSIZ);
16236
16237 int line_len = fgetl (mask_fp, line_buf);
16238
16239 if (line_len == 0) continue;
16240
16241 if (line_buf[0] == '#') continue;
16242
16243 if (masks_avail == maskcnt)
16244 {
16245 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16246
16247 masks_avail += INCR_MASKS;
16248 }
16249
16250 masks[maskcnt] = mystrdup (line_buf);
16251
16252 maskcnt++;
16253 }
16254
16255 myfree (line_buf);
16256
16257 fclose (mask_fp);
16258 }
16259 else
16260 {
16261 log_error ("ERROR: %s: unsupported file-type", mask);
16262
16263 return (-1);
16264 }
16265 }
16266
16267 mask_from_file = 1;
16268 }
16269 }
16270 else
16271 {
16272 custom_charset_1 = (char *) "?l?d?u";
16273 custom_charset_2 = (char *) "?l?d";
16274 custom_charset_3 = (char *) "?l?d*!$@_";
16275
16276 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16277 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16278 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16279
16280 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16281
16282 wordlist_mode = WL_MODE_MASK;
16283
16284 data.wordlist_mode = wordlist_mode;
16285
16286 increment = 1;
16287
16288 maskcnt = 1;
16289 }
16290 }
16291 else
16292 {
16293 /**
16294 * generate full masks and charsets
16295 */
16296
16297 masks = (char **) mymalloc (sizeof (char *));
16298
16299 switch (hash_mode)
16300 {
16301 case 1731: pw_min = 5;
16302 pw_max = 5;
16303 mask = mystrdup ("?b?b?b?b?b");
16304 break;
16305 case 12500: pw_min = 5;
16306 pw_max = 5;
16307 mask = mystrdup ("?b?b?b?b?b");
16308 break;
16309 default: pw_min = 7;
16310 pw_max = 7;
16311 mask = mystrdup ("?b?b?b?b?b?b?b");
16312 break;
16313 }
16314
16315 maskcnt = 1;
16316
16317 masks[maskcnt - 1] = mystrdup (mask);
16318
16319 wordlist_mode = WL_MODE_MASK;
16320
16321 data.wordlist_mode = wordlist_mode;
16322
16323 increment = 1;
16324 }
16325
16326 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16327
16328 if (increment)
16329 {
16330 if (increment_min > pw_min) pw_min = increment_min;
16331
16332 if (increment_max < pw_max) pw_max = increment_max;
16333 }
16334 }
16335 else if (attack_mode == ATTACK_MODE_HYBRID1)
16336 {
16337 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16338
16339 // display
16340
16341 char *mask = myargv[myargc - 1];
16342
16343 maskcnt = 0;
16344
16345 masks = (char **) mymalloc (1 * sizeof (char *));
16346
16347 // mod
16348
16349 struct stat file_stat;
16350
16351 if (stat (mask, &file_stat) == -1)
16352 {
16353 maskcnt = 1;
16354
16355 masks[maskcnt - 1] = mystrdup (mask);
16356 }
16357 else
16358 {
16359 uint is_file = S_ISREG (file_stat.st_mode);
16360
16361 if (is_file == 1)
16362 {
16363 FILE *mask_fp;
16364
16365 if ((mask_fp = fopen (mask, "r")) == NULL)
16366 {
16367 log_error ("ERROR: %s: %s", mask, strerror (errno));
16368
16369 return (-1);
16370 }
16371
16372 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16373
16374 uint masks_avail = 1;
16375
16376 while (!feof (mask_fp))
16377 {
16378 memset (line_buf, 0, HCBUFSIZ);
16379
16380 int line_len = fgetl (mask_fp, line_buf);
16381
16382 if (line_len == 0) continue;
16383
16384 if (line_buf[0] == '#') continue;
16385
16386 if (masks_avail == maskcnt)
16387 {
16388 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16389
16390 masks_avail += INCR_MASKS;
16391 }
16392
16393 masks[maskcnt] = mystrdup (line_buf);
16394
16395 maskcnt++;
16396 }
16397
16398 myfree (line_buf);
16399
16400 fclose (mask_fp);
16401
16402 mask_from_file = 1;
16403 }
16404 else
16405 {
16406 maskcnt = 1;
16407
16408 masks[maskcnt - 1] = mystrdup (mask);
16409 }
16410 }
16411
16412 // base
16413
16414 int wls_left = myargc - (optind + 2);
16415
16416 for (int i = 0; i < wls_left; i++)
16417 {
16418 char *filename = myargv[optind + 1 + i];
16419
16420 struct stat file_stat;
16421
16422 if (stat (filename, &file_stat) == -1)
16423 {
16424 log_error ("ERROR: %s: %s", filename, strerror (errno));
16425
16426 return (-1);
16427 }
16428
16429 uint is_dir = S_ISDIR (file_stat.st_mode);
16430
16431 if (is_dir == 0)
16432 {
16433 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16434
16435 dictcnt++;
16436
16437 dictfiles[dictcnt - 1] = filename;
16438 }
16439 else
16440 {
16441 // do not allow --keyspace w/ a directory
16442
16443 if (keyspace == 1)
16444 {
16445 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16446
16447 return (-1);
16448 }
16449
16450 char **dictionary_files = NULL;
16451
16452 dictionary_files = scan_directory (filename);
16453
16454 if (dictionary_files != NULL)
16455 {
16456 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16457
16458 for (int d = 0; dictionary_files[d] != NULL; d++)
16459 {
16460 char *l1_filename = dictionary_files[d];
16461
16462 struct stat l1_stat;
16463
16464 if (stat (l1_filename, &l1_stat) == -1)
16465 {
16466 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16467
16468 return (-1);
16469 }
16470
16471 if (S_ISREG (l1_stat.st_mode))
16472 {
16473 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16474
16475 dictcnt++;
16476
16477 dictfiles[dictcnt - 1] = strdup (l1_filename);
16478 }
16479 }
16480 }
16481
16482 local_free (dictionary_files);
16483 }
16484 }
16485
16486 if (dictcnt < 1)
16487 {
16488 log_error ("ERROR: No usable dictionary file found.");
16489
16490 return (-1);
16491 }
16492
16493 if (increment)
16494 {
16495 maskcnt = 0;
16496
16497 uint mask_min = increment_min; // we can't reject smaller masks here
16498 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16499
16500 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16501 {
16502 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16503
16504 if (cur_mask == NULL) break;
16505
16506 masks[maskcnt] = cur_mask;
16507
16508 maskcnt++;
16509
16510 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16511 }
16512 }
16513 }
16514 else if (attack_mode == ATTACK_MODE_HYBRID2)
16515 {
16516 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16517
16518 // display
16519
16520 char *mask = myargv[optind + 1 + 0];
16521
16522 maskcnt = 0;
16523
16524 masks = (char **) mymalloc (1 * sizeof (char *));
16525
16526 // mod
16527
16528 struct stat file_stat;
16529
16530 if (stat (mask, &file_stat) == -1)
16531 {
16532 maskcnt = 1;
16533
16534 masks[maskcnt - 1] = mystrdup (mask);
16535 }
16536 else
16537 {
16538 uint is_file = S_ISREG (file_stat.st_mode);
16539
16540 if (is_file == 1)
16541 {
16542 FILE *mask_fp;
16543
16544 if ((mask_fp = fopen (mask, "r")) == NULL)
16545 {
16546 log_error ("ERROR: %s: %s", mask, strerror (errno));
16547
16548 return (-1);
16549 }
16550
16551 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16552
16553 uint masks_avail = 1;
16554
16555 while (!feof (mask_fp))
16556 {
16557 memset (line_buf, 0, HCBUFSIZ);
16558
16559 int line_len = fgetl (mask_fp, line_buf);
16560
16561 if (line_len == 0) continue;
16562
16563 if (line_buf[0] == '#') continue;
16564
16565 if (masks_avail == maskcnt)
16566 {
16567 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16568
16569 masks_avail += INCR_MASKS;
16570 }
16571
16572 masks[maskcnt] = mystrdup (line_buf);
16573
16574 maskcnt++;
16575 }
16576
16577 myfree (line_buf);
16578
16579 fclose (mask_fp);
16580
16581 mask_from_file = 1;
16582 }
16583 else
16584 {
16585 maskcnt = 1;
16586
16587 masks[maskcnt - 1] = mystrdup (mask);
16588 }
16589 }
16590
16591 // base
16592
16593 int wls_left = myargc - (optind + 2);
16594
16595 for (int i = 0; i < wls_left; i++)
16596 {
16597 char *filename = myargv[optind + 2 + i];
16598
16599 struct stat file_stat;
16600
16601 if (stat (filename, &file_stat) == -1)
16602 {
16603 log_error ("ERROR: %s: %s", filename, strerror (errno));
16604
16605 return (-1);
16606 }
16607
16608 uint is_dir = S_ISDIR (file_stat.st_mode);
16609
16610 if (is_dir == 0)
16611 {
16612 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16613
16614 dictcnt++;
16615
16616 dictfiles[dictcnt - 1] = filename;
16617 }
16618 else
16619 {
16620 // do not allow --keyspace w/ a directory
16621
16622 if (keyspace == 1)
16623 {
16624 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16625
16626 return (-1);
16627 }
16628
16629 char **dictionary_files = NULL;
16630
16631 dictionary_files = scan_directory (filename);
16632
16633 if (dictionary_files != NULL)
16634 {
16635 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16636
16637 for (int d = 0; dictionary_files[d] != NULL; d++)
16638 {
16639 char *l1_filename = dictionary_files[d];
16640
16641 struct stat l1_stat;
16642
16643 if (stat (l1_filename, &l1_stat) == -1)
16644 {
16645 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16646
16647 return (-1);
16648 }
16649
16650 if (S_ISREG (l1_stat.st_mode))
16651 {
16652 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16653
16654 dictcnt++;
16655
16656 dictfiles[dictcnt - 1] = strdup (l1_filename);
16657 }
16658 }
16659 }
16660
16661 local_free (dictionary_files);
16662 }
16663 }
16664
16665 if (dictcnt < 1)
16666 {
16667 log_error ("ERROR: No usable dictionary file found.");
16668
16669 return (-1);
16670 }
16671
16672 if (increment)
16673 {
16674 maskcnt = 0;
16675
16676 uint mask_min = increment_min; // we can't reject smaller masks here
16677 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16678
16679 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16680 {
16681 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16682
16683 if (cur_mask == NULL) break;
16684
16685 masks[maskcnt] = cur_mask;
16686
16687 maskcnt++;
16688
16689 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16690 }
16691 }
16692 }
16693
16694 data.pw_min = pw_min;
16695 data.pw_max = pw_max;
16696
16697 /**
16698 * weak hash check
16699 */
16700
16701 if (weak_hash_threshold >= salts_cnt)
16702 {
16703 hc_device_param_t *device_param = NULL;
16704
16705 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16706 {
16707 device_param = &data.devices_param[device_id];
16708
16709 if (device_param->skipped) continue;
16710
16711 break;
16712 }
16713
16714 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16715
16716 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16717 {
16718 weak_hash_check (device_param, salt_pos);
16719 }
16720
16721 // Display hack, guarantee that there is at least one \r before real start
16722
16723 //if (data.quiet == 0) log_info ("");
16724 }
16725
16726 /**
16727 * status and monitor threads
16728 */
16729
16730 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16731
16732 hc_thread_t i_thread = 0;
16733
16734 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16735 {
16736 hc_thread_create (i_thread, thread_keypress, &benchmark);
16737 }
16738
16739 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16740
16741 uint ni_threads_cnt = 0;
16742
16743 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16744
16745 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16746
16747 ni_threads_cnt++;
16748
16749 /**
16750 * Outfile remove
16751 */
16752
16753 if (keyspace == 0)
16754 {
16755 if (outfile_check_timer != 0)
16756 {
16757 if (data.outfile_check_directory != NULL)
16758 {
16759 if ((hash_mode != 5200) &&
16760 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16761 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16762 (hash_mode != 9000))
16763 {
16764 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16765
16766 ni_threads_cnt++;
16767 }
16768 else
16769 {
16770 outfile_check_timer = 0;
16771 }
16772 }
16773 else
16774 {
16775 outfile_check_timer = 0;
16776 }
16777 }
16778 }
16779
16780 /**
16781 * Inform the user if we got some hashes remove because of the pot file remove feature
16782 */
16783
16784 if (data.quiet == 0)
16785 {
16786 if (potfile_remove_cracks > 0)
16787 {
16788 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16789 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16790 }
16791 }
16792
16793 data.outfile_check_timer = outfile_check_timer;
16794
16795 /**
16796 * main loop
16797 */
16798
16799 char **induction_dictionaries = NULL;
16800
16801 int induction_dictionaries_cnt = 0;
16802
16803 hcstat_table_t *root_table_buf = NULL;
16804 hcstat_table_t *markov_table_buf = NULL;
16805
16806 uint initial_restore_done = 0;
16807
16808 data.maskcnt = maskcnt;
16809
16810 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16811 {
16812 if (data.devices_status == STATUS_CRACKED) break;
16813
16814 data.devices_status = STATUS_INIT;
16815
16816 if (maskpos > rd->maskpos)
16817 {
16818 rd->dictpos = 0;
16819 }
16820
16821 rd->maskpos = maskpos;
16822 data.maskpos = maskpos;
16823
16824 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16825 {
16826 char *mask = masks[maskpos];
16827
16828 if (mask_from_file == 1)
16829 {
16830 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16831
16832 char *str_ptr;
16833 uint str_pos;
16834
16835 uint mask_offset = 0;
16836
16837 uint separator_cnt;
16838
16839 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16840 {
16841 str_ptr = strstr (mask + mask_offset, ",");
16842
16843 if (str_ptr == NULL) break;
16844
16845 str_pos = str_ptr - mask;
16846
16847 // escaped separator, i.e. "\,"
16848
16849 if (str_pos > 0)
16850 {
16851 if (mask[str_pos - 1] == '\\')
16852 {
16853 separator_cnt --;
16854
16855 mask_offset = str_pos + 1;
16856
16857 continue;
16858 }
16859 }
16860
16861 // reset the offset
16862
16863 mask_offset = 0;
16864
16865 mask[str_pos] = '\0';
16866
16867 switch (separator_cnt)
16868 {
16869 case 0:
16870 mp_reset_usr (mp_usr, 0);
16871
16872 custom_charset_1 = mask;
16873 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16874 break;
16875
16876 case 1:
16877 mp_reset_usr (mp_usr, 1);
16878
16879 custom_charset_2 = mask;
16880 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16881 break;
16882
16883 case 2:
16884 mp_reset_usr (mp_usr, 2);
16885
16886 custom_charset_3 = mask;
16887 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16888 break;
16889
16890 case 3:
16891 mp_reset_usr (mp_usr, 3);
16892
16893 custom_charset_4 = mask;
16894 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16895 break;
16896 }
16897
16898 mask = mask + str_pos + 1;
16899 }
16900 }
16901
16902 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16903 {
16904 if (maskpos > 0)
16905 {
16906 local_free (css_buf);
16907 local_free (data.root_css_buf);
16908 local_free (data.markov_css_buf);
16909
16910 local_free (masks[maskpos - 1]);
16911 }
16912
16913 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16914
16915 data.mask = mask;
16916 data.css_cnt = css_cnt;
16917 data.css_buf = css_buf;
16918
16919 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16920
16921 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16922
16923 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16924 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16925
16926 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16927
16928 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16929
16930 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16931 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16932
16933 data.root_css_buf = root_css_buf;
16934 data.markov_css_buf = markov_css_buf;
16935
16936 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16937
16938 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16939
16940 local_free (root_table_buf);
16941 local_free (markov_table_buf);
16942
16943 // args
16944
16945 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16946 {
16947 hc_device_param_t *device_param = &data.devices_param[device_id];
16948
16949 if (device_param->skipped) continue;
16950
16951 device_param->kernel_params_mp[0] = &device_param->d_combs;
16952 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16953 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16954
16955 device_param->kernel_params_mp_buf64[3] = 0;
16956 device_param->kernel_params_mp_buf32[4] = css_cnt;
16957 device_param->kernel_params_mp_buf32[5] = 0;
16958 device_param->kernel_params_mp_buf32[6] = 0;
16959 device_param->kernel_params_mp_buf32[7] = 0;
16960
16961 if (attack_mode == ATTACK_MODE_HYBRID1)
16962 {
16963 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16964 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16965 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16966 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16967 }
16968 else if (attack_mode == ATTACK_MODE_HYBRID2)
16969 {
16970 device_param->kernel_params_mp_buf32[5] = 0;
16971 device_param->kernel_params_mp_buf32[6] = 0;
16972 device_param->kernel_params_mp_buf32[7] = 0;
16973 }
16974
16975 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]);
16976 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]);
16977 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]);
16978
16979 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);
16980 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);
16981 }
16982 }
16983 else if (attack_mode == ATTACK_MODE_BF)
16984 {
16985 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16986
16987 if (increment)
16988 {
16989 for (uint i = 0; i < dictcnt; i++)
16990 {
16991 local_free (dictfiles[i]);
16992 }
16993
16994 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16995 {
16996 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16997
16998 if (l1_filename == NULL) break;
16999
17000 dictcnt++;
17001
17002 dictfiles[dictcnt - 1] = l1_filename;
17003 }
17004 }
17005 else
17006 {
17007 dictcnt++;
17008
17009 dictfiles[dictcnt - 1] = mask;
17010 }
17011
17012 if (dictcnt == 0)
17013 {
17014 log_error ("ERROR: Mask is too small");
17015
17016 return (-1);
17017 }
17018 }
17019 }
17020
17021 free (induction_dictionaries);
17022
17023 // induction_dictionaries_cnt = 0; // implied
17024
17025 if (attack_mode != ATTACK_MODE_BF)
17026 {
17027 if (keyspace == 0)
17028 {
17029 induction_dictionaries = scan_directory (induction_directory);
17030
17031 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17032 }
17033 }
17034
17035 if (induction_dictionaries_cnt)
17036 {
17037 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17038 }
17039
17040 /**
17041 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17042 */
17043 if (keyspace == 1)
17044 {
17045 if ((maskcnt > 1) || (dictcnt > 1))
17046 {
17047 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17048
17049 return (-1);
17050 }
17051 }
17052
17053 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17054 {
17055 char *subid = logfile_generate_subid ();
17056
17057 data.subid = subid;
17058
17059 logfile_sub_msg ("START");
17060
17061 data.devices_status = STATUS_INIT;
17062
17063 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17064 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17065 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17066
17067 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17068
17069 data.cpt_pos = 0;
17070
17071 data.cpt_start = time (NULL);
17072
17073 data.cpt_total = 0;
17074
17075 if (data.restore == 0)
17076 {
17077 rd->words_cur = skip;
17078
17079 skip = 0;
17080
17081 data.skip = 0;
17082 }
17083
17084 data.ms_paused = 0;
17085
17086 data.kernel_power_final = 0;
17087
17088 data.words_cur = rd->words_cur;
17089
17090 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17091 {
17092 hc_device_param_t *device_param = &data.devices_param[device_id];
17093
17094 if (device_param->skipped) continue;
17095
17096 device_param->speed_pos = 0;
17097
17098 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17099 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17100
17101 device_param->exec_pos = 0;
17102
17103 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17104
17105 device_param->outerloop_pos = 0;
17106 device_param->outerloop_left = 0;
17107 device_param->innerloop_pos = 0;
17108 device_param->innerloop_left = 0;
17109
17110 // some more resets:
17111
17112 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17113
17114 device_param->pws_cnt = 0;
17115
17116 device_param->words_off = 0;
17117 device_param->words_done = 0;
17118 }
17119
17120 // figure out some workload
17121
17122 if (attack_mode == ATTACK_MODE_STRAIGHT)
17123 {
17124 if (data.wordlist_mode == WL_MODE_FILE)
17125 {
17126 char *dictfile = NULL;
17127
17128 if (induction_dictionaries_cnt)
17129 {
17130 dictfile = induction_dictionaries[0];
17131 }
17132 else
17133 {
17134 dictfile = dictfiles[dictpos];
17135 }
17136
17137 data.dictfile = dictfile;
17138
17139 logfile_sub_string (dictfile);
17140
17141 for (uint i = 0; i < rp_files_cnt; i++)
17142 {
17143 logfile_sub_var_string ("rulefile", rp_files[i]);
17144 }
17145
17146 FILE *fd2 = fopen (dictfile, "rb");
17147
17148 if (fd2 == NULL)
17149 {
17150 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17151
17152 return (-1);
17153 }
17154
17155 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17156
17157 fclose (fd2);
17158
17159 if (data.words_cnt == 0)
17160 {
17161 if (data.devices_status == STATUS_CRACKED) break;
17162 if (data.devices_status == STATUS_ABORTED) break;
17163
17164 dictpos++;
17165
17166 continue;
17167 }
17168 }
17169 }
17170 else if (attack_mode == ATTACK_MODE_COMBI)
17171 {
17172 char *dictfile = data.dictfile;
17173 char *dictfile2 = data.dictfile2;
17174
17175 logfile_sub_string (dictfile);
17176 logfile_sub_string (dictfile2);
17177
17178 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17179 {
17180 FILE *fd2 = fopen (dictfile, "rb");
17181
17182 if (fd2 == NULL)
17183 {
17184 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17185
17186 return (-1);
17187 }
17188
17189 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17190
17191 fclose (fd2);
17192 }
17193 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17194 {
17195 FILE *fd2 = fopen (dictfile2, "rb");
17196
17197 if (fd2 == NULL)
17198 {
17199 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17200
17201 return (-1);
17202 }
17203
17204 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17205
17206 fclose (fd2);
17207 }
17208
17209 if (data.words_cnt == 0)
17210 {
17211 if (data.devices_status == STATUS_CRACKED) break;
17212 if (data.devices_status == STATUS_ABORTED) break;
17213
17214 dictpos++;
17215
17216 continue;
17217 }
17218 }
17219 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17220 {
17221 char *dictfile = NULL;
17222
17223 if (induction_dictionaries_cnt)
17224 {
17225 dictfile = induction_dictionaries[0];
17226 }
17227 else
17228 {
17229 dictfile = dictfiles[dictpos];
17230 }
17231
17232 data.dictfile = dictfile;
17233
17234 char *mask = data.mask;
17235
17236 logfile_sub_string (dictfile);
17237 logfile_sub_string (mask);
17238
17239 FILE *fd2 = fopen (dictfile, "rb");
17240
17241 if (fd2 == NULL)
17242 {
17243 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17244
17245 return (-1);
17246 }
17247
17248 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17249
17250 fclose (fd2);
17251
17252 if (data.words_cnt == 0)
17253 {
17254 if (data.devices_status == STATUS_CRACKED) break;
17255 if (data.devices_status == STATUS_ABORTED) break;
17256
17257 dictpos++;
17258
17259 continue;
17260 }
17261 }
17262 else if (attack_mode == ATTACK_MODE_BF)
17263 {
17264 local_free (css_buf);
17265 local_free (data.root_css_buf);
17266 local_free (data.markov_css_buf);
17267
17268 char *mask = dictfiles[dictpos];
17269
17270 logfile_sub_string (mask);
17271
17272 // base
17273
17274 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17275
17276 if (opts_type & OPTS_TYPE_PT_UNICODE)
17277 {
17278 uint css_cnt_unicode = css_cnt * 2;
17279
17280 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17281
17282 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17283 {
17284 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17285
17286 css_buf_unicode[j + 1].cs_buf[0] = 0;
17287 css_buf_unicode[j + 1].cs_len = 1;
17288 }
17289
17290 free (css_buf);
17291
17292 css_buf = css_buf_unicode;
17293 css_cnt = css_cnt_unicode;
17294 }
17295
17296 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17297
17298 uint mask_min = pw_min;
17299 uint mask_max = pw_max;
17300
17301 if (opts_type & OPTS_TYPE_PT_UNICODE)
17302 {
17303 mask_min *= 2;
17304 mask_max *= 2;
17305 }
17306
17307 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17308 {
17309 if (css_cnt < mask_min)
17310 {
17311 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17312 }
17313
17314 if (css_cnt > mask_max)
17315 {
17316 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17317 }
17318
17319 // skip to next mask
17320
17321 dictpos++;
17322
17323 rd->dictpos = dictpos;
17324
17325 logfile_sub_msg ("STOP");
17326
17327 continue;
17328 }
17329
17330 uint save_css_cnt = css_cnt;
17331
17332 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17333 {
17334 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17335 {
17336 uint salt_len = (uint) data.salts_buf[0].salt_len;
17337 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17338
17339 uint css_cnt_salt = css_cnt + salt_len;
17340
17341 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17342
17343 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17344
17345 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17346 {
17347 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17348 css_buf_salt[j].cs_len = 1;
17349 }
17350
17351 free (css_buf);
17352
17353 css_buf = css_buf_salt;
17354 css_cnt = css_cnt_salt;
17355 }
17356 }
17357
17358 data.mask = mask;
17359 data.css_cnt = css_cnt;
17360 data.css_buf = css_buf;
17361
17362 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17363
17364 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17365
17366 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17367
17368 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17369 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17370
17371 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17372
17373 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17374
17375 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17376 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17377
17378 data.root_css_buf = root_css_buf;
17379 data.markov_css_buf = markov_css_buf;
17380
17381 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17382
17383 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17384
17385 local_free (root_table_buf);
17386 local_free (markov_table_buf);
17387
17388 // copy + args
17389
17390 uint css_cnt_l = css_cnt;
17391 uint css_cnt_r;
17392
17393 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17394 {
17395 if (save_css_cnt < 6)
17396 {
17397 css_cnt_r = 1;
17398 }
17399 else if (save_css_cnt == 6)
17400 {
17401 css_cnt_r = 2;
17402 }
17403 else
17404 {
17405 if (opts_type & OPTS_TYPE_PT_UNICODE)
17406 {
17407 if (save_css_cnt == 8 || save_css_cnt == 10)
17408 {
17409 css_cnt_r = 2;
17410 }
17411 else
17412 {
17413 css_cnt_r = 4;
17414 }
17415 }
17416 else
17417 {
17418 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17419 {
17420 css_cnt_r = 3;
17421 }
17422 else
17423 {
17424 css_cnt_r = 4;
17425 }
17426 }
17427 }
17428 }
17429 else
17430 {
17431 css_cnt_r = 1;
17432
17433 /* unfinished code?
17434 int sum = css_buf[css_cnt_r - 1].cs_len;
17435
17436 for (uint i = 1; i < 4 && i < css_cnt; i++)
17437 {
17438 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17439
17440 css_cnt_r++;
17441
17442 sum *= css_buf[css_cnt_r - 1].cs_len;
17443 }
17444 */
17445 }
17446
17447 css_cnt_l -= css_cnt_r;
17448
17449 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17450
17451 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17452 {
17453 hc_device_param_t *device_param = &data.devices_param[device_id];
17454
17455 if (device_param->skipped) continue;
17456
17457 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17458 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17459 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17460
17461 device_param->kernel_params_mp_l_buf64[3] = 0;
17462 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17463 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17464 device_param->kernel_params_mp_l_buf32[6] = 0;
17465 device_param->kernel_params_mp_l_buf32[7] = 0;
17466 device_param->kernel_params_mp_l_buf32[8] = 0;
17467
17468 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17469 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17470 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17471 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17472
17473 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17474 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17475 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17476
17477 device_param->kernel_params_mp_r_buf64[3] = 0;
17478 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17479 device_param->kernel_params_mp_r_buf32[5] = 0;
17480 device_param->kernel_params_mp_r_buf32[6] = 0;
17481 device_param->kernel_params_mp_r_buf32[7] = 0;
17482
17483 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]);
17484 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]);
17485 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]);
17486
17487 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]);
17488 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]);
17489 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]);
17490
17491 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);
17492 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);
17493 }
17494 }
17495
17496 u64 words_base = data.words_cnt;
17497
17498 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17499 {
17500 if (data.kernel_rules_cnt)
17501 {
17502 words_base /= data.kernel_rules_cnt;
17503 }
17504 }
17505 else if (data.attack_kern == ATTACK_KERN_COMBI)
17506 {
17507 if (data.combs_cnt)
17508 {
17509 words_base /= data.combs_cnt;
17510 }
17511 }
17512 else if (data.attack_kern == ATTACK_KERN_BF)
17513 {
17514 if (data.bfs_cnt)
17515 {
17516 words_base /= data.bfs_cnt;
17517 }
17518 }
17519
17520 data.words_base = words_base;
17521
17522 if (keyspace == 1)
17523 {
17524 log_info ("%llu", (unsigned long long int) words_base);
17525
17526 return (0);
17527 }
17528
17529 if (data.words_cur > data.words_base)
17530 {
17531 log_error ("ERROR: restore value greater keyspace");
17532
17533 return (-1);
17534 }
17535
17536 if (data.words_cur)
17537 {
17538 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17539 {
17540 for (uint i = 0; i < data.salts_cnt; i++)
17541 {
17542 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17543 }
17544 }
17545 else if (data.attack_kern == ATTACK_KERN_COMBI)
17546 {
17547 for (uint i = 0; i < data.salts_cnt; i++)
17548 {
17549 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17550 }
17551 }
17552 else if (data.attack_kern == ATTACK_KERN_BF)
17553 {
17554 for (uint i = 0; i < data.salts_cnt; i++)
17555 {
17556 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17557 }
17558 }
17559 }
17560
17561 /*
17562 * Update loopback file
17563 */
17564
17565 if (loopback == 1)
17566 {
17567 time_t now;
17568
17569 time (&now);
17570
17571 uint random_num = get_random_num (0, 9999);
17572
17573 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17574
17575 data.loopback_file = loopback_file;
17576 }
17577
17578 /*
17579 * Update dictionary statistic
17580 */
17581
17582 if (keyspace == 0)
17583 {
17584 dictstat_fp = fopen (dictstat, "wb");
17585
17586 if (dictstat_fp)
17587 {
17588 lock_file (dictstat_fp);
17589
17590 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17591
17592 fclose (dictstat_fp);
17593 }
17594 }
17595
17596 /**
17597 * create autotune threads
17598 */
17599
17600 data.devices_status = STATUS_AUTOTUNE;
17601
17602 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17603
17604 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17605 {
17606 hc_device_param_t *device_param = &devices_param[device_id];
17607
17608 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
17609 }
17610
17611 hc_thread_wait (data.devices_cnt, c_threads);
17612
17613 /*
17614 * Inform user about possible slow speeds
17615 */
17616
17617 uint hardware_power_all = 0;
17618
17619 uint kernel_power_all = 0;
17620
17621 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17622 {
17623 hc_device_param_t *device_param = &devices_param[device_id];
17624
17625 hardware_power_all += device_param->hardware_power;
17626
17627 kernel_power_all += device_param->kernel_power;
17628 }
17629
17630 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
17631
17632 data.kernel_power_all = kernel_power_all;
17633
17634 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17635 {
17636 if (data.words_base < kernel_power_all)
17637 {
17638 if (quiet == 0)
17639 {
17640 log_info ("ATTENTION!");
17641 log_info (" The wordlist or mask you are using is too small.");
17642 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17643 log_info (" The cracking speed will drop.");
17644 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17645 log_info ("");
17646 }
17647 }
17648 }
17649
17650 /**
17651 * create cracker threads
17652 */
17653
17654 data.devices_status = STATUS_RUNNING;
17655
17656 if (initial_restore_done == 0)
17657 {
17658 if (data.restore_disable == 0) cycle_restore ();
17659
17660 initial_restore_done = 1;
17661 }
17662
17663 hc_timer_set (&data.timer_running);
17664
17665 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17666 {
17667 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17668 {
17669 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17670 if (quiet == 0) fflush (stdout);
17671 }
17672 }
17673 else if (wordlist_mode == WL_MODE_STDIN)
17674 {
17675 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17676 if (data.quiet == 0) log_info ("");
17677 }
17678
17679 time_t runtime_start;
17680
17681 time (&runtime_start);
17682
17683 data.runtime_start = runtime_start;
17684
17685 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17686 {
17687 hc_device_param_t *device_param = &devices_param[device_id];
17688
17689 if (wordlist_mode == WL_MODE_STDIN)
17690 {
17691 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17692 }
17693 else
17694 {
17695 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17696 }
17697 }
17698
17699 hc_thread_wait (data.devices_cnt, c_threads);
17700
17701 local_free (c_threads);
17702
17703 data.restore = 0;
17704
17705 // finalize task
17706
17707 logfile_sub_var_uint ("status-after-work", data.devices_status);
17708
17709 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17710
17711 if (data.devices_status == STATUS_CRACKED) break;
17712 if (data.devices_status == STATUS_ABORTED) break;
17713
17714 if (data.devices_status == STATUS_BYPASS)
17715 {
17716 data.devices_status = STATUS_RUNNING;
17717 }
17718
17719 if (induction_dictionaries_cnt)
17720 {
17721 unlink (induction_dictionaries[0]);
17722 }
17723
17724 free (induction_dictionaries);
17725
17726 if (attack_mode != ATTACK_MODE_BF)
17727 {
17728 induction_dictionaries = scan_directory (induction_directory);
17729
17730 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17731 }
17732
17733 if (benchmark == 0)
17734 {
17735 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17736 {
17737 if (quiet == 0) clear_prompt ();
17738
17739 if (quiet == 0) log_info ("");
17740
17741 if (status == 1)
17742 {
17743 status_display ();
17744 }
17745 else
17746 {
17747 if (quiet == 0) status_display ();
17748 }
17749
17750 if (quiet == 0) log_info ("");
17751 }
17752 }
17753
17754 if (attack_mode == ATTACK_MODE_BF)
17755 {
17756 dictpos++;
17757
17758 rd->dictpos = dictpos;
17759 }
17760 else
17761 {
17762 if (induction_dictionaries_cnt)
17763 {
17764 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17765 }
17766 else
17767 {
17768 dictpos++;
17769
17770 rd->dictpos = dictpos;
17771 }
17772 }
17773
17774 time_t runtime_stop;
17775
17776 time (&runtime_stop);
17777
17778 data.runtime_stop = runtime_stop;
17779
17780 logfile_sub_uint (runtime_start);
17781 logfile_sub_uint (runtime_stop);
17782
17783 logfile_sub_msg ("STOP");
17784
17785 global_free (subid);
17786 }
17787
17788 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17789
17790 if (data.devices_status == STATUS_CRACKED) break;
17791 if (data.devices_status == STATUS_ABORTED) break;
17792 if (data.devices_status == STATUS_QUIT) break;
17793
17794 if (data.devices_status == STATUS_BYPASS)
17795 {
17796 data.devices_status = STATUS_RUNNING;
17797 }
17798 }
17799
17800 // 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
17801
17802 if (attack_mode == ATTACK_MODE_STRAIGHT)
17803 {
17804 if (data.wordlist_mode == WL_MODE_FILE)
17805 {
17806 if (data.dictfile == NULL)
17807 {
17808 if (dictfiles != NULL)
17809 {
17810 data.dictfile = dictfiles[0];
17811
17812 hc_timer_set (&data.timer_running);
17813 }
17814 }
17815 }
17816 }
17817 // NOTE: combi is okay because it is already set beforehand
17818 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17819 {
17820 if (data.dictfile == NULL)
17821 {
17822 if (dictfiles != NULL)
17823 {
17824 hc_timer_set (&data.timer_running);
17825
17826 data.dictfile = dictfiles[0];
17827 }
17828 }
17829 }
17830 else if (attack_mode == ATTACK_MODE_BF)
17831 {
17832 if (data.mask == NULL)
17833 {
17834 hc_timer_set (&data.timer_running);
17835
17836 data.mask = masks[0];
17837 }
17838 }
17839
17840 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17841 {
17842 data.devices_status = STATUS_EXHAUSTED;
17843 }
17844
17845 // if cracked / aborted remove last induction dictionary
17846
17847 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17848 {
17849 struct stat induct_stat;
17850
17851 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17852 {
17853 unlink (induction_dictionaries[file_pos]);
17854 }
17855 }
17856
17857 // wait for non-interactive threads
17858
17859 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17860 {
17861 hc_thread_wait (1, &ni_threads[thread_idx]);
17862 }
17863
17864 local_free (ni_threads);
17865
17866 // wait for interactive threads
17867
17868 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17869 {
17870 hc_thread_wait (1, &i_thread);
17871 }
17872
17873 // we dont need restore file anymore
17874 if (data.restore_disable == 0)
17875 {
17876 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17877 {
17878 unlink (eff_restore_file);
17879 unlink (new_restore_file);
17880 }
17881 else
17882 {
17883 cycle_restore ();
17884 }
17885 }
17886
17887 // finally save left hashes
17888
17889 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17890 {
17891 save_hash ();
17892 }
17893
17894 /**
17895 * Clean up
17896 */
17897
17898 if (benchmark == 1)
17899 {
17900 status_benchmark ();
17901
17902 if (machine_readable == 0)
17903 {
17904 log_info ("");
17905 }
17906 }
17907 else
17908 {
17909 if (quiet == 0) clear_prompt ();
17910
17911 if (quiet == 0) log_info ("");
17912
17913 if (status == 1)
17914 {
17915 status_display ();
17916 }
17917 else
17918 {
17919 if (quiet == 0) status_display ();
17920 }
17921
17922 if (quiet == 0) log_info ("");
17923 }
17924
17925 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17926 {
17927 hc_device_param_t *device_param = &data.devices_param[device_id];
17928
17929 if (device_param->skipped) continue;
17930
17931 local_free (device_param->combs_buf);
17932
17933 local_free (device_param->hooks_buf);
17934
17935 local_free (device_param->device_name);
17936
17937 local_free (device_param->device_name_chksum);
17938
17939 local_free (device_param->device_version);
17940
17941 local_free (device_param->driver_version);
17942
17943 if (device_param->pws_buf) myfree (device_param->pws_buf);
17944 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17945 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17946 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17947 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17948 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17949 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17950 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17951 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17952 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17953 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17954 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17955 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17956 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17957 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17958 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17959 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17960 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17961 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17962 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17963 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17964 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17965 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17966 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17967 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17968 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17969 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17970 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17971 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17972
17973 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17974 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17975 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17976 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17977 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17978 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17979 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17980 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17981 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17982 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17983 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17984
17985 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17986 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17987 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17988
17989 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17990 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17991 }
17992
17993 // reset default fan speed
17994
17995 #ifdef HAVE_HWMON
17996 if (gpu_temp_disable == 0)
17997 {
17998 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17999 {
18000 hc_thread_mutex_lock (mux_adl);
18001
18002 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18003 {
18004 hc_device_param_t *device_param = &data.devices_param[device_id];
18005
18006 if (device_param->skipped) continue;
18007
18008 if (data.hm_device[device_id].fan_set_supported == 1)
18009 {
18010 int fanspeed = temp_retain_fanspeed_value[device_id];
18011 int fanpolicy = temp_retain_fanpolicy_value[device_id];
18012
18013 if (fanpolicy == 1)
18014 {
18015 int rc = -1;
18016
18017 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18018 {
18019 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
18020 }
18021 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18022 {
18023
18024 }
18025
18026 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18027 }
18028 }
18029 }
18030
18031 hc_thread_mutex_unlock (mux_adl);
18032 }
18033 }
18034
18035 // reset power tuning
18036
18037 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18038 {
18039 hc_thread_mutex_lock (mux_adl);
18040
18041 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18042 {
18043 hc_device_param_t *device_param = &data.devices_param[device_id];
18044
18045 if (device_param->skipped) continue;
18046
18047 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18048 {
18049 if (data.hm_device[device_id].od_version == 6)
18050 {
18051 // check powertune capabilities first, if not available then skip device
18052
18053 int powertune_supported = 0;
18054
18055 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18056 {
18057 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18058
18059 return (-1);
18060 }
18061
18062 if (powertune_supported != 0)
18063 {
18064 // powercontrol settings
18065
18066 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18067 {
18068 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18069
18070 return (-1);
18071 }
18072
18073 // clocks
18074
18075 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18076
18077 performance_state->iNumberOfPerformanceLevels = 2;
18078
18079 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18080 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18081 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18082 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18083
18084 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18085 {
18086 log_info ("ERROR: Failed to restore ADL performance state");
18087
18088 return (-1);
18089 }
18090
18091 local_free (performance_state);
18092 }
18093 }
18094 }
18095
18096 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18097 {
18098 unsigned int limit = nvml_power_limit[device_id];
18099
18100 if (limit > 0)
18101 {
18102 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18103 }
18104 }
18105 }
18106
18107 hc_thread_mutex_unlock (mux_adl);
18108 }
18109
18110 if (gpu_temp_disable == 0)
18111 {
18112 if (data.hm_nvml)
18113 {
18114 hm_NVML_nvmlShutdown (data.hm_nvml);
18115
18116 nvml_close (data.hm_nvml);
18117
18118 data.hm_nvml = NULL;
18119 }
18120
18121 if (data.hm_adl)
18122 {
18123 hm_ADL_Main_Control_Destroy (data.hm_adl);
18124
18125 adl_close (data.hm_adl);
18126
18127 data.hm_adl = NULL;
18128 }
18129 }
18130 #endif // HAVE_HWMON
18131
18132 // free memory
18133
18134 local_free (masks);
18135
18136 local_free (dictstat_base);
18137
18138 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18139 {
18140 pot_t *pot_ptr = &pot[pot_pos];
18141
18142 hash_t *hash = &pot_ptr->hash;
18143
18144 local_free (hash->digest);
18145
18146 if (isSalted)
18147 {
18148 local_free (hash->salt);
18149 }
18150 }
18151
18152 local_free (pot);
18153
18154 local_free (all_kernel_rules_cnt);
18155 local_free (all_kernel_rules_buf);
18156
18157 local_free (wl_data->buf);
18158 local_free (wl_data);
18159
18160 local_free (bitmap_s1_a);
18161 local_free (bitmap_s1_b);
18162 local_free (bitmap_s1_c);
18163 local_free (bitmap_s1_d);
18164 local_free (bitmap_s2_a);
18165 local_free (bitmap_s2_b);
18166 local_free (bitmap_s2_c);
18167 local_free (bitmap_s2_d);
18168
18169 #ifdef HAVE_HWMON
18170 local_free (temp_retain_fanspeed_value);
18171 local_free (od_clock_mem_status);
18172 local_free (od_power_control_status);
18173 local_free (nvml_power_limit);
18174 #endif
18175
18176 global_free (devices_param);
18177
18178 global_free (kernel_rules_buf);
18179
18180 global_free (root_css_buf);
18181 global_free (markov_css_buf);
18182
18183 global_free (digests_buf);
18184 global_free (digests_shown);
18185 global_free (digests_shown_tmp);
18186
18187 global_free (salts_buf);
18188 global_free (salts_shown);
18189
18190 global_free (esalts_buf);
18191
18192 global_free (words_progress_done);
18193 global_free (words_progress_rejected);
18194 global_free (words_progress_restored);
18195
18196 if (pot_fp) fclose (pot_fp);
18197
18198 if (data.devices_status == STATUS_QUIT) break;
18199 }
18200
18201 // destroy others mutex
18202
18203 hc_thread_mutex_delete (mux_dispatcher);
18204 hc_thread_mutex_delete (mux_counter);
18205 hc_thread_mutex_delete (mux_display);
18206 hc_thread_mutex_delete (mux_adl);
18207
18208 // free memory
18209
18210 local_free (eff_restore_file);
18211 local_free (new_restore_file);
18212
18213 local_free (rd);
18214
18215 // tuning db
18216
18217 tuning_db_destroy (tuning_db);
18218
18219 // loopback
18220
18221 local_free (loopback_file);
18222
18223 if (loopback == 1) unlink (loopback_file);
18224
18225 // induction directory
18226
18227 if (induction_dir == NULL)
18228 {
18229 if (attack_mode != ATTACK_MODE_BF)
18230 {
18231 if (rmdir (induction_directory) == -1)
18232 {
18233 if (errno == ENOENT)
18234 {
18235 // good, we can ignore
18236 }
18237 else if (errno == ENOTEMPTY)
18238 {
18239 // good, we can ignore
18240 }
18241 else
18242 {
18243 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18244
18245 return (-1);
18246 }
18247 }
18248
18249 local_free (induction_directory);
18250 }
18251 }
18252
18253 // outfile-check directory
18254
18255 if (outfile_check_dir == NULL)
18256 {
18257 if (rmdir (outfile_check_directory) == -1)
18258 {
18259 if (errno == ENOENT)
18260 {
18261 // good, we can ignore
18262 }
18263 else if (errno == ENOTEMPTY)
18264 {
18265 // good, we can ignore
18266 }
18267 else
18268 {
18269 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18270
18271 return (-1);
18272 }
18273 }
18274
18275 local_free (outfile_check_directory);
18276 }
18277
18278 time_t proc_stop;
18279
18280 time (&proc_stop);
18281
18282 logfile_top_uint (proc_start);
18283 logfile_top_uint (proc_stop);
18284
18285 logfile_top_msg ("STOP");
18286
18287 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18288 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18289
18290 if (data.ocl) ocl_close (data.ocl);
18291
18292 if (data.devices_status == STATUS_ABORTED) return 2;
18293 if (data.devices_status == STATUS_QUIT) return 2;
18294 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18295 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18296 if (data.devices_status == STATUS_CRACKED) return 0;
18297
18298 return -1;
18299 }
Hashcat additions to support pwdhash