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