projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Inform user about how to verify reported cracking speed
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define MACHINE_READABLE 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 0
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
152
153 #define NVIDIA_100PERCENTCPU_WORKAROUND 100
154
155 #define global_free(attr) \
156 { \
157 myfree ((void *) data.attr); \
158 \
159 data.attr = NULL; \
160 }
161
162 #define local_free(attr) \
163 { \
164 myfree ((void *) attr); \
165 \
166 attr = NULL; \
167 }
168
169 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
170 #define HC_API_CALL __stdcall
171 #else
172 #define HC_API_CALL
173 #endif
174
175 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
176 {
177 900,
178 0,
179 5100,
180 100,
181 1400,
182 10800,
183 1700,
184 5000,
185 10100,
186 6000,
187 6100,
188 6900,
189 11700,
190 11800,
191 400,
192 8900,
193 11900,
194 12000,
195 10900,
196 12100,
197 23,
198 2500,
199 5300,
200 5400,
201 5500,
202 5600,
203 7300,
204 7500,
205 13100,
206 8300,
207 11100,
208 11200,
209 11400,
210 121,
211 2611,
212 2711,
213 2811,
214 8400,
215 11,
216 2612,
217 7900,
218 21,
219 11000,
220 124,
221 10000,
222 3711,
223 7600,
224 12,
225 131,
226 132,
227 1731,
228 200,
229 300,
230 3100,
231 112,
232 12300,
233 8000,
234 141,
235 1441,
236 1600,
237 12600,
238 1421,
239 101,
240 111,
241 1711,
242 3000,
243 1000,
244 1100,
245 2100,
246 12800,
247 1500,
248 12400,
249 500,
250 3200,
251 7400,
252 1800,
253 122,
254 1722,
255 7100,
256 6300,
257 6700,
258 6400,
259 6500,
260 2400,
261 2410,
262 5700,
263 9200,
264 9300,
265 22,
266 501,
267 5800,
268 8100,
269 8500,
270 7200,
271 9900,
272 7700,
273 7800,
274 10300,
275 8600,
276 8700,
277 9100,
278 133,
279 13500,
280 11600,
281 13600,
282 12500,
283 13000,
284 13200,
285 13300,
286 6211,
287 6221,
288 6231,
289 6241,
290 13711,
291 13721,
292 13731,
293 13741,
294 13751,
295 13761,
296 8800,
297 12900,
298 12200,
299 9700,
300 9710,
301 9800,
302 9810,
303 9400,
304 9500,
305 9600,
306 10400,
307 10410,
308 10500,
309 10600,
310 10700,
311 9000,
312 5200,
313 6800,
314 6600,
315 8200,
316 11300,
317 12700,
318 13400,
319 125
320 };
321
322 /**
323 * types
324 */
325
326 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
327
328 /**
329 * globals
330 */
331
332 static unsigned int full01 = 0x01010101;
333 static unsigned int full80 = 0x80808080;
334
335 int SUPPRESS_OUTPUT = 0;
336
337 hc_thread_mutex_t mux_adl;
338 hc_thread_mutex_t mux_counter;
339 hc_thread_mutex_t mux_dispatcher;
340 hc_thread_mutex_t mux_display;
341
342 hc_global_data_t data;
343
344 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
345
346 const char *USAGE_MINI[] =
347 {
348 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
349 "",
350 "Try --help for more help.",
351 NULL
352 };
353
354 const char *USAGE_BIG[] =
355 {
356 "%s, advanced password recovery",
357 "",
358 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
359 "",
360 "- [ Options ] -",
361 "",
362 " Options Short / Long | Type | Description | Example",
363 "===============================|======|======================================================|=======================",
364 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
365 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
366 " -V, --version | | Print version |",
367 " -h, --help | | Print help |",
368 " --quiet | | Suppress output |",
369 " --hex-charset | | Assume charset is given in hex |",
370 " --hex-salt | | Assume salt is given in hex |",
371 " --hex-wordlist | | Assume words in wordlist is given in hex |",
372 " --force | | Ignore warnings |",
373 " --status | | Enable automatic update of the status-screen |",
374 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
375 " --machine-readable | | Display the status view in a machine readable format |",
376 " --loopback | | Add new plains to induct directory |",
377 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
378 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
379 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
380 " --markov-classic | | Enables classic markov-chains, no per-position |",
381 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
382 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
383 " --session | Str | Define specific session name | --session=mysession",
384 " --restore | | Restore session from --session |",
385 " --restore-disable | | Do not write restore file |",
386 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
387 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
388 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
389 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
390 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
391 " --show | | Show cracked passwords only |",
392 " --left | | Show un-cracked passwords only |",
393 " --username | | Enable ignoring of usernames in hashfile |",
394 " --remove | | Enable remove of hash once it is cracked |",
395 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
396 " --potfile-disable | | Do not write potfile |",
397 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
398 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
399 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
400 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
401 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
402 " --logfile-disable | | Disable the logfile |",
403 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
404 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
405 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
406 " -b, --benchmark | | Run benchmark |",
407 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
408 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
409 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
410 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
411 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
412 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
413 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
414 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
415 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
416 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
417 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
418 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
419 #ifdef HAVE_HWMON
420 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
421 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
422 " --powertune-enable | | Enable power tuning, restores settings when finished |",
423 #endif
424 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
425 " -s, --skip | Num | Skip X words from the start | -s 1000000",
426 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
427 " --keyspace | | Show keyspace base:mod values and quit |",
428 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
429 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
430 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
431 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
432 " --generate-rules-func-min | Num | Force min X funcs per rule |",
433 " --generate-rules-func-max | Num | Force max X funcs per rule |",
434 " --generate-rules-seed | Num | Force RNG seed set to X |",
435 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
436 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
437 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
438 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
439 " -i, --increment | | Enable mask increment mode |",
440 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
441 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
442 "",
443 "- [ Hash modes ] -",
444 "",
445 " # | Name | Category",
446 " ======+==================================================+======================================",
447 " 900 | MD4 | Raw Hash",
448 " 0 | MD5 | Raw Hash",
449 " 5100 | Half MD5 | Raw Hash",
450 " 100 | SHA1 | Raw Hash",
451 " 10800 | SHA-384 | Raw Hash",
452 " 1400 | SHA-256 | Raw Hash",
453 " 1700 | SHA-512 | Raw Hash",
454 " 5000 | SHA-3(Keccak) | Raw Hash",
455 " 10100 | SipHash | Raw Hash",
456 " 6000 | RipeMD160 | Raw Hash",
457 " 6100 | Whirlpool | Raw Hash",
458 " 6900 | GOST R 34.11-94 | Raw Hash",
459 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
460 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
461 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
462 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
463 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
464 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
465 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
466 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
467 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
468 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
469 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
470 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
471 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
472 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
473 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
474 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
475 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
476 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
477 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
478 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
479 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
480 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
481 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
482 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
483 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
484 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
485 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
486 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
487 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
488 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
489 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
490 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
491 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
492 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
493 " 400 | phpass | Generic KDF",
494 " 8900 | scrypt | Generic KDF",
495 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
496 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
497 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
498 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
499 " 23 | Skype | Network protocols",
500 " 2500 | WPA/WPA2 | Network protocols",
501 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
502 " 5300 | IKE-PSK MD5 | Network protocols",
503 " 5400 | IKE-PSK SHA1 | Network protocols",
504 " 5500 | NetNTLMv1 | Network protocols",
505 " 5500 | NetNTLMv1 + ESS | Network protocols",
506 " 5600 | NetNTLMv2 | Network protocols",
507 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
508 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
509 " 8300 | DNSSEC (NSEC3) | Network protocols",
510 " 10200 | Cram MD5 | Network protocols",
511 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
512 " 11200 | MySQL CRAM (SHA1) | Network protocols",
513 " 11400 | SIP digest authentication (MD5) | Network protocols",
514 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
515 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
516 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
517 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
518 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
519 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
520 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
521 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
522 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
523 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
524 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
525 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
526 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
527 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
528 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
529 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
530 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
531 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
532 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
533 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
534 " 12 | PostgreSQL | Database Server",
535 " 131 | MSSQL(2000) | Database Server",
536 " 132 | MSSQL(2005) | Database Server",
537 " 1731 | MSSQL(2012) | Database Server",
538 " 1731 | MSSQL(2014) | Database Server",
539 " 200 | MySQL323 | Database Server",
540 " 300 | MySQL4.1/MySQL5 | Database Server",
541 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
542 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
543 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
544 " 8000 | Sybase ASE | Database Server",
545 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
546 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
547 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
548 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
549 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
550 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
551 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
552 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
553 " 11500 | CRC32 | Checksums",
554 " 3000 | LM | Operating-Systems",
555 " 1000 | NTLM | Operating-Systems",
556 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
557 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
558 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
559 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
560 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
561 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
562 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
563 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
564 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
565 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
566 " 1722 | OSX v10.7 | Operating-Systems",
567 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
568 " 6300 | AIX {smd5} | Operating-Systems",
569 " 6700 | AIX {ssha1} | Operating-Systems",
570 " 6400 | AIX {ssha256} | Operating-Systems",
571 " 6500 | AIX {ssha512} | Operating-Systems",
572 " 2400 | Cisco-PIX | Operating-Systems",
573 " 2410 | Cisco-ASA | Operating-Systems",
574 " 500 | Cisco-IOS $1$ | Operating-Systems",
575 " 5700 | Cisco-IOS $4$ | Operating-Systems",
576 " 9200 | Cisco-IOS $8$ | Operating-Systems",
577 " 9300 | Cisco-IOS $9$ | Operating-Systems",
578 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
579 " 501 | Juniper IVE | Operating-Systems",
580 " 5800 | Android PIN | Operating-Systems",
581 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
582 " 8100 | Citrix Netscaler | Operating-Systems",
583 " 8500 | RACF | Operating-Systems",
584 " 7200 | GRUB 2 | Operating-Systems",
585 " 9900 | Radmin2 | Operating-Systems",
586 " 125 | ArubaOS | Operating-Systems",
587 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
588 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
589 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
590 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
591 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
592 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
593 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
594 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
595 " 11600 | 7-Zip | Archives",
596 " 12500 | RAR3-hp | Archives",
597 " 13000 | RAR5 | Archives",
598 " 13200 | AxCrypt | Archives",
599 " 13300 | AxCrypt in memory SHA1 | Archives",
600 " 13600 | WinZip | Archives",
601 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
602 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
603 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
604 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
605 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
606 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
607 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
608 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
609 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
610 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
611 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
612 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
613 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
614 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
615 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
616 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
617 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
618 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
619 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
620 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
621 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
622 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
623 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
624 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
625 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
626 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
627 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
628 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
629 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
630 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
631 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
632 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
633 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
634 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
635 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
636 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
637 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
638 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
639 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
640 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
641 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
642 " 9400 | MS Office 2007 | Documents",
643 " 9500 | MS Office 2010 | Documents",
644 " 9600 | MS Office 2013 | Documents",
645 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
646 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
647 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
648 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
649 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
650 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
651 " 9000 | Password Safe v2 | Password Managers",
652 " 5200 | Password Safe v3 | Password Managers",
653 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
654 " 6600 | 1Password, agilekeychain | Password Managers",
655 " 8200 | 1Password, cloudkeychain | Password Managers",
656 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
657 " 12700 | Blockchain, My Wallet | Password Managers",
658 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
659 "",
660 "- [ Outfile Formats ] -",
661 "",
662 " # | Format",
663 " ===+========",
664 " 1 | hash[:salt]",
665 " 2 | plain",
666 " 3 | hash[:salt]:plain",
667 " 4 | hex_plain",
668 " 5 | hash[:salt]:hex_plain",
669 " 6 | plain:hex_plain",
670 " 7 | hash[:salt]:plain:hex_plain",
671 " 8 | crackpos",
672 " 9 | hash[:salt]:crack_pos",
673 " 10 | plain:crack_pos",
674 " 11 | hash[:salt]:plain:crack_pos",
675 " 12 | hex_plain:crack_pos",
676 " 13 | hash[:salt]:hex_plain:crack_pos",
677 " 14 | plain:hex_plain:crack_pos",
678 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
679 "",
680 "- [ Rule Debugging Modes ] -",
681 "",
682 " # | Format",
683 " ===+========",
684 " 1 | Finding-Rule",
685 " 2 | Original-Word",
686 " 3 | Original-Word:Finding-Rule",
687 " 4 | Original-Word:Finding-Rule:Processed-Word",
688 "",
689 "- [ Attack Modes ] -",
690 "",
691 " # | Mode",
692 " ===+======",
693 " 0 | Straight",
694 " 1 | Combination",
695 " 3 | Brute-force",
696 " 6 | Hybrid Wordlist + Mask",
697 " 7 | Hybrid Mask + Wordlist",
698 "",
699 "- [ Built-in Charsets ] -",
700 "",
701 " ? | Charset",
702 " ===+=========",
703 " l | abcdefghijklmnopqrstuvwxyz",
704 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
705 " d | 0123456789",
706 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
707 " a | ?l?u?d?s",
708 " b | 0x00 - 0xff",
709 "",
710 "- [ OpenCL Device Types ] -",
711 "",
712 " # | Device Type",
713 " ===+=============",
714 " 1 | CPU",
715 " 2 | GPU",
716 " 3 | FPGA, DSP, Co-Processor",
717 "",
718 "- [ Workload Profiles ] -",
719 "",
720 " # | Performance | Runtime | Power Consumption | Desktop Impact",
721 " ===+=============+=========+===================+=================",
722 " 1 | Low | 2 ms | Low | Minimal",
723 " 2 | Default | 12 ms | Economic | Noticeable",
724 " 3 | High | 96 ms | High | Unresponsive",
725 " 4 | Nightmare | 480 ms | Insane | Headless",
726 "",
727 "If you have no idea what just happened then visit the following pages:",
728 "",
729 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
730 "* https://hashcat.net/wiki/#frequently_asked_questions",
731 "",
732 NULL
733 };
734
735 /**
736 * hashcat specific functions
737 */
738
739 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
740 {
741 int exec_pos = (int) device_param->exec_pos - last_num_entries;
742
743 if (exec_pos < 0) exec_pos += EXEC_CACHE;
744
745 double exec_ms_sum = 0;
746
747 int exec_ms_cnt = 0;
748
749 for (int i = 0; i < last_num_entries; i++)
750 {
751 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
752
753 if (exec_ms)
754 {
755 exec_ms_sum += exec_ms;
756
757 exec_ms_cnt++;
758 }
759 }
760
761 if (exec_ms_cnt == 0) return 0;
762
763 return exec_ms_sum / exec_ms_cnt;
764 }
765
766 void status_display_machine_readable ()
767 {
768 FILE *out = stdout;
769
770 fprintf (out, "STATUS\t%u\t", data.devices_status);
771
772 /**
773 * speed new
774 */
775
776 fprintf (out, "SPEED\t");
777
778 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
779 {
780 hc_device_param_t *device_param = &data.devices_param[device_id];
781
782 if (device_param->skipped) continue;
783
784 u64 speed_cnt = 0;
785 double speed_ms = 0;
786
787 for (int i = 0; i < SPEED_CACHE; i++)
788 {
789 speed_cnt += device_param->speed_cnt[i];
790 speed_ms += device_param->speed_ms[i];
791 }
792
793 speed_cnt /= SPEED_CACHE;
794 speed_ms /= SPEED_CACHE;
795
796 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
797 }
798
799 /**
800 * exec time
801 */
802
803 fprintf (out, "EXEC_RUNTIME\t");
804
805 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
806 {
807 hc_device_param_t *device_param = &data.devices_param[device_id];
808
809 if (device_param->skipped) continue;
810
811 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
812
813 fprintf (out, "%f\t", exec_ms_avg);
814 }
815
816 /**
817 * words_cur
818 */
819
820 u64 words_cur = get_lowest_words_done ();
821
822 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
823
824 /**
825 * counter
826 */
827
828 u64 progress_total = data.words_cnt * data.salts_cnt;
829
830 u64 all_done = 0;
831 u64 all_rejected = 0;
832 u64 all_restored = 0;
833
834 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
835 {
836 all_done += data.words_progress_done[salt_pos];
837 all_rejected += data.words_progress_rejected[salt_pos];
838 all_restored += data.words_progress_restored[salt_pos];
839 }
840
841 u64 progress_cur = all_restored + all_done + all_rejected;
842 u64 progress_end = progress_total;
843
844 u64 progress_skip = 0;
845
846 if (data.skip)
847 {
848 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
849
850 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
851 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
852 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
853 }
854
855 if (data.limit)
856 {
857 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
858
859 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
860 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
861 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
862 }
863
864 u64 progress_cur_relative_skip = progress_cur - progress_skip;
865 u64 progress_end_relative_skip = progress_end - progress_skip;
866
867 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
868
869 /**
870 * cracks
871 */
872
873 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
874 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
875
876 /**
877 * temperature
878 */
879
880 #ifdef HAVE_HWMON
881 if (data.gpu_temp_disable == 0)
882 {
883 fprintf (out, "TEMP\t");
884
885 hc_thread_mutex_lock (mux_adl);
886
887 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
888 {
889 hc_device_param_t *device_param = &data.devices_param[device_id];
890
891 if (device_param->skipped) continue;
892
893 int temp = hm_get_temperature_with_device_id (device_id);
894
895 fprintf (out, "%d\t", temp);
896 }
897
898 hc_thread_mutex_unlock (mux_adl);
899 }
900 #endif // HAVE_HWMON
901
902 /**
903 * flush
904 */
905
906 #ifdef _WIN
907 fputc ('\r', out);
908 fputc ('\n', out);
909 #endif
910
911 #ifdef _POSIX
912 fputc ('\n', out);
913 #endif
914
915 fflush (out);
916 }
917
918 void status_display ()
919 {
920 if (data.devices_status == STATUS_INIT) return;
921 if (data.devices_status == STATUS_STARTING) return;
922 if (data.devices_status == STATUS_BYPASS) return;
923
924 if (data.machine_readable == 1)
925 {
926 status_display_machine_readable ();
927
928 return;
929 }
930
931 char tmp_buf[1000] = { 0 };
932
933 uint tmp_len = 0;
934
935 log_info ("Session.Name...: %s", data.session);
936
937 char *status_type = strstatus (data.devices_status);
938
939 uint hash_mode = data.hash_mode;
940
941 char *hash_type = strhashtype (hash_mode); // not a bug
942
943 log_info ("Status.........: %s", status_type);
944
945 /**
946 * show rules
947 */
948
949 if (data.rp_files_cnt)
950 {
951 uint i;
952
953 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
954 {
955 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
956 }
957
958 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
959
960 log_info ("Rules.Type.....: %s", tmp_buf);
961
962 tmp_len = 0;
963 }
964
965 if (data.rp_gen)
966 {
967 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
968
969 if (data.rp_gen_seed)
970 {
971 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
972 }
973 }
974
975 /**
976 * show input
977 */
978
979 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
980 {
981 if (data.wordlist_mode == WL_MODE_FILE)
982 {
983 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
984 }
985 else if (data.wordlist_mode == WL_MODE_STDIN)
986 {
987 log_info ("Input.Mode.....: Pipe");
988 }
989 }
990 else if (data.attack_mode == ATTACK_MODE_COMBI)
991 {
992 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
993 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
994 }
995 else if (data.attack_mode == ATTACK_MODE_BF)
996 {
997 char *mask = data.mask;
998
999 if (mask != NULL)
1000 {
1001 uint mask_len = data.css_cnt;
1002
1003 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1004
1005 if (mask_len > 0)
1006 {
1007 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1008 {
1009 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1010 {
1011 mask_len -= data.salts_buf[0].salt_len;
1012 }
1013 }
1014
1015 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1016
1017 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1018 }
1019
1020 if (data.maskcnt > 1)
1021 {
1022 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1023
1024 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1025 }
1026
1027 log_info ("Input.Mode.....: %s", tmp_buf);
1028 }
1029
1030 tmp_len = 0;
1031 }
1032 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1033 {
1034 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1035 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1036 }
1037 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1038 {
1039 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1040 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1041 }
1042
1043 if (data.digests_cnt == 1)
1044 {
1045 if (data.hash_mode == 2500)
1046 {
1047 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1048
1049 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1050 (char *) data.salts_buf[0].salt_buf,
1051 wpa->orig_mac1[0],
1052 wpa->orig_mac1[1],
1053 wpa->orig_mac1[2],
1054 wpa->orig_mac1[3],
1055 wpa->orig_mac1[4],
1056 wpa->orig_mac1[5],
1057 wpa->orig_mac2[0],
1058 wpa->orig_mac2[1],
1059 wpa->orig_mac2[2],
1060 wpa->orig_mac2[3],
1061 wpa->orig_mac2[4],
1062 wpa->orig_mac2[5]);
1063 }
1064 else if (data.hash_mode == 5200)
1065 {
1066 log_info ("Hash.Target....: File (%s)", data.hashfile);
1067 }
1068 else if (data.hash_mode == 9000)
1069 {
1070 log_info ("Hash.Target....: File (%s)", data.hashfile);
1071 }
1072 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1073 {
1074 log_info ("Hash.Target....: File (%s)", data.hashfile);
1075 }
1076 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1077 {
1078 log_info ("Hash.Target....: File (%s)", data.hashfile);
1079 }
1080 else
1081 {
1082 char out_buf[HCBUFSIZ] = { 0 };
1083
1084 ascii_digest (out_buf, 0, 0);
1085
1086 // limit length
1087 if (strlen (out_buf) > 40)
1088 {
1089 out_buf[41] = '.';
1090 out_buf[42] = '.';
1091 out_buf[43] = '.';
1092 out_buf[44] = 0;
1093 }
1094
1095 log_info ("Hash.Target....: %s", out_buf);
1096 }
1097 }
1098 else
1099 {
1100 if (data.hash_mode == 3000)
1101 {
1102 char out_buf1[32] = { 0 };
1103 char out_buf2[32] = { 0 };
1104
1105 ascii_digest (out_buf1, 0, 0);
1106 ascii_digest (out_buf2, 0, 1);
1107
1108 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1109 }
1110 else
1111 {
1112 log_info ("Hash.Target....: File (%s)", data.hashfile);
1113 }
1114 }
1115
1116 log_info ("Hash.Type......: %s", hash_type);
1117
1118 /**
1119 * speed new
1120 */
1121
1122 u64 speed_cnt[DEVICES_MAX] = { 0 };
1123 double speed_ms[DEVICES_MAX] = { 0 };
1124
1125 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1126 {
1127 hc_device_param_t *device_param = &data.devices_param[device_id];
1128
1129 if (device_param->skipped) continue;
1130
1131 speed_cnt[device_id] = 0;
1132 speed_ms[device_id] = 0;
1133
1134 for (int i = 0; i < SPEED_CACHE; i++)
1135 {
1136 speed_cnt[device_id] += device_param->speed_cnt[i];
1137 speed_ms[device_id] += device_param->speed_ms[i];
1138 }
1139
1140 speed_cnt[device_id] /= SPEED_CACHE;
1141 speed_ms[device_id] /= SPEED_CACHE;
1142 }
1143
1144 double hashes_all_ms = 0;
1145
1146 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1147
1148 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1149 {
1150 hc_device_param_t *device_param = &data.devices_param[device_id];
1151
1152 if (device_param->skipped) continue;
1153
1154 hashes_dev_ms[device_id] = 0;
1155
1156 if (speed_ms[device_id])
1157 {
1158 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1159
1160 hashes_all_ms += hashes_dev_ms[device_id];
1161 }
1162 }
1163
1164 /**
1165 * exec time
1166 */
1167
1168 double exec_all_ms[DEVICES_MAX] = { 0 };
1169
1170 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1171 {
1172 hc_device_param_t *device_param = &data.devices_param[device_id];
1173
1174 if (device_param->skipped) continue;
1175
1176 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1177
1178 exec_all_ms[device_id] = exec_ms_avg;
1179 }
1180
1181 /**
1182 * timers
1183 */
1184
1185 double ms_running = 0;
1186
1187 hc_timer_get (data.timer_running, ms_running);
1188
1189 double ms_paused = data.ms_paused;
1190
1191 if (data.devices_status == STATUS_PAUSED)
1192 {
1193 double ms_paused_tmp = 0;
1194
1195 hc_timer_get (data.timer_paused, ms_paused_tmp);
1196
1197 ms_paused += ms_paused_tmp;
1198 }
1199
1200 #ifdef WIN
1201
1202 __time64_t sec_run = ms_running / 1000;
1203
1204 #else
1205
1206 time_t sec_run = ms_running / 1000;
1207
1208 #endif
1209
1210 if (sec_run)
1211 {
1212 char display_run[32] = { 0 };
1213
1214 struct tm tm_run;
1215
1216 struct tm *tmp = NULL;
1217
1218 #ifdef WIN
1219
1220 tmp = _gmtime64 (&sec_run);
1221
1222 #else
1223
1224 tmp = gmtime (&sec_run);
1225
1226 #endif
1227
1228 if (tmp != NULL)
1229 {
1230 memset (&tm_run, 0, sizeof (tm_run));
1231
1232 memcpy (&tm_run, tmp, sizeof (tm_run));
1233
1234 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1235
1236 char *start = ctime (&data.proc_start);
1237
1238 size_t start_len = strlen (start);
1239
1240 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1241 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1242
1243 log_info ("Time.Started...: %s (%s)", start, display_run);
1244 }
1245 }
1246 else
1247 {
1248 log_info ("Time.Started...: 0 secs");
1249 }
1250
1251 /**
1252 * counters
1253 */
1254
1255 u64 progress_total = data.words_cnt * data.salts_cnt;
1256
1257 u64 all_done = 0;
1258 u64 all_rejected = 0;
1259 u64 all_restored = 0;
1260
1261 u64 progress_noneed = 0;
1262
1263 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1264 {
1265 all_done += data.words_progress_done[salt_pos];
1266 all_rejected += data.words_progress_rejected[salt_pos];
1267 all_restored += data.words_progress_restored[salt_pos];
1268
1269 // Important for ETA only
1270
1271 if (data.salts_shown[salt_pos] == 1)
1272 {
1273 const u64 all = data.words_progress_done[salt_pos]
1274 + data.words_progress_rejected[salt_pos]
1275 + data.words_progress_restored[salt_pos];
1276
1277 const u64 left = data.words_cnt - all;
1278
1279 progress_noneed += left;
1280 }
1281 }
1282
1283 u64 progress_cur = all_restored + all_done + all_rejected;
1284 u64 progress_end = progress_total;
1285
1286 u64 progress_skip = 0;
1287
1288 if (data.skip)
1289 {
1290 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1291
1292 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1293 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1294 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1295 }
1296
1297 if (data.limit)
1298 {
1299 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1300
1301 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1302 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1303 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1304 }
1305
1306 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1307 u64 progress_end_relative_skip = progress_end - progress_skip;
1308
1309 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1310 {
1311 if (data.devices_status != STATUS_CRACKED)
1312 {
1313 #ifdef WIN
1314 __time64_t sec_etc = 0;
1315 #else
1316 time_t sec_etc = 0;
1317 #endif
1318
1319 if (hashes_all_ms)
1320 {
1321 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1322
1323 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1324
1325 sec_etc = ms_left / 1000;
1326 }
1327
1328 if (sec_etc == 0)
1329 {
1330 //log_info ("Time.Estimated.: 0 secs");
1331 }
1332 else if ((u64) sec_etc > ETC_MAX)
1333 {
1334 log_info ("Time.Estimated.: > 10 Years");
1335 }
1336 else
1337 {
1338 char display_etc[32] = { 0 };
1339
1340 struct tm tm_etc;
1341
1342 struct tm *tmp = NULL;
1343
1344 #ifdef WIN
1345
1346 tmp = _gmtime64 (&sec_etc);
1347
1348 #else
1349
1350 tmp = gmtime (&sec_etc);
1351
1352 #endif
1353
1354 if (tmp != NULL)
1355 {
1356 memset (&tm_etc, 0, sizeof (tm_etc));
1357
1358 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1359
1360 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1361
1362 time_t now;
1363
1364 time (&now);
1365
1366 now += sec_etc;
1367
1368 char *etc = ctime (&now);
1369
1370 size_t etc_len = strlen (etc);
1371
1372 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1373 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1374
1375 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1376 }
1377 }
1378 }
1379 }
1380
1381 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1382 {
1383 hc_device_param_t *device_param = &data.devices_param[device_id];
1384
1385 if (device_param->skipped) continue;
1386
1387 char display_dev_cur[16] = { 0 };
1388
1389 strncpy (display_dev_cur, "0.00", 4);
1390
1391 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1392
1393 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1394 }
1395
1396 char display_all_cur[16] = { 0 };
1397
1398 strncpy (display_all_cur, "0.00", 4);
1399
1400 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1401
1402 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1403
1404 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1405 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1406
1407 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1408
1409 // crack-per-time
1410
1411 if (data.digests_cnt > 100)
1412 {
1413 time_t now = time (NULL);
1414
1415 int cpt_cur_min = 0;
1416 int cpt_cur_hour = 0;
1417 int cpt_cur_day = 0;
1418
1419 for (int i = 0; i < CPT_BUF; i++)
1420 {
1421 const uint cracked = data.cpt_buf[i].cracked;
1422 const time_t timestamp = data.cpt_buf[i].timestamp;
1423
1424 if ((timestamp + 60) > now)
1425 {
1426 cpt_cur_min += cracked;
1427 }
1428
1429 if ((timestamp + 3600) > now)
1430 {
1431 cpt_cur_hour += cracked;
1432 }
1433
1434 if ((timestamp + 86400) > now)
1435 {
1436 cpt_cur_day += cracked;
1437 }
1438 }
1439
1440 double ms_real = ms_running - ms_paused;
1441
1442 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1443 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1444 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1445
1446 if ((data.cpt_start + 86400) < now)
1447 {
1448 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1449 cpt_cur_min,
1450 cpt_cur_hour,
1451 cpt_cur_day,
1452 cpt_avg_min,
1453 cpt_avg_hour,
1454 cpt_avg_day);
1455 }
1456 else if ((data.cpt_start + 3600) < now)
1457 {
1458 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1459 cpt_cur_min,
1460 cpt_cur_hour,
1461 cpt_avg_min,
1462 cpt_avg_hour,
1463 cpt_avg_day);
1464 }
1465 else if ((data.cpt_start + 60) < now)
1466 {
1467 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1468 cpt_cur_min,
1469 cpt_avg_min,
1470 cpt_avg_hour,
1471 cpt_avg_day);
1472 }
1473 else
1474 {
1475 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1476 cpt_avg_min,
1477 cpt_avg_hour,
1478 cpt_avg_day);
1479 }
1480 }
1481
1482 // Restore point
1483
1484 u64 restore_point = get_lowest_words_done ();
1485
1486 u64 restore_total = data.words_base;
1487
1488 float percent_restore = 0;
1489
1490 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1491
1492 if (progress_end_relative_skip)
1493 {
1494 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1495 {
1496 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1497 float percent_rejected = 0.0;
1498
1499 if (progress_cur)
1500 {
1501 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1502 }
1503
1504 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1505 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1506
1507 if (data.restore_disable == 0)
1508 {
1509 if (percent_finished != 1)
1510 {
1511 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1512 }
1513 }
1514 }
1515 }
1516 else
1517 {
1518 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1519 {
1520 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1521 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1522
1523 if (data.restore_disable == 0)
1524 {
1525 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1526 }
1527 }
1528 else
1529 {
1530 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1531 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1532
1533 // --restore not allowed if stdin is used -- really? why?
1534
1535 //if (data.restore_disable == 0)
1536 //{
1537 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1538 //}
1539 }
1540 }
1541
1542 #ifdef HAVE_HWMON
1543
1544 if (data.devices_status == STATUS_EXHAUSTED) return;
1545 if (data.devices_status == STATUS_CRACKED) return;
1546 if (data.devices_status == STATUS_ABORTED) return;
1547 if (data.devices_status == STATUS_QUIT) return;
1548
1549 if (data.gpu_temp_disable == 0)
1550 {
1551 hc_thread_mutex_lock (mux_adl);
1552
1553 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1554 {
1555 hc_device_param_t *device_param = &data.devices_param[device_id];
1556
1557 if (device_param->skipped) continue;
1558
1559 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1560 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1561 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1562 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1563 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1564 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1565 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1566
1567 char output_buf[256] = { 0 };
1568
1569 int output_len = 0;
1570
1571 if (num_temperature >= 0)
1572 {
1573 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1574
1575 output_len = strlen (output_buf);
1576 }
1577
1578 if (num_fanspeed >= 0)
1579 {
1580 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1581
1582 output_len = strlen (output_buf);
1583 }
1584
1585 if (num_utilization >= 0)
1586 {
1587 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1588
1589 output_len = strlen (output_buf);
1590 }
1591
1592 if (num_corespeed >= 0)
1593 {
1594 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1595
1596 output_len = strlen (output_buf);
1597 }
1598
1599 if (num_memoryspeed >= 0)
1600 {
1601 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1602
1603 output_len = strlen (output_buf);
1604 }
1605
1606 if (num_buslanes >= 0)
1607 {
1608 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1609
1610 output_len = strlen (output_buf);
1611 }
1612
1613 if (num_throttle == 1)
1614 {
1615 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1616
1617 output_len = strlen (output_buf);
1618 }
1619
1620 if (output_len == 0)
1621 {
1622 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1623
1624 output_len = strlen (output_buf);
1625 }
1626
1627 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1628 }
1629
1630 hc_thread_mutex_unlock (mux_adl);
1631 }
1632
1633 #endif // HAVE_HWMON
1634 }
1635
1636 static void status_benchmark_automate ()
1637 {
1638 u64 speed_cnt[DEVICES_MAX] = { 0 };
1639 double speed_ms[DEVICES_MAX] = { 0 };
1640
1641 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1642 {
1643 hc_device_param_t *device_param = &data.devices_param[device_id];
1644
1645 if (device_param->skipped) continue;
1646
1647 speed_cnt[device_id] = device_param->speed_cnt[0];
1648 speed_ms[device_id] = device_param->speed_ms[0];
1649 }
1650
1651 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1652
1653 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1654 {
1655 hc_device_param_t *device_param = &data.devices_param[device_id];
1656
1657 if (device_param->skipped) continue;
1658
1659 hashes_dev_ms[device_id] = 0;
1660
1661 if (speed_ms[device_id])
1662 {
1663 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1664 }
1665 }
1666
1667 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1668 {
1669 hc_device_param_t *device_param = &data.devices_param[device_id];
1670
1671 if (device_param->skipped) continue;
1672
1673 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1674 }
1675 }
1676
1677 static void status_benchmark ()
1678 {
1679 if (data.devices_status == STATUS_INIT) return;
1680 if (data.devices_status == STATUS_STARTING) return;
1681 if (data.devices_status == STATUS_BYPASS) return;
1682
1683 if (data.machine_readable == 1)
1684 {
1685 status_benchmark_automate ();
1686
1687 return;
1688 }
1689
1690 u64 speed_cnt[DEVICES_MAX] = { 0 };
1691 double speed_ms[DEVICES_MAX] = { 0 };
1692
1693 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1694 {
1695 hc_device_param_t *device_param = &data.devices_param[device_id];
1696
1697 if (device_param->skipped) continue;
1698
1699 speed_cnt[device_id] = device_param->speed_cnt[0];
1700 speed_ms[device_id] = device_param->speed_ms[0];
1701 }
1702
1703 double hashes_all_ms = 0;
1704
1705 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1706
1707 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1708 {
1709 hc_device_param_t *device_param = &data.devices_param[device_id];
1710
1711 if (device_param->skipped) continue;
1712
1713 hashes_dev_ms[device_id] = 0;
1714
1715 if (speed_ms[device_id])
1716 {
1717 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1718
1719 hashes_all_ms += hashes_dev_ms[device_id];
1720 }
1721 }
1722
1723 /**
1724 * exec time
1725 */
1726
1727 double exec_all_ms[DEVICES_MAX] = { 0 };
1728
1729 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1730 {
1731 hc_device_param_t *device_param = &data.devices_param[device_id];
1732
1733 if (device_param->skipped) continue;
1734
1735 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1736
1737 exec_all_ms[device_id] = exec_ms_avg;
1738 }
1739
1740 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1741 {
1742 hc_device_param_t *device_param = &data.devices_param[device_id];
1743
1744 if (device_param->skipped) continue;
1745
1746 char display_dev_cur[16] = { 0 };
1747
1748 strncpy (display_dev_cur, "0.00", 4);
1749
1750 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1751
1752 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1753 }
1754
1755 char display_all_cur[16] = { 0 };
1756
1757 strncpy (display_all_cur, "0.00", 4);
1758
1759 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1760
1761 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1762 }
1763
1764 /**
1765 * hashcat -only- functions
1766 */
1767
1768 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1769 {
1770 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1771 {
1772 if (attack_kern == ATTACK_KERN_STRAIGHT)
1773 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1774 else if (attack_kern == ATTACK_KERN_COMBI)
1775 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1776 else if (attack_kern == ATTACK_KERN_BF)
1777 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1778 }
1779 else
1780 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1781 }
1782
1783 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1784 {
1785 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1786 {
1787 if (attack_kern == ATTACK_KERN_STRAIGHT)
1788 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1789 else if (attack_kern == ATTACK_KERN_COMBI)
1790 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1791 else if (attack_kern == ATTACK_KERN_BF)
1792 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1793 }
1794 else
1795 {
1796 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1797 }
1798 }
1799
1800 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1801 {
1802 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1803 {
1804 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1805 }
1806 else
1807 {
1808 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1809 }
1810 }
1811
1812 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1813 {
1814 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1815 {
1816 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1817 }
1818 else
1819 {
1820 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1821 }
1822 }
1823
1824 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1825 {
1826 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1827 }
1828
1829 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1830 {
1831 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1832 }
1833
1834 static uint convert_from_hex (char *line_buf, const uint line_len)
1835 {
1836 if (line_len & 1) return (line_len); // not in hex
1837
1838 if (data.hex_wordlist == 1)
1839 {
1840 uint i;
1841 uint j;
1842
1843 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1844 {
1845 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1846 }
1847
1848 memset (line_buf + i, 0, line_len - i);
1849
1850 return (i);
1851 }
1852 else if (line_len >= 6) // $HEX[] = 6
1853 {
1854 if (line_buf[0] != '$') return (line_len);
1855 if (line_buf[1] != 'H') return (line_len);
1856 if (line_buf[2] != 'E') return (line_len);
1857 if (line_buf[3] != 'X') return (line_len);
1858 if (line_buf[4] != '[') return (line_len);
1859 if (line_buf[line_len - 1] != ']') return (line_len);
1860
1861 uint i;
1862 uint j;
1863
1864 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1865 {
1866 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1867 }
1868
1869 memset (line_buf + i, 0, line_len - i);
1870
1871 return (i);
1872 }
1873
1874 return (line_len);
1875 }
1876
1877 static void clear_prompt ()
1878 {
1879 fputc ('\r', stdout);
1880
1881 for (size_t i = 0; i < strlen (PROMPT); i++)
1882 {
1883 fputc (' ', stdout);
1884 }
1885
1886 fputc ('\r', stdout);
1887
1888 fflush (stdout);
1889 }
1890
1891 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1892 {
1893 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1894 }
1895
1896 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1897 {
1898 char *outfile = data.outfile;
1899 uint quiet = data.quiet;
1900 FILE *pot_fp = data.pot_fp;
1901 uint loopback = data.loopback;
1902 uint debug_mode = data.debug_mode;
1903 char *debug_file = data.debug_file;
1904
1905 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1906 int debug_rule_len = 0; // -1 error
1907 uint debug_plain_len = 0;
1908
1909 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1910
1911 // hash
1912
1913 char out_buf[HCBUFSIZ] = { 0 };
1914
1915 const u32 salt_pos = plain->salt_pos;
1916 const u32 digest_pos = plain->digest_pos; // relative
1917 const u32 gidvid = plain->gidvid;
1918 const u32 il_pos = plain->il_pos;
1919
1920 ascii_digest (out_buf, salt_pos, digest_pos);
1921
1922 // plain
1923
1924 u64 crackpos = device_param->words_off;
1925
1926 uint plain_buf[16] = { 0 };
1927
1928 u8 *plain_ptr = (u8 *) plain_buf;
1929
1930 unsigned int plain_len = 0;
1931
1932 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1933 {
1934 pw_t pw;
1935
1936 gidd_to_pw_t (device_param, gidvid, &pw);
1937
1938 for (int i = 0; i < 16; i++)
1939 {
1940 plain_buf[i] = pw.i[i];
1941 }
1942
1943 plain_len = pw.pw_len;
1944
1945 const uint off = device_param->innerloop_pos + il_pos;
1946
1947 if (debug_mode > 0)
1948 {
1949 debug_rule_len = 0;
1950
1951 // save rule
1952 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1953 {
1954 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1955
1956 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1957 }
1958
1959 // save plain
1960 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1961 {
1962 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1963
1964 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1965
1966 debug_plain_len = plain_len;
1967 }
1968 }
1969
1970 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1971
1972 crackpos += gidvid;
1973 crackpos *= data.kernel_rules_cnt;
1974 crackpos += device_param->innerloop_pos + il_pos;
1975
1976 if (plain_len > data.pw_max) plain_len = data.pw_max;
1977 }
1978 else if (data.attack_mode == ATTACK_MODE_COMBI)
1979 {
1980 pw_t pw;
1981
1982 gidd_to_pw_t (device_param, gidvid, &pw);
1983
1984 for (int i = 0; i < 16; i++)
1985 {
1986 plain_buf[i] = pw.i[i];
1987 }
1988
1989 plain_len = pw.pw_len;
1990
1991 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1992 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1993
1994 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1995 {
1996 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1997 }
1998 else
1999 {
2000 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2001
2002 memcpy (plain_ptr, comb_buf, comb_len);
2003 }
2004
2005 plain_len += comb_len;
2006
2007 crackpos += gidvid;
2008 crackpos *= data.combs_cnt;
2009 crackpos += device_param->innerloop_pos + il_pos;
2010
2011 if (data.pw_max != PW_DICTMAX1)
2012 {
2013 if (plain_len > data.pw_max) plain_len = data.pw_max;
2014 }
2015 }
2016 else if (data.attack_mode == ATTACK_MODE_BF)
2017 {
2018 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2019 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2020
2021 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2022 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2023
2024 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2025 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2026
2027 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2028 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2029
2030 plain_len = data.css_cnt;
2031
2032 crackpos += gidvid;
2033 crackpos *= data.bfs_cnt;
2034 crackpos += device_param->innerloop_pos + il_pos;
2035 }
2036 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2037 {
2038 pw_t pw;
2039
2040 gidd_to_pw_t (device_param, gidvid, &pw);
2041
2042 for (int i = 0; i < 16; i++)
2043 {
2044 plain_buf[i] = pw.i[i];
2045 }
2046
2047 plain_len = pw.pw_len;
2048
2049 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2050
2051 uint start = 0;
2052 uint stop = device_param->kernel_params_mp_buf32[4];
2053
2054 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2055
2056 plain_len += start + stop;
2057
2058 crackpos += gidvid;
2059 crackpos *= data.combs_cnt;
2060 crackpos += device_param->innerloop_pos + il_pos;
2061
2062 if (data.pw_max != PW_DICTMAX1)
2063 {
2064 if (plain_len > data.pw_max) plain_len = data.pw_max;
2065 }
2066 }
2067 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2068 {
2069 pw_t pw;
2070
2071 gidd_to_pw_t (device_param, gidvid, &pw);
2072
2073 for (int i = 0; i < 16; i++)
2074 {
2075 plain_buf[i] = pw.i[i];
2076 }
2077
2078 plain_len = pw.pw_len;
2079
2080 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2081
2082 uint start = 0;
2083 uint stop = device_param->kernel_params_mp_buf32[4];
2084
2085 memmove (plain_ptr + stop, plain_ptr, plain_len);
2086
2087 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2088
2089 plain_len += start + stop;
2090
2091 crackpos += gidvid;
2092 crackpos *= data.combs_cnt;
2093 crackpos += device_param->innerloop_pos + il_pos;
2094
2095 if (data.pw_max != PW_DICTMAX1)
2096 {
2097 if (plain_len > data.pw_max) plain_len = data.pw_max;
2098 }
2099 }
2100
2101 if (data.attack_mode == ATTACK_MODE_BF)
2102 {
2103 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2104 {
2105 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2106 {
2107 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2108 {
2109 plain_len = plain_len - data.salts_buf[0].salt_len;
2110 }
2111 }
2112
2113 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2114 {
2115 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2116 {
2117 plain_ptr[j] = plain_ptr[i];
2118 }
2119
2120 plain_len = plain_len / 2;
2121 }
2122 }
2123 }
2124
2125 // if enabled, update also the potfile
2126
2127 if (pot_fp)
2128 {
2129 lock_file (pot_fp);
2130
2131 fprintf (pot_fp, "%s:", out_buf);
2132
2133 format_plain (pot_fp, plain_ptr, plain_len, 1);
2134
2135 fputc ('\n', pot_fp);
2136
2137 fflush (pot_fp);
2138
2139 unlock_file (pot_fp);
2140 }
2141
2142 // outfile
2143
2144 FILE *out_fp = NULL;
2145
2146 if (outfile != NULL)
2147 {
2148 if ((out_fp = fopen (outfile, "ab")) == NULL)
2149 {
2150 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2151
2152 out_fp = stdout;
2153 }
2154
2155 lock_file (out_fp);
2156 }
2157 else
2158 {
2159 out_fp = stdout;
2160
2161 if (quiet == 0) clear_prompt ();
2162 }
2163
2164 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2165
2166 if (outfile != NULL)
2167 {
2168 if (out_fp != stdout)
2169 {
2170 fclose (out_fp);
2171 }
2172 }
2173 else
2174 {
2175 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2176 {
2177 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2178 {
2179 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2180 if (quiet == 0) fflush (stdout);
2181 }
2182 }
2183 }
2184
2185 // loopback
2186
2187 if (loopback)
2188 {
2189 char *loopback_file = data.loopback_file;
2190
2191 FILE *fb_fp = NULL;
2192
2193 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2194 {
2195 lock_file (fb_fp);
2196
2197 format_plain (fb_fp, plain_ptr, plain_len, 1);
2198
2199 fputc ('\n', fb_fp);
2200
2201 fclose (fb_fp);
2202 }
2203 }
2204
2205 // (rule) debug mode
2206
2207 // the next check implies that:
2208 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2209 // - debug_mode > 0
2210
2211 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2212 {
2213 if (debug_rule_len < 0) debug_rule_len = 0;
2214
2215 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2216
2217 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2218
2219 if ((quiet == 0) && (debug_file == NULL))
2220 {
2221 fprintf (stdout, "%s", PROMPT);
2222
2223 fflush (stdout);
2224 }
2225 }
2226 }
2227
2228 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2229 {
2230 salt_t *salt_buf = &data.salts_buf[salt_pos];
2231
2232 u32 num_cracked;
2233
2234 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2235
2236 if (num_cracked)
2237 {
2238 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2239
2240 log_info_nn ("");
2241
2242 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2243
2244 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, 0, num_cracked * sizeof (plain_t), cracked, 0, NULL, NULL);
2245
2246 uint cpt_cracked = 0;
2247
2248 for (uint i = 0; i < num_cracked; i++)
2249 {
2250 const uint hash_pos = cracked[i].hash_pos;
2251
2252 if (data.digests_shown[hash_pos] == 1) continue;
2253
2254 hc_thread_mutex_lock (mux_display);
2255
2256 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2257 {
2258 data.digests_shown[hash_pos] = 1;
2259
2260 data.digests_done++;
2261
2262 cpt_cracked++;
2263
2264 salt_buf->digests_done++;
2265
2266 if (salt_buf->digests_done == salt_buf->digests_cnt)
2267 {
2268 data.salts_shown[salt_pos] = 1;
2269
2270 data.salts_done++;
2271 }
2272 }
2273
2274 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2275
2276 hc_thread_mutex_unlock (mux_display);
2277
2278 check_hash (device_param, &cracked[i]);
2279 }
2280
2281 myfree (cracked);
2282
2283 if (cpt_cracked > 0)
2284 {
2285 hc_thread_mutex_lock (mux_display);
2286
2287 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2288 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2289
2290 data.cpt_pos++;
2291
2292 data.cpt_total += cpt_cracked;
2293
2294 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2295
2296 hc_thread_mutex_unlock (mux_display);
2297 }
2298
2299 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2300 {
2301 // we need to reset cracked state on the device
2302 // otherwise host thinks again and again the hash was cracked
2303 // and returns invalid password each time
2304
2305 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2306
2307 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2308 }
2309
2310 num_cracked = 0;
2311
2312 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2313 }
2314 }
2315
2316 static void save_hash ()
2317 {
2318 char *hashfile = data.hashfile;
2319
2320 char new_hashfile[256] = { 0 };
2321 char old_hashfile[256] = { 0 };
2322
2323 snprintf (new_hashfile, 255, "%s.new", hashfile);
2324 snprintf (old_hashfile, 255, "%s.old", hashfile);
2325
2326 unlink (new_hashfile);
2327
2328 char separator = data.separator;
2329
2330 FILE *fp = fopen (new_hashfile, "wb");
2331
2332 if (fp == NULL)
2333 {
2334 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2335
2336 exit (-1);
2337 }
2338
2339 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2340 {
2341 if (data.salts_shown[salt_pos] == 1) continue;
2342
2343 salt_t *salt_buf = &data.salts_buf[salt_pos];
2344
2345 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2346 {
2347 uint idx = salt_buf->digests_offset + digest_pos;
2348
2349 if (data.digests_shown[idx] == 1) continue;
2350
2351 if (data.hash_mode != 2500)
2352 {
2353 char out_buf[HCBUFSIZ] = { 0 };
2354
2355 if (data.username == 1)
2356 {
2357 user_t *user = data.hash_info[idx]->user;
2358
2359 uint i;
2360
2361 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2362
2363 fputc (separator, fp);
2364 }
2365
2366 ascii_digest (out_buf, salt_pos, digest_pos);
2367
2368 fputs (out_buf, fp);
2369
2370 log_out (fp, "");
2371 }
2372 else
2373 {
2374 hccap_t hccap;
2375
2376 to_hccap_t (&hccap, salt_pos, digest_pos);
2377
2378 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2379 }
2380 }
2381 }
2382
2383 fflush (fp);
2384
2385 fclose (fp);
2386
2387 unlink (old_hashfile);
2388
2389 if (rename (hashfile, old_hashfile) != 0)
2390 {
2391 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2392
2393 exit (-1);
2394 }
2395
2396 unlink (hashfile);
2397
2398 if (rename (new_hashfile, hashfile) != 0)
2399 {
2400 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2401
2402 exit (-1);
2403 }
2404
2405 unlink (old_hashfile);
2406 }
2407
2408 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2409 {
2410 uint num_elements = num;
2411
2412 device_param->kernel_params_buf32[30] = data.combs_mode;
2413 device_param->kernel_params_buf32[31] = num;
2414
2415 uint kernel_threads = device_param->kernel_threads;
2416
2417 while (num_elements % kernel_threads) num_elements++;
2418
2419 cl_kernel kernel = NULL;
2420
2421 switch (kern_run)
2422 {
2423 case KERN_RUN_1: kernel = device_param->kernel1; break;
2424 case KERN_RUN_12: kernel = device_param->kernel12; break;
2425 case KERN_RUN_2: kernel = device_param->kernel2; break;
2426 case KERN_RUN_23: kernel = device_param->kernel23; break;
2427 case KERN_RUN_3: kernel = device_param->kernel3; break;
2428 }
2429
2430 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2431 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2432 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2433 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2434 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2435 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2436 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2437 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2438 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2439 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2440 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2441
2442 cl_event event;
2443
2444 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2445 {
2446 const size_t global_work_size[3] = { num_elements, 32, 1 };
2447 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2448
2449 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2450 }
2451 else
2452 {
2453 if (kern_run == KERN_RUN_2)
2454 {
2455 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2456 {
2457 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2458 }
2459 }
2460
2461 while (num_elements % kernel_threads) num_elements++;
2462
2463 const size_t global_work_size[3] = { num_elements, 1, 1 };
2464 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2465
2466 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2467 }
2468
2469 hc_clFlush (data.ocl, device_param->command_queue);
2470
2471 hc_clWaitForEvents (data.ocl, 1, &event);
2472
2473 if (event_update)
2474 {
2475 cl_ulong time_start;
2476 cl_ulong time_end;
2477
2478 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2479 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2480
2481 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2482
2483 uint exec_pos = device_param->exec_pos;
2484
2485 device_param->exec_ms[exec_pos] = exec_time;
2486
2487 exec_pos++;
2488
2489 if (exec_pos == EXEC_CACHE)
2490 {
2491 exec_pos = 0;
2492 }
2493
2494 device_param->exec_pos = exec_pos;
2495 }
2496
2497 hc_clReleaseEvent (data.ocl, event);
2498
2499 hc_clFinish (data.ocl, device_param->command_queue);
2500 }
2501
2502 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2503 {
2504 uint num_elements = num;
2505
2506 switch (kern_run)
2507 {
2508 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2509 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2510 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2511 }
2512
2513 // causes problems with special threads like in bcrypt
2514 // const uint kernel_threads = device_param->kernel_threads;
2515
2516 uint kernel_threads = device_param->kernel_threads;
2517
2518 while (num_elements % kernel_threads) num_elements++;
2519
2520 cl_kernel kernel = NULL;
2521
2522 switch (kern_run)
2523 {
2524 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2525 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2526 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2527 }
2528
2529 switch (kern_run)
2530 {
2531 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2532 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2533 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2534 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2535 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2536 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2537 break;
2538 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2539 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2540 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2541 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2542 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2543 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2544 break;
2545 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2546 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2547 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2548 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2549 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2550 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2551 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2552 break;
2553 }
2554
2555 const size_t global_work_size[3] = { num_elements, 1, 1 };
2556 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2557
2558 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2559
2560 hc_clFlush (data.ocl, device_param->command_queue);
2561
2562 hc_clFinish (data.ocl, device_param->command_queue);
2563 }
2564
2565 static void run_kernel_tm (hc_device_param_t *device_param)
2566 {
2567 const uint num_elements = 1024; // fixed
2568
2569 uint kernel_threads = 32;
2570
2571 cl_kernel kernel = device_param->kernel_tm;
2572
2573 const size_t global_work_size[3] = { num_elements, 1, 1 };
2574 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2575
2576 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2577
2578 hc_clFlush (data.ocl, device_param->command_queue);
2579
2580 hc_clFinish (data.ocl, device_param->command_queue);
2581 }
2582
2583 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2584 {
2585 uint num_elements = num;
2586
2587 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2588 device_param->kernel_params_amp_buf32[6] = num_elements;
2589
2590 // causes problems with special threads like in bcrypt
2591 // const uint kernel_threads = device_param->kernel_threads;
2592
2593 uint kernel_threads = device_param->kernel_threads;
2594
2595 while (num_elements % kernel_threads) num_elements++;
2596
2597 cl_kernel kernel = device_param->kernel_amp;
2598
2599 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2600 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2601
2602 const size_t global_work_size[3] = { num_elements, 1, 1 };
2603 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2604
2605 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2606
2607 hc_clFlush (data.ocl, device_param->command_queue);
2608
2609 hc_clFinish (data.ocl, device_param->command_queue);
2610 }
2611
2612 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2613 {
2614 const u32 num16d = num / 16;
2615 const u32 num16m = num % 16;
2616
2617 if (num16d)
2618 {
2619 device_param->kernel_params_memset_buf32[1] = value;
2620 device_param->kernel_params_memset_buf32[2] = num16d;
2621
2622 uint kernel_threads = device_param->kernel_threads;
2623
2624 uint num_elements = num16d;
2625
2626 while (num_elements % kernel_threads) num_elements++;
2627
2628 cl_kernel kernel = device_param->kernel_memset;
2629
2630 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2631 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2632 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2633
2634 const size_t global_work_size[3] = { num_elements, 1, 1 };
2635 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2636
2637 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2638
2639 hc_clFlush (data.ocl, device_param->command_queue);
2640
2641 hc_clFinish (data.ocl, device_param->command_queue);
2642 }
2643
2644 if (num16m)
2645 {
2646 u32 tmp[4];
2647
2648 tmp[0] = value;
2649 tmp[1] = value;
2650 tmp[2] = value;
2651 tmp[3] = value;
2652
2653 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2654 }
2655 }
2656
2657 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2658 {
2659 run_kernel_memset (device_param, buf, 0, size);
2660
2661 /*
2662 int rc = -1;
2663
2664 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2665 {
2666 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2667
2668 const cl_uchar zero = 0;
2669
2670 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2671 }
2672
2673 if (rc != 0)
2674 {
2675 // NOTE: clEnqueueFillBuffer () always fails with -59
2676 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2677 // How's that possible, OpenCL 1.2 support is advertised??
2678 // We need to workaround...
2679
2680 #define FILLSZ 0x100000
2681
2682 char *tmp = (char *) mymalloc (FILLSZ);
2683
2684 for (size_t i = 0; i < size; i += FILLSZ)
2685 {
2686 const size_t left = size - i;
2687
2688 const size_t fillsz = MIN (FILLSZ, left);
2689
2690 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2691 }
2692
2693 myfree (tmp);
2694 }
2695 */
2696 }
2697
2698 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2699 {
2700 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2701 {
2702 if (attack_mode == ATTACK_MODE_BF)
2703 {
2704 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2705 {
2706 const uint size_tm = 32 * sizeof (bs_word_t);
2707
2708 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2709
2710 run_kernel_tm (device_param);
2711
2712 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2713 }
2714 }
2715
2716 if (highest_pw_len < 16)
2717 {
2718 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2719 }
2720 else if (highest_pw_len < 32)
2721 {
2722 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2723 }
2724 else
2725 {
2726 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2727 }
2728 }
2729 else
2730 {
2731 run_kernel_amp (device_param, pws_cnt);
2732
2733 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2734
2735 if (opts_type & OPTS_TYPE_HOOK12)
2736 {
2737 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2738 }
2739
2740 uint iter = salt_buf->salt_iter;
2741
2742 uint loop_step = device_param->kernel_loops;
2743
2744 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2745 {
2746 uint loop_left = iter - loop_pos;
2747
2748 loop_left = MIN (loop_left, loop_step);
2749
2750 device_param->kernel_params_buf32[25] = loop_pos;
2751 device_param->kernel_params_buf32[26] = loop_left;
2752
2753 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2754
2755 if (data.devices_status == STATUS_CRACKED) break;
2756 if (data.devices_status == STATUS_ABORTED) break;
2757 if (data.devices_status == STATUS_QUIT) break;
2758
2759 /**
2760 * speed
2761 */
2762
2763 const float iter_part = (float) (loop_pos + loop_left) / iter;
2764
2765 const u64 perf_sum_all = pws_cnt * iter_part;
2766
2767 double speed_ms;
2768
2769 hc_timer_get (device_param->timer_speed, speed_ms);
2770
2771 const u32 speed_pos = device_param->speed_pos;
2772
2773 device_param->speed_cnt[speed_pos] = perf_sum_all;
2774
2775 device_param->speed_ms[speed_pos] = speed_ms;
2776
2777 if (data.benchmark == 1)
2778 {
2779 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2780 }
2781 }
2782
2783 if (opts_type & OPTS_TYPE_HOOK23)
2784 {
2785 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2786
2787 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2788
2789 // do something with data
2790
2791 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2792 }
2793
2794 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2795 }
2796 }
2797
2798 static int run_rule_engine (const int rule_len, const char *rule_buf)
2799 {
2800 if (rule_len == 0)
2801 {
2802 return 0;
2803 }
2804 else if (rule_len == 1)
2805 {
2806 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2807 }
2808
2809 return 1;
2810 }
2811
2812 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2813 {
2814 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2815 {
2816 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2817 }
2818 else if (data.attack_kern == ATTACK_KERN_COMBI)
2819 {
2820 if (data.attack_mode == ATTACK_MODE_COMBI)
2821 {
2822 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2823 {
2824 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2825 {
2826 for (u32 i = 0; i < pws_cnt; i++)
2827 {
2828 const u32 pw_len = device_param->pws_buf[i].pw_len;
2829
2830 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2831
2832 ptr[pw_len] = 0x01;
2833 }
2834 }
2835 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2836 {
2837 for (u32 i = 0; i < pws_cnt; i++)
2838 {
2839 const u32 pw_len = device_param->pws_buf[i].pw_len;
2840
2841 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2842
2843 ptr[pw_len] = 0x80;
2844 }
2845 }
2846 }
2847 }
2848 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2849 {
2850 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2851 {
2852 for (u32 i = 0; i < pws_cnt; i++)
2853 {
2854 const u32 pw_len = device_param->pws_buf[i].pw_len;
2855
2856 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2857
2858 ptr[pw_len] = 0x01;
2859 }
2860 }
2861 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2862 {
2863 for (u32 i = 0; i < pws_cnt; i++)
2864 {
2865 const u32 pw_len = device_param->pws_buf[i].pw_len;
2866
2867 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2868
2869 ptr[pw_len] = 0x80;
2870 }
2871 }
2872 }
2873
2874 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2875 }
2876 else if (data.attack_kern == ATTACK_KERN_BF)
2877 {
2878 const u64 off = device_param->words_off;
2879
2880 device_param->kernel_params_mp_l_buf64[3] = off;
2881
2882 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2883 }
2884 }
2885
2886 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2887 {
2888 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2889
2890 device_param->kernel_params_buf32[25] = 0;
2891 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2892 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2893
2894 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2895 {
2896 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true);
2897 }
2898 else
2899 {
2900 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true);
2901 }
2902
2903 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2904
2905 return exec_ms_prev;
2906 }
2907
2908 static void autotune (hc_device_param_t *device_param)
2909 {
2910 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2911
2912 const u32 kernel_accel_min = device_param->kernel_accel_min;
2913 const u32 kernel_accel_max = device_param->kernel_accel_max;
2914
2915 const u32 kernel_loops_min = device_param->kernel_loops_min;
2916 const u32 kernel_loops_max = device_param->kernel_loops_max;
2917
2918 u32 kernel_accel = kernel_accel_min;
2919 u32 kernel_loops = kernel_loops_min;
2920
2921 // in this case the user specified a fixed -u and -n on the commandline
2922 // no way to tune anything
2923 // but we need to run a few caching rounds
2924
2925 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2926 {
2927 try_run (device_param, kernel_accel, kernel_loops);
2928 try_run (device_param, kernel_accel, kernel_loops);
2929 try_run (device_param, kernel_accel, kernel_loops);
2930 try_run (device_param, kernel_accel, kernel_loops);
2931
2932 device_param->kernel_accel = kernel_accel;
2933 device_param->kernel_loops = kernel_loops;
2934
2935 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2936
2937 device_param->kernel_power = kernel_power;
2938
2939 return;
2940 }
2941
2942 // from here it's clear we are allowed to autotune
2943 // so let's init some fake words
2944
2945 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2946
2947 if (data.attack_kern == ATTACK_KERN_BF)
2948 {
2949 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2950 }
2951 else
2952 {
2953 for (u32 i = 0; i < kernel_power_max; i++)
2954 {
2955 device_param->pws_buf[i].i[0] = i;
2956 device_param->pws_buf[i].i[1] = 0x01234567;
2957 device_param->pws_buf[i].pw_len = 7 + (i & 7);
2958 }
2959
2960 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2961 }
2962
2963 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2964 {
2965 if (data.kernel_rules_cnt > 1)
2966 {
2967 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, 0, 0, MIN (kernel_loops_max, KERNEL_RULES) * sizeof (kernel_rule_t), 0, NULL, NULL);
2968 }
2969 }
2970 else
2971 {
2972 run_kernel_amp (device_param, kernel_power_max);
2973 }
2974
2975 #define VERIFIER_CNT 1
2976
2977 // first find out highest kernel-loops that stays below target_ms
2978
2979 if (kernel_loops_min < kernel_loops_max)
2980 {
2981 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2982 {
2983 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2984
2985 for (int i = 0; i < VERIFIER_CNT; i++)
2986 {
2987 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
2988
2989 exec_ms = MIN (exec_ms, exec_ms_v);
2990 }
2991
2992 if (exec_ms < target_ms) break;
2993 }
2994 }
2995
2996 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2997
2998 #define STEPS_CNT 10
2999
3000 if (kernel_accel_min < kernel_accel_max)
3001 {
3002 for (int i = 0; i < STEPS_CNT; i++)
3003 {
3004 const u32 kernel_accel_try = 1 << i;
3005
3006 if (kernel_accel_try < kernel_accel_min) continue;
3007 if (kernel_accel_try > kernel_accel_max) break;
3008
3009 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3010
3011 for (int i = 0; i < VERIFIER_CNT; i++)
3012 {
3013 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3014
3015 exec_ms = MIN (exec_ms, exec_ms_v);
3016 }
3017
3018 if (exec_ms > target_ms) break;
3019
3020 kernel_accel = kernel_accel_try;
3021 }
3022 }
3023
3024 // at this point we want to know the actual runtime for the following reason:
3025 // we need a reference for the balancing loop following up, and this
3026 // the balancing loop can have an effect that the creates a new opportunity, for example:
3027 // if the target is 95 ms and the current runtime is 48ms the above loop
3028 // stopped the execution because the previous exec_ms was > 95ms
3029 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3030 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3031
3032 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3033
3034 for (int i = 0; i < VERIFIER_CNT; i++)
3035 {
3036 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3037
3038 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3039 }
3040
3041 u32 diff = kernel_loops - kernel_accel;
3042
3043 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3044 {
3045 u32 kernel_accel_orig = kernel_accel;
3046 u32 kernel_loops_orig = kernel_loops;
3047
3048 for (u32 f = 1; f < 1024; f++)
3049 {
3050 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3051 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3052
3053 if (kernel_accel_try > kernel_accel_max) break;
3054 if (kernel_loops_try < kernel_loops_min) break;
3055
3056 u32 diff_new = kernel_loops_try - kernel_accel_try;
3057
3058 if (diff_new > diff) break;
3059
3060 diff_new = diff;
3061
3062 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3063
3064 for (int i = 0; i < VERIFIER_CNT; i++)
3065 {
3066 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3067
3068 exec_ms = MIN (exec_ms, exec_ms_v);
3069 }
3070
3071 if (exec_ms < exec_ms_pre_final)
3072 {
3073 exec_ms_pre_final = exec_ms;
3074
3075 kernel_accel = kernel_accel_try;
3076 kernel_loops = kernel_loops_try;
3077 }
3078 }
3079 }
3080
3081 const double exec_left = target_ms / exec_ms_pre_final;
3082
3083 const double accel_left = kernel_accel_max / kernel_accel;
3084
3085 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3086
3087 if (exec_accel_min >= 1.0)
3088 {
3089 // this is safe to not overflow kernel_accel_max because of accel_left
3090
3091 kernel_accel = (double) kernel_accel * exec_accel_min;
3092 }
3093
3094 // reset them fake words
3095
3096 /*
3097 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3098
3099 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3100 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3101 */
3102
3103 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3104
3105 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3106 {
3107 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3108 }
3109
3110 // reset timer
3111
3112 device_param->exec_pos = 0;
3113
3114 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3115
3116 // store
3117
3118 device_param->kernel_accel = kernel_accel;
3119 device_param->kernel_loops = kernel_loops;
3120
3121 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3122
3123 device_param->kernel_power = kernel_power;
3124
3125 #ifdef DEBUG
3126
3127 if (data.quiet == 0)
3128 {
3129 clear_prompt ();
3130
3131 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3132 "Device #%u: autotuned kernel-loops to %u\n",
3133 device_param->device_id + 1, kernel_accel,
3134 device_param->device_id + 1, kernel_loops);
3135
3136 fprintf (stdout, "%s", PROMPT);
3137
3138 fflush (stdout);
3139 }
3140
3141 #endif
3142 }
3143
3144 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3145 {
3146 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3147
3148 // init speed timer
3149
3150 uint speed_pos = device_param->speed_pos;
3151
3152 #ifdef _POSIX
3153 if (device_param->timer_speed.tv_sec == 0)
3154 {
3155 hc_timer_set (&device_param->timer_speed);
3156 }
3157 #endif
3158
3159 #ifdef _WIN
3160 if (device_param->timer_speed.QuadPart == 0)
3161 {
3162 hc_timer_set (&device_param->timer_speed);
3163 }
3164 #endif
3165
3166 // find higest password length, this is for optimization stuff
3167
3168 uint highest_pw_len = 0;
3169
3170 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3171 {
3172 }
3173 else if (data.attack_kern == ATTACK_KERN_COMBI)
3174 {
3175 }
3176 else if (data.attack_kern == ATTACK_KERN_BF)
3177 {
3178 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3179 + device_param->kernel_params_mp_l_buf32[5];
3180 }
3181
3182 // iteration type
3183
3184 uint innerloop_step = 0;
3185 uint innerloop_cnt = 0;
3186
3187 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3188 else innerloop_step = 1;
3189
3190 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3191 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3192 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3193
3194 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3195
3196 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3197 {
3198 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3199
3200 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3201
3202 if (data.devices_status == STATUS_CRACKED) break;
3203 if (data.devices_status == STATUS_ABORTED) break;
3204 if (data.devices_status == STATUS_QUIT) break;
3205 if (data.devices_status == STATUS_BYPASS) break;
3206
3207 salt_t *salt_buf = &data.salts_buf[salt_pos];
3208
3209 device_param->kernel_params_buf32[24] = salt_pos;
3210 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3211 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3212
3213 FILE *combs_fp = device_param->combs_fp;
3214
3215 if (data.attack_mode == ATTACK_MODE_COMBI)
3216 {
3217 rewind (combs_fp);
3218 }
3219
3220 // innerloops
3221
3222 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3223 {
3224 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3225
3226 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3227
3228 if (data.devices_status == STATUS_CRACKED) break;
3229 if (data.devices_status == STATUS_ABORTED) break;
3230 if (data.devices_status == STATUS_QUIT) break;
3231 if (data.devices_status == STATUS_BYPASS) break;
3232
3233 uint innerloop_left = innerloop_cnt - innerloop_pos;
3234
3235 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3236
3237 device_param->innerloop_pos = innerloop_pos;
3238 device_param->innerloop_left = innerloop_left;
3239
3240 device_param->kernel_params_buf32[27] = innerloop_left;
3241
3242 // i think we can get rid of this
3243 if (innerloop_left == 0)
3244 {
3245 puts ("bug, how should this happen????\n");
3246
3247 continue;
3248 }
3249
3250 if (data.salts_shown[salt_pos] == 1)
3251 {
3252 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3253
3254 continue;
3255 }
3256
3257 // initialize amplifiers
3258
3259 if (data.attack_mode == ATTACK_MODE_COMBI)
3260 {
3261 uint i = 0;
3262
3263 while (i < innerloop_left)
3264 {
3265 if (feof (combs_fp)) break;
3266
3267 int line_len = fgetl (combs_fp, line_buf);
3268
3269 if (line_len >= PW_MAX1) continue;
3270
3271 line_len = convert_from_hex (line_buf, line_len);
3272
3273 char *line_buf_new = line_buf;
3274
3275 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3276 {
3277 char rule_buf_out[BLOCK_SIZE] = { 0 };
3278
3279 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3280
3281 if (rule_len_out < 0)
3282 {
3283 data.words_progress_rejected[salt_pos] += pws_cnt;
3284
3285 continue;
3286 }
3287
3288 line_len = rule_len_out;
3289
3290 line_buf_new = rule_buf_out;
3291 }
3292
3293 line_len = MIN (line_len, PW_DICTMAX);
3294
3295 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3296
3297 memcpy (ptr, line_buf_new, line_len);
3298
3299 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3300
3301 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3302 {
3303 uppercase (ptr, line_len);
3304 }
3305
3306 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3307 {
3308 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3309 {
3310 ptr[line_len] = 0x80;
3311 }
3312
3313 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3314 {
3315 ptr[line_len] = 0x01;
3316 }
3317 }
3318
3319 device_param->combs_buf[i].pw_len = line_len;
3320
3321 i++;
3322 }
3323
3324 for (uint j = i; j < innerloop_left; j++)
3325 {
3326 device_param->combs_buf[j].i[0] = 0;
3327 device_param->combs_buf[j].i[1] = 0;
3328 device_param->combs_buf[j].i[2] = 0;
3329 device_param->combs_buf[j].i[3] = 0;
3330 device_param->combs_buf[j].i[4] = 0;
3331 device_param->combs_buf[j].i[5] = 0;
3332 device_param->combs_buf[j].i[6] = 0;
3333 device_param->combs_buf[j].i[7] = 0;
3334
3335 device_param->combs_buf[j].pw_len = 0;
3336 }
3337
3338 innerloop_left = i;
3339 }
3340 else if (data.attack_mode == ATTACK_MODE_BF)
3341 {
3342 u64 off = innerloop_pos;
3343
3344 device_param->kernel_params_mp_r_buf64[3] = off;
3345
3346 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3347 }
3348 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3349 {
3350 u64 off = innerloop_pos;
3351
3352 device_param->kernel_params_mp_buf64[3] = off;
3353
3354 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3355 }
3356 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3357 {
3358 u64 off = innerloop_pos;
3359
3360 device_param->kernel_params_mp_buf64[3] = off;
3361
3362 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3363 }
3364
3365 // copy amplifiers
3366
3367 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3368 {
3369 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
3370 }
3371 else if (data.attack_mode == ATTACK_MODE_COMBI)
3372 {
3373 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
3374 }
3375 else if (data.attack_mode == ATTACK_MODE_BF)
3376 {
3377 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
3378 }
3379 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3380 {
3381 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3382 }
3383 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3384 {
3385 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3386 }
3387
3388 if (data.benchmark == 1)
3389 {
3390 hc_timer_set (&device_param->timer_speed);
3391 }
3392
3393 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3394
3395 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3396
3397 if (data.devices_status == STATUS_CRACKED) break;
3398 if (data.devices_status == STATUS_ABORTED) break;
3399 if (data.devices_status == STATUS_QUIT) break;
3400
3401 /**
3402 * result
3403 */
3404
3405 if (data.benchmark == 0)
3406 {
3407 check_cracked (device_param, salt_pos);
3408 }
3409
3410 /**
3411 * progress
3412 */
3413
3414 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3415
3416 hc_thread_mutex_lock (mux_counter);
3417
3418 data.words_progress_done[salt_pos] += perf_sum_all;
3419
3420 hc_thread_mutex_unlock (mux_counter);
3421
3422 /**
3423 * speed
3424 */
3425
3426 double speed_ms;
3427
3428 hc_timer_get (device_param->timer_speed, speed_ms);
3429
3430 hc_timer_set (&device_param->timer_speed);
3431
3432 // current speed
3433
3434 //hc_thread_mutex_lock (mux_display);
3435
3436 device_param->speed_cnt[speed_pos] = perf_sum_all;
3437
3438 device_param->speed_ms[speed_pos] = speed_ms;
3439
3440 //hc_thread_mutex_unlock (mux_display);
3441
3442 speed_pos++;
3443
3444 if (speed_pos == SPEED_CACHE)
3445 {
3446 speed_pos = 0;
3447 }
3448
3449 /**
3450 * benchmark
3451 */
3452
3453 if (data.benchmark == 1) break;
3454 }
3455 }
3456
3457 device_param->speed_pos = speed_pos;
3458
3459 myfree (line_buf);
3460 }
3461
3462 static void load_segment (wl_data_t *wl_data, FILE *fd)
3463 {
3464 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3465
3466 wl_data->pos = 0;
3467
3468 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3469
3470 wl_data->buf[wl_data->cnt] = 0;
3471
3472 if (wl_data->cnt == 0) return;
3473
3474 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3475
3476 while (!feof (fd))
3477 {
3478 if (wl_data->cnt == wl_data->avail)
3479 {
3480 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3481
3482 wl_data->avail += wl_data->incr;
3483 }
3484
3485 const int c = fgetc (fd);
3486
3487 if (c == EOF) break;
3488
3489 wl_data->buf[wl_data->cnt] = (char) c;
3490
3491 wl_data->cnt++;
3492
3493 if (c == '\n') break;
3494 }
3495
3496 // ensure stream ends with a newline
3497
3498 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3499 {
3500 wl_data->cnt++;
3501
3502 wl_data->buf[wl_data->cnt - 1] = '\n';
3503 }
3504
3505 return;
3506 }
3507
3508 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3509 {
3510 char *ptr = buf;
3511
3512 for (u32 i = 0; i < sz; i++, ptr++)
3513 {
3514 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3515
3516 if (i == 7)
3517 {
3518 *off = i;
3519 *len = i;
3520
3521 return;
3522 }
3523
3524 if (*ptr != '\n') continue;
3525
3526 *off = i + 1;
3527
3528 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3529
3530 *len = i;
3531
3532 return;
3533 }
3534
3535 *off = sz;
3536 *len = sz;
3537 }
3538
3539 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3540 {
3541 char *ptr = buf;
3542
3543 for (u32 i = 0; i < sz; i++, ptr++)
3544 {
3545 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3546
3547 if (*ptr != '\n') continue;
3548
3549 *off = i + 1;
3550
3551 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3552
3553 *len = i;
3554
3555 return;
3556 }
3557
3558 *off = sz;
3559 *len = sz;
3560 }
3561
3562 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3563 {
3564 char *ptr = buf;
3565
3566 for (u32 i = 0; i < sz; i++, ptr++)
3567 {
3568 if (*ptr != '\n') continue;
3569
3570 *off = i + 1;
3571
3572 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3573
3574 *len = i;
3575
3576 return;
3577 }
3578
3579 *off = sz;
3580 *len = sz;
3581 }
3582
3583 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3584 {
3585 while (wl_data->pos < wl_data->cnt)
3586 {
3587 uint off;
3588 uint len;
3589
3590 char *ptr = wl_data->buf + wl_data->pos;
3591
3592 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3593
3594 wl_data->pos += off;
3595
3596 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3597 {
3598 char rule_buf_out[BLOCK_SIZE] = { 0 };
3599
3600 int rule_len_out = -1;
3601
3602 if (len < BLOCK_SIZE)
3603 {
3604 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3605 }
3606
3607 if (rule_len_out < 0)
3608 {
3609 continue;
3610 }
3611
3612 if (rule_len_out > PW_MAX)
3613 {
3614 continue;
3615 }
3616 }
3617 else
3618 {
3619 if (len > PW_MAX)
3620 {
3621 continue;
3622 }
3623 }
3624
3625 *out_buf = ptr;
3626 *out_len = len;
3627
3628 return;
3629 }
3630
3631 if (feof (fd))
3632 {
3633 fprintf (stderr, "BUG feof()!!\n");
3634
3635 return;
3636 }
3637
3638 load_segment (wl_data, fd);
3639
3640 get_next_word (wl_data, fd, out_buf, out_len);
3641 }
3642
3643 #ifdef _POSIX
3644 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3645 #endif
3646
3647 #ifdef _WIN
3648 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3649 #endif
3650 {
3651 hc_signal (NULL);
3652
3653 dictstat_t d;
3654
3655 d.cnt = 0;
3656
3657 #ifdef _POSIX
3658 fstat (fileno (fd), &d.stat);
3659 #endif
3660
3661 #ifdef _WIN
3662 _fstat64 (fileno (fd), &d.stat);
3663 #endif
3664
3665 d.stat.st_mode = 0;
3666 d.stat.st_nlink = 0;
3667 d.stat.st_uid = 0;
3668 d.stat.st_gid = 0;
3669 d.stat.st_rdev = 0;
3670 d.stat.st_atime = 0;
3671
3672 #ifdef _POSIX
3673 d.stat.st_blksize = 0;
3674 d.stat.st_blocks = 0;
3675 #endif
3676
3677 if (d.stat.st_size == 0) return 0;
3678
3679 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3680
3681 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3682 {
3683 if (d_cache)
3684 {
3685 u64 cnt = d_cache->cnt;
3686
3687 u64 keyspace = cnt;
3688
3689 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3690 {
3691 keyspace *= data.kernel_rules_cnt;
3692 }
3693 else if (data.attack_kern == ATTACK_KERN_COMBI)
3694 {
3695 keyspace *= data.combs_cnt;
3696 }
3697
3698 if (data.quiet == 0) log_info ("Cache-hit dictionary stats %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) d.stat.st_size, (unsigned long long int) cnt, (unsigned long long int) keyspace);
3699 if (data.quiet == 0) log_info ("");
3700
3701 hc_signal (sigHandler_default);
3702
3703 return (keyspace);
3704 }
3705 }
3706
3707 time_t now = 0;
3708 time_t prev = 0;
3709
3710 u64 comp = 0;
3711 u64 cnt = 0;
3712 u64 cnt2 = 0;
3713
3714 while (!feof (fd))
3715 {
3716 load_segment (wl_data, fd);
3717
3718 comp += wl_data->cnt;
3719
3720 u32 i = 0;
3721
3722 while (i < wl_data->cnt)
3723 {
3724 u32 len;
3725 u32 off;
3726
3727 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3728
3729 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3730 {
3731 char rule_buf_out[BLOCK_SIZE] = { 0 };
3732
3733 int rule_len_out = -1;
3734
3735 if (len < BLOCK_SIZE)
3736 {
3737 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3738 }
3739
3740 if (rule_len_out < 0)
3741 {
3742 len = PW_MAX1;
3743 }
3744 else
3745 {
3746 len = rule_len_out;
3747 }
3748 }
3749
3750 if (len < PW_MAX1)
3751 {
3752 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3753 {
3754 cnt += data.kernel_rules_cnt;
3755 }
3756 else if (data.attack_kern == ATTACK_KERN_COMBI)
3757 {
3758 cnt += data.combs_cnt;
3759 }
3760
3761 d.cnt++;
3762 }
3763
3764 i += off;
3765
3766 cnt2++;
3767 }
3768
3769 time (&now);
3770
3771 if ((now - prev) == 0) continue;
3772
3773 float percent = (float) comp / (float) d.stat.st_size;
3774
3775 if (data.quiet == 0) log_info_nn ("Generating dictionary stats for %s: %llu bytes (%.2f%%), %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, percent * 100, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3776
3777 time (&prev);
3778 }
3779
3780 if (data.quiet == 0) log_info ("Generated dictionary stats for %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3781 if (data.quiet == 0) log_info ("");
3782
3783 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3784
3785 hc_signal (sigHandler_default);
3786
3787 return (cnt);
3788 }
3789
3790 static void *thread_monitor (void *p)
3791 {
3792 uint runtime_check = 0;
3793 uint remove_check = 0;
3794 uint status_check = 0;
3795 uint restore_check = 0;
3796
3797 uint restore_left = data.restore_timer;
3798 uint remove_left = data.remove_timer;
3799 uint status_left = data.status_timer;
3800
3801 #ifdef HAVE_HWMON
3802 uint hwmon_check = 0;
3803
3804 int slowdown_warnings = 0;
3805
3806 // these variables are mainly used for fan control
3807
3808 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3809
3810 // temperature controller "loopback" values
3811
3812 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3813 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3814
3815 int temp_threshold = 1; // degrees celcius
3816
3817 int fan_speed_min = 15; // in percentage
3818 int fan_speed_max = 100;
3819
3820 time_t last_temp_check_time;
3821 #endif // HAVE_HWMON
3822
3823 uint sleep_time = 1;
3824
3825 if (data.runtime)
3826 {
3827 runtime_check = 1;
3828 }
3829
3830 if (data.restore_timer)
3831 {
3832 restore_check = 1;
3833 }
3834
3835 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3836 {
3837 remove_check = 1;
3838 }
3839
3840 if (data.status == 1)
3841 {
3842 status_check = 1;
3843 }
3844
3845 #ifdef HAVE_HWMON
3846 if (data.gpu_temp_disable == 0)
3847 {
3848 time (&last_temp_check_time);
3849
3850 hwmon_check = 1;
3851 }
3852 #endif
3853
3854 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3855 {
3856 #ifdef HAVE_HWMON
3857 if (hwmon_check == 0)
3858 #endif
3859 return (p);
3860 }
3861
3862 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3863 {
3864 hc_sleep (sleep_time);
3865
3866 if (data.devices_status != STATUS_RUNNING) continue;
3867
3868 #ifdef HAVE_HWMON
3869
3870 if (hwmon_check == 1)
3871 {
3872 hc_thread_mutex_lock (mux_adl);
3873
3874 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3875 {
3876 hc_device_param_t *device_param = &data.devices_param[device_id];
3877
3878 if (device_param->skipped) continue;
3879
3880 if (device_param->device_vendor_id == VENDOR_ID_NV)
3881 {
3882 if (data.hm_nvapi)
3883 {
3884 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
3885 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
3886
3887 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
3888 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
3889
3890 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
3891
3892 perfPolicies_status.info_value = perfPolicies_info.info_value;
3893
3894 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
3895
3896 if (perfPolicies_status.throttle & 2)
3897 {
3898 if (slowdown_warnings < 3)
3899 {
3900 if (data.quiet == 0) clear_prompt ();
3901
3902 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
3903
3904 if (slowdown_warnings == 2)
3905 {
3906 log_info ("");
3907 }
3908
3909 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
3910 if (data.quiet == 0) fflush (stdout);
3911
3912 slowdown_warnings++;
3913 }
3914 }
3915 else
3916 {
3917 slowdown_warnings = 0;
3918 }
3919 }
3920 }
3921 }
3922
3923 hc_thread_mutex_unlock (mux_adl);
3924 }
3925
3926 if (hwmon_check == 1)
3927 {
3928 hc_thread_mutex_lock (mux_adl);
3929
3930 time_t temp_check_time;
3931
3932 time (&temp_check_time);
3933
3934 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3935
3936 if (Ta == 0) Ta = 1;
3937
3938 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3939 {
3940 hc_device_param_t *device_param = &data.devices_param[device_id];
3941
3942 if (device_param->skipped) continue;
3943
3944 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3945
3946 const int temperature = hm_get_temperature_with_device_id (device_id);
3947
3948 if (temperature > (int) data.gpu_temp_abort)
3949 {
3950 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3951
3952 if (data.devices_status != STATUS_QUIT) myabort ();
3953
3954 break;
3955 }
3956
3957 const int gpu_temp_retain = data.gpu_temp_retain;
3958
3959 if (gpu_temp_retain)
3960 {
3961 if (data.hm_device[device_id].fan_set_supported == 1)
3962 {
3963 int temp_cur = temperature;
3964
3965 int temp_diff_new = gpu_temp_retain - temp_cur;
3966
3967 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3968
3969 // calculate Ta value (time difference in seconds between the last check and this check)
3970
3971 last_temp_check_time = temp_check_time;
3972
3973 float Kp = 1.8;
3974 float Ki = 0.005;
3975 float Kd = 6;
3976
3977 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3978
3979 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
3980
3981 if (abs (fan_diff_required) >= temp_threshold)
3982 {
3983 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3984
3985 int fan_speed_level = fan_speed_cur;
3986
3987 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3988
3989 int fan_speed_new = fan_speed_level - fan_diff_required;
3990
3991 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3992 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3993
3994 if (fan_speed_new != fan_speed_cur)
3995 {
3996 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3997 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3998
3999 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4000 {
4001 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4002 {
4003 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4004 }
4005 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4006 {
4007
4008 }
4009
4010 fan_speed_chgd[device_id] = 1;
4011 }
4012
4013 temp_diff_old[device_id] = temp_diff_new;
4014 }
4015 }
4016 }
4017 }
4018 }
4019
4020 hc_thread_mutex_unlock (mux_adl);
4021 }
4022 #endif // HAVE_HWMON
4023
4024 if (restore_check == 1)
4025 {
4026 restore_left--;
4027
4028 if (restore_left == 0)
4029 {
4030 if (data.restore_disable == 0) cycle_restore ();
4031
4032 restore_left = data.restore_timer;
4033 }
4034 }
4035
4036 if ((runtime_check == 1) && (data.runtime_start > 0))
4037 {
4038 time_t runtime_cur;
4039
4040 time (&runtime_cur);
4041
4042 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4043
4044 if (runtime_left <= 0)
4045 {
4046 if (data.benchmark == 0)
4047 {
4048 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4049 }
4050
4051 if (data.devices_status != STATUS_QUIT) myabort ();
4052 }
4053 }
4054
4055 if (remove_check == 1)
4056 {
4057 remove_left--;
4058
4059 if (remove_left == 0)
4060 {
4061 if (data.digests_saved != data.digests_done)
4062 {
4063 data.digests_saved = data.digests_done;
4064
4065 save_hash ();
4066 }
4067
4068 remove_left = data.remove_timer;
4069 }
4070 }
4071
4072 if (status_check == 1)
4073 {
4074 status_left--;
4075
4076 if (status_left == 0)
4077 {
4078 //hc_thread_mutex_lock (mux_display);
4079
4080 if (data.quiet == 0) clear_prompt ();
4081
4082 if (data.quiet == 0) log_info ("");
4083
4084 status_display ();
4085
4086 if (data.quiet == 0) log_info ("");
4087
4088 //hc_thread_mutex_unlock (mux_display);
4089
4090 status_left = data.status_timer;
4091 }
4092 }
4093 }
4094
4095 #ifdef HAVE_HWMON
4096 myfree (fan_speed_chgd);
4097
4098 myfree (temp_diff_old);
4099 myfree (temp_diff_sum);
4100 #endif
4101
4102 p = NULL;
4103
4104 return (p);
4105 }
4106
4107 static void *thread_outfile_remove (void *p)
4108 {
4109 // some hash-dependent constants
4110 char *outfile_dir = data.outfile_check_directory;
4111 uint dgst_size = data.dgst_size;
4112 uint isSalted = data.isSalted;
4113 uint esalt_size = data.esalt_size;
4114 uint hash_mode = data.hash_mode;
4115
4116 uint outfile_check_timer = data.outfile_check_timer;
4117
4118 char separator = data.separator;
4119
4120 // some hash-dependent functions
4121 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4122 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4123
4124 // buffers
4125 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4126
4127 hash_buf.digest = mymalloc (dgst_size);
4128
4129 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4130
4131 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4132
4133 uint digest_buf[64] = { 0 };
4134
4135 outfile_data_t *out_info = NULL;
4136
4137 char **out_files = NULL;
4138
4139 time_t folder_mtime = 0;
4140
4141 int out_cnt = 0;
4142
4143 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4144
4145 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4146 {
4147 hc_sleep (1);
4148
4149 if (data.devices_status != STATUS_RUNNING) continue;
4150
4151 check_left--;
4152
4153 if (check_left == 0)
4154 {
4155 struct stat outfile_check_stat;
4156
4157 if (stat (outfile_dir, &outfile_check_stat) == 0)
4158 {
4159 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4160
4161 if (is_dir == 1)
4162 {
4163 if (outfile_check_stat.st_mtime > folder_mtime)
4164 {
4165 char **out_files_new = scan_directory (outfile_dir);
4166
4167 int out_cnt_new = count_dictionaries (out_files_new);
4168
4169 outfile_data_t *out_info_new = NULL;
4170
4171 if (out_cnt_new > 0)
4172 {
4173 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4174
4175 for (int i = 0; i < out_cnt_new; i++)
4176 {
4177 out_info_new[i].file_name = out_files_new[i];
4178
4179 // check if there are files that we have seen/checked before (and not changed)
4180
4181 for (int j = 0; j < out_cnt; j++)
4182 {
4183 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4184 {
4185 struct stat outfile_stat;
4186
4187 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4188 {
4189 if (outfile_stat.st_ctime == out_info[j].ctime)
4190 {
4191 out_info_new[i].ctime = out_info[j].ctime;
4192 out_info_new[i].seek = out_info[j].seek;
4193 }
4194 }
4195 }
4196 }
4197 }
4198 }
4199
4200 local_free (out_info);
4201 local_free (out_files);
4202
4203 out_files = out_files_new;
4204 out_cnt = out_cnt_new;
4205 out_info = out_info_new;
4206
4207 folder_mtime = outfile_check_stat.st_mtime;
4208 }
4209
4210 for (int j = 0; j < out_cnt; j++)
4211 {
4212 FILE *fp = fopen (out_info[j].file_name, "rb");
4213
4214 if (fp != NULL)
4215 {
4216 //hc_thread_mutex_lock (mux_display);
4217
4218 #ifdef _POSIX
4219 struct stat outfile_stat;
4220
4221 fstat (fileno (fp), &outfile_stat);
4222 #endif
4223
4224 #ifdef _WIN
4225 struct stat64 outfile_stat;
4226
4227 _fstat64 (fileno (fp), &outfile_stat);
4228 #endif
4229
4230 if (outfile_stat.st_ctime > out_info[j].ctime)
4231 {
4232 out_info[j].ctime = outfile_stat.st_ctime;
4233 out_info[j].seek = 0;
4234 }
4235
4236 fseek (fp, out_info[j].seek, SEEK_SET);
4237
4238 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4239
4240 while (!feof (fp))
4241 {
4242 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4243
4244 if (ptr == NULL) break;
4245
4246 int line_len = strlen (line_buf);
4247
4248 if (line_len <= 0) continue;
4249
4250 int iter = MAX_CUT_TRIES;
4251
4252 for (uint i = line_len - 1; i && iter; i--, line_len--)
4253 {
4254 if (line_buf[i] != separator) continue;
4255
4256 int parser_status = PARSER_OK;
4257
4258 if ((hash_mode != 2500) && (hash_mode != 6800))
4259 {
4260 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4261 }
4262
4263 uint found = 0;
4264
4265 if (parser_status == PARSER_OK)
4266 {
4267 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4268 {
4269 if (data.salts_shown[salt_pos] == 1) continue;
4270
4271 salt_t *salt_buf = &data.salts_buf[salt_pos];
4272
4273 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4274 {
4275 uint idx = salt_buf->digests_offset + digest_pos;
4276
4277 if (data.digests_shown[idx] == 1) continue;
4278
4279 uint cracked = 0;
4280
4281 if (hash_mode == 6800)
4282 {
4283 if (i == salt_buf->salt_len)
4284 {
4285 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4286 }
4287 }
4288 else if (hash_mode == 2500)
4289 {
4290 // BSSID : MAC1 : MAC2 (:plain)
4291 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4292 {
4293 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4294
4295 if (!cracked) continue;
4296
4297 // now compare MAC1 and MAC2 too, since we have this additional info
4298 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4299 char *mac2_pos = mac1_pos + 12 + 1;
4300
4301 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4302 wpa_t *wpa = &wpas[salt_pos];
4303
4304 // compare hex string(s) vs binary MAC address(es)
4305
4306 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4307 {
4308 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4309 {
4310 cracked = 0;
4311
4312 break;
4313 }
4314 }
4315
4316 // early skip ;)
4317 if (!cracked) continue;
4318
4319 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4320 {
4321 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4322 {
4323 cracked = 0;
4324
4325 break;
4326 }
4327 }
4328 }
4329 }
4330 else
4331 {
4332 char *digests_buf_ptr = (char *) data.digests_buf;
4333
4334 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4335
4336 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4337 }
4338
4339 if (cracked == 1)
4340 {
4341 found = 1;
4342
4343 data.digests_shown[idx] = 1;
4344
4345 data.digests_done++;
4346
4347 salt_buf->digests_done++;
4348
4349 if (salt_buf->digests_done == salt_buf->digests_cnt)
4350 {
4351 data.salts_shown[salt_pos] = 1;
4352
4353 data.salts_done++;
4354
4355 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4356 }
4357 }
4358 }
4359
4360 if (data.devices_status == STATUS_CRACKED) break;
4361 }
4362 }
4363
4364 if (found) break;
4365
4366 if (data.devices_status == STATUS_CRACKED) break;
4367
4368 iter--;
4369 }
4370
4371 if (data.devices_status == STATUS_CRACKED) break;
4372 }
4373
4374 myfree (line_buf);
4375
4376 out_info[j].seek = ftell (fp);
4377
4378 //hc_thread_mutex_unlock (mux_display);
4379
4380 fclose (fp);
4381 }
4382 }
4383 }
4384 }
4385
4386 check_left = outfile_check_timer;
4387 }
4388 }
4389
4390 if (esalt_size) local_free (hash_buf.esalt);
4391
4392 if (isSalted) local_free (hash_buf.salt);
4393
4394 local_free (hash_buf.digest);
4395
4396 local_free (out_info);
4397
4398 local_free (out_files);
4399
4400 p = NULL;
4401
4402 return (p);
4403 }
4404
4405 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4406 {
4407 //if (device_param->pws_cnt < device_param->kernel_power)
4408 //{
4409 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4410
4411 u8 *ptr = (u8 *) pw->i;
4412
4413 memcpy (ptr, pw_buf, pw_len);
4414
4415 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4416
4417 pw->pw_len = pw_len;
4418
4419 device_param->pws_cnt++;
4420 //}
4421 //else
4422 //{
4423 // fprintf (stderr, "BUG pw_add()!!\n");
4424 //
4425 // return;
4426 //}
4427 }
4428
4429 static void set_kernel_power_final (const u64 kernel_power_final)
4430 {
4431 if (data.quiet == 0)
4432 {
4433 clear_prompt ();
4434
4435 //log_info ("");
4436
4437 log_info ("INFO: approaching final keyspace, workload adjusted");
4438 log_info ("");
4439
4440 fprintf (stdout, "%s", PROMPT);
4441
4442 fflush (stdout);
4443 }
4444
4445 data.kernel_power_final = kernel_power_final;
4446 }
4447
4448 static u32 get_power (hc_device_param_t *device_param)
4449 {
4450 const u64 kernel_power_final = data.kernel_power_final;
4451
4452 if (kernel_power_final)
4453 {
4454 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4455
4456 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4457
4458 // work should be at least the hardware power available without any accelerator
4459
4460 const u64 work = MAX (words_left_device, device_param->hardware_power);
4461
4462 return work;
4463 }
4464
4465 return device_param->kernel_power;
4466 }
4467
4468 static uint get_work (hc_device_param_t *device_param, const u64 max)
4469 {
4470 hc_thread_mutex_lock (mux_dispatcher);
4471
4472 const u64 words_cur = data.words_cur;
4473 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4474
4475 device_param->words_off = words_cur;
4476
4477 const u64 kernel_power_all = data.kernel_power_all;
4478
4479 const u64 words_left = words_base - words_cur;
4480
4481 if (words_left < kernel_power_all)
4482 {
4483 if (data.kernel_power_final == 0)
4484 {
4485 set_kernel_power_final (words_left);
4486 }
4487 }
4488
4489 const u32 kernel_power = get_power (device_param);
4490
4491 uint work = MIN (words_left, kernel_power);
4492
4493 work = MIN (work, max);
4494
4495 data.words_cur += work;
4496
4497 hc_thread_mutex_unlock (mux_dispatcher);
4498
4499 return work;
4500 }
4501
4502 static void *thread_autotune (void *p)
4503 {
4504 hc_device_param_t *device_param = (hc_device_param_t *) p;
4505
4506 if (device_param->skipped) return NULL;
4507
4508 autotune (device_param);
4509
4510 return NULL;
4511 }
4512
4513 static void *thread_calc_stdin (void *p)
4514 {
4515 hc_device_param_t *device_param = (hc_device_param_t *) p;
4516
4517 if (device_param->skipped) return NULL;
4518
4519 char *buf = (char *) mymalloc (HCBUFSIZ);
4520
4521 const uint attack_kern = data.attack_kern;
4522
4523 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4524 {
4525 hc_thread_mutex_lock (mux_dispatcher);
4526
4527 if (feof (stdin) != 0)
4528 {
4529 hc_thread_mutex_unlock (mux_dispatcher);
4530
4531 break;
4532 }
4533
4534 uint words_cur = 0;
4535
4536 while (words_cur < device_param->kernel_power)
4537 {
4538 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4539
4540 if (line_buf == NULL) break;
4541
4542 uint line_len = in_superchop (line_buf);
4543
4544 line_len = convert_from_hex (line_buf, line_len);
4545
4546 // post-process rule engine
4547
4548 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4549 {
4550 char rule_buf_out[BLOCK_SIZE] = { 0 };
4551
4552 int rule_len_out = -1;
4553
4554 if (line_len < BLOCK_SIZE)
4555 {
4556 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4557 }
4558
4559 if (rule_len_out < 0) continue;
4560
4561 line_buf = rule_buf_out;
4562 line_len = rule_len_out;
4563 }
4564
4565 if (line_len > PW_MAX)
4566 {
4567 continue;
4568 }
4569
4570 // hmm that's always the case, or?
4571
4572 if (attack_kern == ATTACK_KERN_STRAIGHT)
4573 {
4574 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4575 {
4576 hc_thread_mutex_lock (mux_counter);
4577
4578 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4579 {
4580 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4581 }
4582
4583 hc_thread_mutex_unlock (mux_counter);
4584
4585 continue;
4586 }
4587 }
4588
4589 pw_add (device_param, (u8 *) line_buf, line_len);
4590
4591 words_cur++;
4592
4593 if (data.devices_status == STATUS_CRACKED) break;
4594 if (data.devices_status == STATUS_ABORTED) break;
4595 if (data.devices_status == STATUS_QUIT) break;
4596 if (data.devices_status == STATUS_BYPASS) break;
4597 }
4598
4599 hc_thread_mutex_unlock (mux_dispatcher);
4600
4601 if (data.devices_status == STATUS_CRACKED) break;
4602 if (data.devices_status == STATUS_ABORTED) break;
4603 if (data.devices_status == STATUS_QUIT) break;
4604 if (data.devices_status == STATUS_BYPASS) break;
4605
4606 // flush
4607
4608 const uint pws_cnt = device_param->pws_cnt;
4609
4610 if (pws_cnt)
4611 {
4612 run_copy (device_param, pws_cnt);
4613
4614 run_cracker (device_param, pws_cnt);
4615
4616 device_param->pws_cnt = 0;
4617
4618 /*
4619 still required?
4620 if (attack_kern == ATTACK_KERN_STRAIGHT)
4621 {
4622 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4623 }
4624 else if (attack_kern == ATTACK_KERN_COMBI)
4625 {
4626 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4627 }
4628 */
4629 }
4630 }
4631
4632 device_param->kernel_accel = 0;
4633 device_param->kernel_loops = 0;
4634
4635 myfree (buf);
4636
4637 return NULL;
4638 }
4639
4640 static void *thread_calc (void *p)
4641 {
4642 hc_device_param_t *device_param = (hc_device_param_t *) p;
4643
4644 if (device_param->skipped) return NULL;
4645
4646 const uint attack_mode = data.attack_mode;
4647 const uint attack_kern = data.attack_kern;
4648
4649 if (attack_mode == ATTACK_MODE_BF)
4650 {
4651 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4652 {
4653 const uint work = get_work (device_param, -1);
4654
4655 if (work == 0) break;
4656
4657 const u64 words_off = device_param->words_off;
4658 const u64 words_fin = words_off + work;
4659
4660 const uint pws_cnt = work;
4661
4662 device_param->pws_cnt = pws_cnt;
4663
4664 if (pws_cnt)
4665 {
4666 run_copy (device_param, pws_cnt);
4667
4668 run_cracker (device_param, pws_cnt);
4669
4670 device_param->pws_cnt = 0;
4671
4672 /*
4673 still required?
4674 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4675 */
4676 }
4677
4678 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4679
4680 if (data.devices_status == STATUS_CRACKED) break;
4681 if (data.devices_status == STATUS_ABORTED) break;
4682 if (data.devices_status == STATUS_QUIT) break;
4683 if (data.devices_status == STATUS_BYPASS) break;
4684
4685 if (data.benchmark == 1) break;
4686
4687 device_param->words_done = words_fin;
4688 }
4689 }
4690 else
4691 {
4692 const uint segment_size = data.segment_size;
4693
4694 char *dictfile = data.dictfile;
4695
4696 if (attack_mode == ATTACK_MODE_COMBI)
4697 {
4698 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4699 {
4700 dictfile = data.dictfile2;
4701 }
4702 }
4703
4704 FILE *fd = fopen (dictfile, "rb");
4705
4706 if (fd == NULL)
4707 {
4708 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4709
4710 return NULL;
4711 }
4712
4713 if (attack_mode == ATTACK_MODE_COMBI)
4714 {
4715 const uint combs_mode = data.combs_mode;
4716
4717 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4718 {
4719 const char *dictfilec = data.dictfile2;
4720
4721 FILE *combs_fp = fopen (dictfilec, "rb");
4722
4723 if (combs_fp == NULL)
4724 {
4725 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4726
4727 fclose (fd);
4728
4729 return NULL;
4730 }
4731
4732 device_param->combs_fp = combs_fp;
4733 }
4734 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4735 {
4736 const char *dictfilec = data.dictfile;
4737
4738 FILE *combs_fp = fopen (dictfilec, "rb");
4739
4740 if (combs_fp == NULL)
4741 {
4742 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4743
4744 fclose (fd);
4745
4746 return NULL;
4747 }
4748
4749 device_param->combs_fp = combs_fp;
4750 }
4751 }
4752
4753 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4754
4755 wl_data->buf = (char *) mymalloc (segment_size);
4756 wl_data->avail = segment_size;
4757 wl_data->incr = segment_size;
4758 wl_data->cnt = 0;
4759 wl_data->pos = 0;
4760
4761 u64 words_cur = 0;
4762
4763 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4764 {
4765 u64 words_off = 0;
4766 u64 words_fin = 0;
4767
4768 u64 max = -1;
4769
4770 while (max)
4771 {
4772 const uint work = get_work (device_param, max);
4773
4774 if (work == 0) break;
4775
4776 max = 0;
4777
4778 words_off = device_param->words_off;
4779 words_fin = words_off + work;
4780
4781 char *line_buf;
4782 uint line_len;
4783
4784 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4785
4786 for ( ; words_cur < words_fin; words_cur++)
4787 {
4788 get_next_word (wl_data, fd, &line_buf, &line_len);
4789
4790 line_len = convert_from_hex (line_buf, line_len);
4791
4792 // post-process rule engine
4793
4794 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4795 {
4796 char rule_buf_out[BLOCK_SIZE] = { 0 };
4797
4798 int rule_len_out = -1;
4799
4800 if (line_len < BLOCK_SIZE)
4801 {
4802 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4803 }
4804
4805 if (rule_len_out < 0) continue;
4806
4807 line_buf = rule_buf_out;
4808 line_len = rule_len_out;
4809 }
4810
4811 if (attack_kern == ATTACK_KERN_STRAIGHT)
4812 {
4813 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4814 {
4815 max++;
4816
4817 hc_thread_mutex_lock (mux_counter);
4818
4819 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4820 {
4821 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4822 }
4823
4824 hc_thread_mutex_unlock (mux_counter);
4825
4826 continue;
4827 }
4828 }
4829 else if (attack_kern == ATTACK_KERN_COMBI)
4830 {
4831 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4832 // since we still need to combine the plains
4833
4834 if (line_len > data.pw_max)
4835 {
4836 max++;
4837
4838 hc_thread_mutex_lock (mux_counter);
4839
4840 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4841 {
4842 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4843 }
4844
4845 hc_thread_mutex_unlock (mux_counter);
4846
4847 continue;
4848 }
4849 }
4850
4851 pw_add (device_param, (u8 *) line_buf, line_len);
4852
4853 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4854
4855 if (data.devices_status == STATUS_CRACKED) break;
4856 if (data.devices_status == STATUS_ABORTED) break;
4857 if (data.devices_status == STATUS_QUIT) break;
4858 if (data.devices_status == STATUS_BYPASS) break;
4859 }
4860
4861 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4862
4863 if (data.devices_status == STATUS_CRACKED) break;
4864 if (data.devices_status == STATUS_ABORTED) break;
4865 if (data.devices_status == STATUS_QUIT) break;
4866 if (data.devices_status == STATUS_BYPASS) break;
4867 }
4868
4869 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4870
4871 if (data.devices_status == STATUS_CRACKED) break;
4872 if (data.devices_status == STATUS_ABORTED) break;
4873 if (data.devices_status == STATUS_QUIT) break;
4874 if (data.devices_status == STATUS_BYPASS) break;
4875
4876 //
4877 // flush
4878 //
4879
4880 const uint pws_cnt = device_param->pws_cnt;
4881
4882 if (pws_cnt)
4883 {
4884 run_copy (device_param, pws_cnt);
4885
4886 run_cracker (device_param, pws_cnt);
4887
4888 device_param->pws_cnt = 0;
4889
4890 /*
4891 still required?
4892 if (attack_kern == ATTACK_KERN_STRAIGHT)
4893 {
4894 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4895 }
4896 else if (attack_kern == ATTACK_KERN_COMBI)
4897 {
4898 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4899 }
4900 */
4901 }
4902
4903 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4904
4905 if (data.devices_status == STATUS_CRACKED) break;
4906 if (data.devices_status == STATUS_ABORTED) break;
4907 if (data.devices_status == STATUS_QUIT) break;
4908 if (data.devices_status == STATUS_BYPASS) break;
4909
4910 if (words_fin == 0) break;
4911
4912 device_param->words_done = words_fin;
4913 }
4914
4915 if (attack_mode == ATTACK_MODE_COMBI)
4916 {
4917 fclose (device_param->combs_fp);
4918 }
4919
4920 free (wl_data->buf);
4921 free (wl_data);
4922
4923 fclose (fd);
4924 }
4925
4926 device_param->kernel_accel = 0;
4927 device_param->kernel_loops = 0;
4928
4929 return NULL;
4930 }
4931
4932 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4933 {
4934 if (!device_param)
4935 {
4936 log_error ("ERROR: %s : Invalid argument", __func__);
4937
4938 exit (-1);
4939 }
4940
4941 salt_t *salt_buf = &data.salts_buf[salt_pos];
4942
4943 device_param->kernel_params_buf32[24] = salt_pos;
4944 device_param->kernel_params_buf32[27] = 1;
4945 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4946 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4947 device_param->kernel_params_buf32[30] = 0;
4948 device_param->kernel_params_buf32[31] = 1;
4949
4950 char *dictfile_old = data.dictfile;
4951
4952 const char *weak_hash_check = "weak-hash-check";
4953
4954 data.dictfile = (char *) weak_hash_check;
4955
4956 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4957
4958 data.kernel_rules_buf[0].cmds[0] = 0;
4959
4960 /**
4961 * run the kernel
4962 */
4963
4964 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4965 {
4966 run_kernel (KERN_RUN_1, device_param, 1, false);
4967 }
4968 else
4969 {
4970 run_kernel (KERN_RUN_1, device_param, 1, false);
4971
4972 uint loop_step = 16;
4973
4974 const uint iter = salt_buf->salt_iter;
4975
4976 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4977 {
4978 uint loop_left = iter - loop_pos;
4979
4980 loop_left = MIN (loop_left, loop_step);
4981
4982 device_param->kernel_params_buf32[25] = loop_pos;
4983 device_param->kernel_params_buf32[26] = loop_left;
4984
4985 run_kernel (KERN_RUN_2, device_param, 1, false);
4986 }
4987
4988 run_kernel (KERN_RUN_3, device_param, 1, false);
4989 }
4990
4991 /**
4992 * result
4993 */
4994
4995 check_cracked (device_param, salt_pos);
4996
4997 /**
4998 * cleanup
4999 */
5000
5001 device_param->kernel_params_buf32[24] = 0;
5002 device_param->kernel_params_buf32[25] = 0;
5003 device_param->kernel_params_buf32[26] = 0;
5004 device_param->kernel_params_buf32[27] = 0;
5005 device_param->kernel_params_buf32[28] = 0;
5006 device_param->kernel_params_buf32[29] = 0;
5007 device_param->kernel_params_buf32[30] = 0;
5008 device_param->kernel_params_buf32[31] = 0;
5009
5010 data.dictfile = dictfile_old;
5011
5012 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5013 }
5014
5015 // hlfmt hashcat
5016
5017 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5018 {
5019 if (data.username == 0)
5020 {
5021 *hashbuf_pos = line_buf;
5022 *hashbuf_len = line_len;
5023 }
5024 else
5025 {
5026 char *pos = line_buf;
5027 int len = line_len;
5028
5029 for (int i = 0; i < line_len; i++, pos++, len--)
5030 {
5031 if (line_buf[i] == data.separator)
5032 {
5033 pos++;
5034
5035 len--;
5036
5037 break;
5038 }
5039 }
5040
5041 *hashbuf_pos = pos;
5042 *hashbuf_len = len;
5043 }
5044 }
5045
5046 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5047 {
5048 char *pos = NULL;
5049 int len = 0;
5050
5051 int sep_cnt = 0;
5052
5053 for (int i = 0; i < line_len; i++)
5054 {
5055 if (line_buf[i] == data.separator)
5056 {
5057 sep_cnt++;
5058
5059 continue;
5060 }
5061
5062 if (sep_cnt == 0)
5063 {
5064 if (pos == NULL) pos = line_buf + i;
5065
5066 len++;
5067 }
5068 }
5069
5070 *userbuf_pos = pos;
5071 *userbuf_len = len;
5072 }
5073
5074 // hlfmt pwdump
5075
5076 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5077 {
5078 int sep_cnt = 0;
5079
5080 int sep2_len = 0;
5081 int sep3_len = 0;
5082
5083 for (int i = 0; i < line_len; i++)
5084 {
5085 if (line_buf[i] == ':')
5086 {
5087 sep_cnt++;
5088
5089 continue;
5090 }
5091
5092 if (sep_cnt == 2) sep2_len++;
5093 if (sep_cnt == 3) sep3_len++;
5094 }
5095
5096 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5097
5098 return 0;
5099 }
5100
5101 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5102 {
5103 char *pos = NULL;
5104 int len = 0;
5105
5106 int sep_cnt = 0;
5107
5108 for (int i = 0; i < line_len; i++)
5109 {
5110 if (line_buf[i] == ':')
5111 {
5112 sep_cnt++;
5113
5114 continue;
5115 }
5116
5117 if (data.hash_mode == 1000)
5118 {
5119 if (sep_cnt == 3)
5120 {
5121 if (pos == NULL) pos = line_buf + i;
5122
5123 len++;
5124 }
5125 }
5126 else if (data.hash_mode == 3000)
5127 {
5128 if (sep_cnt == 2)
5129 {
5130 if (pos == NULL) pos = line_buf + i;
5131
5132 len++;
5133 }
5134 }
5135 }
5136
5137 *hashbuf_pos = pos;
5138 *hashbuf_len = len;
5139 }
5140
5141 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5142 {
5143 char *pos = NULL;
5144 int len = 0;
5145
5146 int sep_cnt = 0;
5147
5148 for (int i = 0; i < line_len; i++)
5149 {
5150 if (line_buf[i] == ':')
5151 {
5152 sep_cnt++;
5153
5154 continue;
5155 }
5156
5157 if (sep_cnt == 0)
5158 {
5159 if (pos == NULL) pos = line_buf + i;
5160
5161 len++;
5162 }
5163 }
5164
5165 *userbuf_pos = pos;
5166 *userbuf_len = len;
5167 }
5168
5169 // hlfmt passwd
5170
5171 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5172 {
5173 int sep_cnt = 0;
5174
5175 char sep5_first = 0;
5176 char sep6_first = 0;
5177
5178 for (int i = 0; i < line_len; i++)
5179 {
5180 if (line_buf[i] == ':')
5181 {
5182 sep_cnt++;
5183
5184 continue;
5185 }
5186
5187 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5188 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5189 }
5190
5191 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5192
5193 return 0;
5194 }
5195
5196 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5197 {
5198 char *pos = NULL;
5199 int len = 0;
5200
5201 int sep_cnt = 0;
5202
5203 for (int i = 0; i < line_len; i++)
5204 {
5205 if (line_buf[i] == ':')
5206 {
5207 sep_cnt++;
5208
5209 continue;
5210 }
5211
5212 if (sep_cnt == 1)
5213 {
5214 if (pos == NULL) pos = line_buf + i;
5215
5216 len++;
5217 }
5218 }
5219
5220 *hashbuf_pos = pos;
5221 *hashbuf_len = len;
5222 }
5223
5224 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5225 {
5226 char *pos = NULL;
5227 int len = 0;
5228
5229 int sep_cnt = 0;
5230
5231 for (int i = 0; i < line_len; i++)
5232 {
5233 if (line_buf[i] == ':')
5234 {
5235 sep_cnt++;
5236
5237 continue;
5238 }
5239
5240 if (sep_cnt == 0)
5241 {
5242 if (pos == NULL) pos = line_buf + i;
5243
5244 len++;
5245 }
5246 }
5247
5248 *userbuf_pos = pos;
5249 *userbuf_len = len;
5250 }
5251
5252 // hlfmt shadow
5253
5254 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5255 {
5256 int sep_cnt = 0;
5257
5258 for (int i = 0; i < line_len; i++)
5259 {
5260 if (line_buf[i] == ':') sep_cnt++;
5261 }
5262
5263 if (sep_cnt == 8) return 1;
5264
5265 return 0;
5266 }
5267
5268 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5269 {
5270 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5271 }
5272
5273 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5274 {
5275 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5276 }
5277
5278 // hlfmt main
5279
5280 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5281 {
5282 switch (hashfile_format)
5283 {
5284 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5285 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5286 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5287 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5288 }
5289 }
5290
5291 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5292 {
5293 switch (hashfile_format)
5294 {
5295 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5296 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5297 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5298 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5299 }
5300 }
5301
5302 char *strhlfmt (const uint hashfile_format)
5303 {
5304 switch (hashfile_format)
5305 {
5306 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5307 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5308 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5309 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5310 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5311 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5312 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5313 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5314 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5315 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5316 }
5317
5318 return ((char *) "Unknown");
5319 }
5320
5321 static uint hlfmt_detect (FILE *fp, uint max_check)
5322 {
5323 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5324
5325 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5326 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5327
5328 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5329
5330 uint num_check = 0;
5331
5332 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5333
5334 while (!feof (fp))
5335 {
5336 int line_len = fgetl (fp, line_buf);
5337
5338 if (line_len == 0) continue;
5339
5340 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5341 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5342 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5343
5344 if (num_check == max_check) break;
5345
5346 num_check++;
5347 }
5348
5349 myfree (line_buf);
5350
5351 uint hashlist_format = HLFMT_HASHCAT;
5352
5353 for (int i = 1; i < HLFMTS_CNT; i++)
5354 {
5355 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5356
5357 hashlist_format = i;
5358 }
5359
5360 free (formats_cnt);
5361
5362 return hashlist_format;
5363 }
5364
5365 /**
5366 * some further helper function
5367 */
5368
5369 // wrapper around mymalloc for ADL
5370
5371 #if defined(HAVE_HWMON)
5372 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5373 {
5374 return mymalloc (iSize);
5375 }
5376 #endif
5377
5378 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const u64 collisions_max)
5379 {
5380 u64 collisions = 0;
5381
5382 const uint dgst_pos0 = data.dgst_pos0;
5383 const uint dgst_pos1 = data.dgst_pos1;
5384 const uint dgst_pos2 = data.dgst_pos2;
5385 const uint dgst_pos3 = data.dgst_pos3;
5386
5387 memset (bitmap_a, 0, bitmap_size);
5388 memset (bitmap_b, 0, bitmap_size);
5389 memset (bitmap_c, 0, bitmap_size);
5390 memset (bitmap_d, 0, bitmap_size);
5391
5392 for (uint i = 0; i < digests_cnt; i++)
5393 {
5394 uint *digest_ptr = (uint *) digests_buf_ptr;
5395
5396 digests_buf_ptr += dgst_size;
5397
5398 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5399 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5400 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5401 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5402
5403 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5404 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5405 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5406 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5407
5408 if (bitmap_a[idx0] & val0) collisions++;
5409 if (bitmap_b[idx1] & val1) collisions++;
5410 if (bitmap_c[idx2] & val2) collisions++;
5411 if (bitmap_d[idx3] & val3) collisions++;
5412
5413 bitmap_a[idx0] |= val0;
5414 bitmap_b[idx1] |= val1;
5415 bitmap_c[idx2] |= val2;
5416 bitmap_d[idx3] |= val3;
5417
5418 if (collisions >= collisions_max) return 0x7fffffff;
5419 }
5420
5421 return collisions;
5422 }
5423
5424 /**
5425 * main
5426 */
5427
5428 #ifdef _WIN
5429 void SetConsoleWindowSize (const int x)
5430 {
5431 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5432
5433 if (h == INVALID_HANDLE_VALUE) return;
5434
5435 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5436
5437 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5438
5439 SMALL_RECT *sr = &bufferInfo.srWindow;
5440
5441 sr->Right = MAX (sr->Right, x - 1);
5442
5443 COORD co;
5444
5445 co.X = sr->Right + 1;
5446 co.Y = 9999;
5447
5448 if (!SetConsoleScreenBufferSize (h, co)) return;
5449
5450 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5451 }
5452 #endif
5453
5454 #ifdef _POSIX
5455 int (*clock_gettime_orig) (clockid_t clk_id, struct timespec *tp);
5456
5457 int clock_gettime (clockid_t clk_id, struct timespec *tp)
5458 {
5459 int r = clock_gettime_orig (clk_id, tp);
5460
5461 usleep (NVIDIA_100PERCENTCPU_WORKAROUND);
5462
5463 return r;
5464 }
5465 #endif
5466
5467 int main (int argc, char **argv)
5468 {
5469 #ifdef _POSIX
5470 clock_gettime_orig = dlsym (RTLD_NEXT, "clock_gettime");
5471 #endif
5472
5473 #ifdef _WIN
5474 SetConsoleWindowSize (132);
5475 #endif
5476
5477 /**
5478 * To help users a bit
5479 */
5480
5481 char *compute = getenv ("COMPUTE");
5482
5483 if (compute)
5484 {
5485 static char display[100];
5486
5487 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5488
5489 putenv (display);
5490 }
5491 else
5492 {
5493 if (getenv ("DISPLAY") == NULL)
5494 putenv ((char *) "DISPLAY=:0");
5495 }
5496
5497 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5498 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5499
5500 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5501 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5502
5503 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5504 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5505
5506 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5507 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5508
5509 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5510 putenv ((char *) "POCL_KERNEL_CACHE=0");
5511
5512 umask (077);
5513
5514 /**
5515 * Real init
5516 */
5517
5518 memset (&data, 0, sizeof (hc_global_data_t));
5519
5520 time_t proc_start;
5521
5522 time (&proc_start);
5523
5524 data.proc_start = proc_start;
5525
5526 int myargc = argc;
5527 char **myargv = argv;
5528
5529 hc_thread_mutex_init (mux_dispatcher);
5530 hc_thread_mutex_init (mux_counter);
5531 hc_thread_mutex_init (mux_display);
5532 hc_thread_mutex_init (mux_adl);
5533
5534 /**
5535 * commandline parameters
5536 */
5537
5538 uint usage = USAGE;
5539 uint version = VERSION;
5540 uint quiet = QUIET;
5541 uint benchmark = BENCHMARK;
5542 uint show = SHOW;
5543 uint left = LEFT;
5544 uint username = USERNAME;
5545 uint remove = REMOVE;
5546 uint remove_timer = REMOVE_TIMER;
5547 u64 skip = SKIP;
5548 u64 limit = LIMIT;
5549 uint keyspace = KEYSPACE;
5550 uint potfile_disable = POTFILE_DISABLE;
5551 char *potfile_path = NULL;
5552 uint debug_mode = DEBUG_MODE;
5553 char *debug_file = NULL;
5554 char *induction_dir = NULL;
5555 char *outfile_check_dir = NULL;
5556 uint force = FORCE;
5557 uint runtime = RUNTIME;
5558 uint hash_mode = HASH_MODE;
5559 uint attack_mode = ATTACK_MODE;
5560 uint markov_disable = MARKOV_DISABLE;
5561 uint markov_classic = MARKOV_CLASSIC;
5562 uint markov_threshold = MARKOV_THRESHOLD;
5563 char *markov_hcstat = NULL;
5564 char *outfile = NULL;
5565 uint outfile_format = OUTFILE_FORMAT;
5566 uint outfile_autohex = OUTFILE_AUTOHEX;
5567 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5568 uint restore = RESTORE;
5569 uint restore_timer = RESTORE_TIMER;
5570 uint restore_disable = RESTORE_DISABLE;
5571 uint status = STATUS;
5572 uint status_timer = STATUS_TIMER;
5573 uint machine_readable = MACHINE_READABLE;
5574 uint loopback = LOOPBACK;
5575 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5576 char *session = NULL;
5577 uint hex_charset = HEX_CHARSET;
5578 uint hex_salt = HEX_SALT;
5579 uint hex_wordlist = HEX_WORDLIST;
5580 uint rp_gen = RP_GEN;
5581 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5582 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5583 uint rp_gen_seed = RP_GEN_SEED;
5584 char *rule_buf_l = (char *) RULE_BUF_L;
5585 char *rule_buf_r = (char *) RULE_BUF_R;
5586 uint increment = INCREMENT;
5587 uint increment_min = INCREMENT_MIN;
5588 uint increment_max = INCREMENT_MAX;
5589 char *cpu_affinity = NULL;
5590 OCL_PTR *ocl = NULL;
5591 char *opencl_devices = NULL;
5592 char *opencl_platforms = NULL;
5593 char *opencl_device_types = NULL;
5594 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5595 char *truecrypt_keyfiles = NULL;
5596 char *veracrypt_keyfiles = NULL;
5597 uint veracrypt_pim = 0;
5598 uint workload_profile = WORKLOAD_PROFILE;
5599 uint kernel_accel = KERNEL_ACCEL;
5600 uint kernel_loops = KERNEL_LOOPS;
5601 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5602 #ifdef HAVE_HWMON
5603 uint gpu_temp_abort = GPU_TEMP_ABORT;
5604 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5605 uint powertune_enable = POWERTUNE_ENABLE;
5606 #endif
5607 uint logfile_disable = LOGFILE_DISABLE;
5608 uint segment_size = SEGMENT_SIZE;
5609 uint scrypt_tmto = SCRYPT_TMTO;
5610 char separator = SEPARATOR;
5611 uint bitmap_min = BITMAP_MIN;
5612 uint bitmap_max = BITMAP_MAX;
5613 char *custom_charset_1 = NULL;
5614 char *custom_charset_2 = NULL;
5615 char *custom_charset_3 = NULL;
5616 char *custom_charset_4 = NULL;
5617
5618 #define IDX_HELP 'h'
5619 #define IDX_VERSION 'V'
5620 #define IDX_VERSION_LOWER 'v'
5621 #define IDX_QUIET 0xff02
5622 #define IDX_SHOW 0xff03
5623 #define IDX_LEFT 0xff04
5624 #define IDX_REMOVE 0xff05
5625 #define IDX_REMOVE_TIMER 0xff37
5626 #define IDX_SKIP 's'
5627 #define IDX_LIMIT 'l'
5628 #define IDX_KEYSPACE 0xff35
5629 #define IDX_POTFILE_DISABLE 0xff06
5630 #define IDX_POTFILE_PATH 0xffe0
5631 #define IDX_DEBUG_MODE 0xff43
5632 #define IDX_DEBUG_FILE 0xff44
5633 #define IDX_INDUCTION_DIR 0xff46
5634 #define IDX_OUTFILE_CHECK_DIR 0xff47
5635 #define IDX_USERNAME 0xff07
5636 #define IDX_FORCE 0xff08
5637 #define IDX_RUNTIME 0xff09
5638 #define IDX_BENCHMARK 'b'
5639 #define IDX_HASH_MODE 'm'
5640 #define IDX_ATTACK_MODE 'a'
5641 #define IDX_RP_FILE 'r'
5642 #define IDX_RP_GEN 'g'
5643 #define IDX_RP_GEN_FUNC_MIN 0xff10
5644 #define IDX_RP_GEN_FUNC_MAX 0xff11
5645 #define IDX_RP_GEN_SEED 0xff34
5646 #define IDX_RULE_BUF_L 'j'
5647 #define IDX_RULE_BUF_R 'k'
5648 #define IDX_INCREMENT 'i'
5649 #define IDX_INCREMENT_MIN 0xff12
5650 #define IDX_INCREMENT_MAX 0xff13
5651 #define IDX_OUTFILE 'o'
5652 #define IDX_OUTFILE_FORMAT 0xff14
5653 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5654 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5655 #define IDX_RESTORE 0xff15
5656 #define IDX_RESTORE_DISABLE 0xff27
5657 #define IDX_STATUS 0xff17
5658 #define IDX_STATUS_TIMER 0xff18
5659 #define IDX_MACHINE_READABLE 0xff50
5660 #define IDX_LOOPBACK 0xff38
5661 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5662 #define IDX_SESSION 0xff19
5663 #define IDX_HEX_CHARSET 0xff20
5664 #define IDX_HEX_SALT 0xff21
5665 #define IDX_HEX_WORDLIST 0xff40
5666 #define IDX_MARKOV_DISABLE 0xff22
5667 #define IDX_MARKOV_CLASSIC 0xff23
5668 #define IDX_MARKOV_THRESHOLD 't'
5669 #define IDX_MARKOV_HCSTAT 0xff24
5670 #define IDX_CPU_AFFINITY 0xff25
5671 #define IDX_OPENCL_DEVICES 'd'
5672 #define IDX_OPENCL_PLATFORMS 0xff72
5673 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5674 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5675 #define IDX_WORKLOAD_PROFILE 'w'
5676 #define IDX_KERNEL_ACCEL 'n'
5677 #define IDX_KERNEL_LOOPS 'u'
5678 #define IDX_GPU_TEMP_DISABLE 0xff29
5679 #define IDX_GPU_TEMP_ABORT 0xff30
5680 #define IDX_GPU_TEMP_RETAIN 0xff31
5681 #define IDX_POWERTUNE_ENABLE 0xff41
5682 #define IDX_LOGFILE_DISABLE 0xff51
5683 #define IDX_TRUECRYPT_KEYFILES 0xff52
5684 #define IDX_VERACRYPT_KEYFILES 0xff53
5685 #define IDX_VERACRYPT_PIM 0xff54
5686 #define IDX_SCRYPT_TMTO 0xff61
5687 #define IDX_SEGMENT_SIZE 'c'
5688 #define IDX_SEPARATOR 'p'
5689 #define IDX_BITMAP_MIN 0xff70
5690 #define IDX_BITMAP_MAX 0xff71
5691 #define IDX_CUSTOM_CHARSET_1 '1'
5692 #define IDX_CUSTOM_CHARSET_2 '2'
5693 #define IDX_CUSTOM_CHARSET_3 '3'
5694 #define IDX_CUSTOM_CHARSET_4 '4'
5695
5696 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5697
5698 struct option long_options[] =
5699 {
5700 {"help", no_argument, 0, IDX_HELP},
5701 {"version", no_argument, 0, IDX_VERSION},
5702 {"quiet", no_argument, 0, IDX_QUIET},
5703 {"show", no_argument, 0, IDX_SHOW},
5704 {"left", no_argument, 0, IDX_LEFT},
5705 {"username", no_argument, 0, IDX_USERNAME},
5706 {"remove", no_argument, 0, IDX_REMOVE},
5707 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5708 {"skip", required_argument, 0, IDX_SKIP},
5709 {"limit", required_argument, 0, IDX_LIMIT},
5710 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5711 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5712 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5713 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5714 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5715 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5716 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5717 {"force", no_argument, 0, IDX_FORCE},
5718 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5719 {"restore", no_argument, 0, IDX_RESTORE},
5720 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5721 {"status", no_argument, 0, IDX_STATUS},
5722 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5723 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5724 {"loopback", no_argument, 0, IDX_LOOPBACK},
5725 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5726 {"session", required_argument, 0, IDX_SESSION},
5727 {"runtime", required_argument, 0, IDX_RUNTIME},
5728 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5729 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5730 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5731 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5732 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5733 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5734 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5735 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5736 {"rules-file", required_argument, 0, IDX_RP_FILE},
5737 {"outfile", required_argument, 0, IDX_OUTFILE},
5738 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5739 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5740 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5741 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5742 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5743 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5744 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5745 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5746 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5747 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5748 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5749 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5750 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5751 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5752 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5753 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5754 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5755 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5756 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5757 #ifdef HAVE_HWMON
5758 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5759 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5760 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5761 #endif // HAVE_HWMON
5762 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5763 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5764 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5765 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5766 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5767 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5768 {"seperator", required_argument, 0, IDX_SEPARATOR},
5769 {"separator", required_argument, 0, IDX_SEPARATOR},
5770 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5771 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5772 {"increment", no_argument, 0, IDX_INCREMENT},
5773 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5774 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5775 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5776 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5777 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5778 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5779 {0, 0, 0, 0}
5780 };
5781
5782 uint rp_files_cnt = 0;
5783
5784 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5785
5786 int option_index = 0;
5787 int c = -1;
5788
5789 optind = 1;
5790 optopt = 0;
5791
5792 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5793 {
5794 switch (c)
5795 {
5796 case IDX_HELP: usage = 1; break;
5797 case IDX_VERSION:
5798 case IDX_VERSION_LOWER: version = 1; break;
5799 case IDX_RESTORE: restore = 1; break;
5800 case IDX_SESSION: session = optarg; break;
5801 case IDX_SHOW: show = 1; break;
5802 case IDX_LEFT: left = 1; break;
5803 case '?': return (-1);
5804 }
5805 }
5806
5807 if (optopt != 0)
5808 {
5809 log_error ("ERROR: Invalid argument specified");
5810
5811 return (-1);
5812 }
5813
5814 /**
5815 * exit functions
5816 */
5817
5818 if (version)
5819 {
5820 log_info ("%s", VERSION_TAG);
5821
5822 return (0);
5823 }
5824
5825 if (usage)
5826 {
5827 usage_big_print (PROGNAME);
5828
5829 return (0);
5830 }
5831
5832 /**
5833 * session needs to be set, always!
5834 */
5835
5836 if (session == NULL) session = (char *) PROGNAME;
5837
5838 /**
5839 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5840 */
5841
5842 char *exec_path = get_exec_path ();
5843
5844 #ifdef LINUX
5845
5846 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5847 char *resolved_exec_path = realpath (exec_path, NULL);
5848
5849 char *install_dir = get_install_dir (resolved_exec_path);
5850 char *profile_dir = NULL;
5851 char *session_dir = NULL;
5852 char *shared_dir = NULL;
5853
5854 if (strcmp (install_dir, resolved_install_folder) == 0)
5855 {
5856 struct passwd *pw = getpwuid (getuid ());
5857
5858 const char *homedir = pw->pw_dir;
5859
5860 profile_dir = get_profile_dir (homedir);
5861 session_dir = get_session_dir (profile_dir);
5862 shared_dir = strdup (SHARED_FOLDER);
5863
5864 mkdir (profile_dir, 0700);
5865 mkdir (session_dir, 0700);
5866 }
5867 else
5868 {
5869 profile_dir = install_dir;
5870 session_dir = install_dir;
5871 shared_dir = install_dir;
5872 }
5873
5874 myfree (resolved_install_folder);
5875 myfree (resolved_exec_path);
5876
5877 #else
5878
5879 char *install_dir = get_install_dir (exec_path);
5880 char *profile_dir = install_dir;
5881 char *session_dir = install_dir;
5882 char *shared_dir = install_dir;
5883
5884 #endif
5885
5886 data.install_dir = install_dir;
5887 data.profile_dir = profile_dir;
5888 data.session_dir = session_dir;
5889 data.shared_dir = shared_dir;
5890
5891 myfree (exec_path);
5892
5893 /**
5894 * kernel cache, we need to make sure folder exist
5895 */
5896
5897 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5898
5899 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5900
5901 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5902
5903 mkdir (kernels_folder, 0700);
5904
5905 myfree (kernels_folder);
5906
5907 /**
5908 * session
5909 */
5910
5911 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5912
5913 data.session = session;
5914
5915 char *eff_restore_file = (char *) mymalloc (session_size);
5916 char *new_restore_file = (char *) mymalloc (session_size);
5917
5918 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5919 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5920
5921 data.eff_restore_file = eff_restore_file;
5922 data.new_restore_file = new_restore_file;
5923
5924 if (((show == 1) || (left == 1)) && (restore == 1))
5925 {
5926 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5927 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5928
5929 return (-1);
5930 }
5931
5932 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5933 if ((show == 1) || (left == 1))
5934 {
5935 restore_disable = 1;
5936
5937 restore = 0;
5938 }
5939
5940 data.restore_disable = restore_disable;
5941
5942 restore_data_t *rd = init_restore (argc, argv);
5943
5944 data.rd = rd;
5945
5946 /**
5947 * restore file
5948 */
5949
5950 if (restore == 1)
5951 {
5952 read_restore (eff_restore_file, rd);
5953
5954 if (rd->version_bin < RESTORE_MIN)
5955 {
5956 log_error ("ERROR: Incompatible restore-file version");
5957
5958 return (-1);
5959 }
5960
5961 myargc = rd->argc;
5962 myargv = rd->argv;
5963
5964 #ifdef _POSIX
5965 rd->pid = getpid ();
5966 #elif _WIN
5967 rd->pid = GetCurrentProcessId ();
5968 #endif
5969 }
5970
5971 uint hash_mode_chgd = 0;
5972 uint runtime_chgd = 0;
5973 uint kernel_loops_chgd = 0;
5974 uint kernel_accel_chgd = 0;
5975 uint attack_mode_chgd = 0;
5976 uint outfile_format_chgd = 0;
5977 uint rp_gen_seed_chgd = 0;
5978 uint remove_timer_chgd = 0;
5979 uint increment_min_chgd = 0;
5980 uint increment_max_chgd = 0;
5981 uint workload_profile_chgd = 0;
5982 uint opencl_vector_width_chgd = 0;
5983
5984 optind = 1;
5985 optopt = 0;
5986 option_index = 0;
5987
5988 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5989 {
5990 switch (c)
5991 {
5992 //case IDX_HELP: usage = 1; break;
5993 //case IDX_VERSION: version = 1; break;
5994 //case IDX_RESTORE: restore = 1; break;
5995 case IDX_QUIET: quiet = 1; break;
5996 //case IDX_SHOW: show = 1; break;
5997 case IDX_SHOW: break;
5998 //case IDX_LEFT: left = 1; break;
5999 case IDX_LEFT: break;
6000 case IDX_USERNAME: username = 1; break;
6001 case IDX_REMOVE: remove = 1; break;
6002 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6003 remove_timer_chgd = 1; break;
6004 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6005 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6006 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6007 case IDX_DEBUG_FILE: debug_file = optarg; break;
6008 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6009 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6010 case IDX_FORCE: force = 1; break;
6011 case IDX_SKIP: skip = atoll (optarg); break;
6012 case IDX_LIMIT: limit = atoll (optarg); break;
6013 case IDX_KEYSPACE: keyspace = 1; break;
6014 case IDX_BENCHMARK: benchmark = 1; break;
6015 case IDX_RESTORE: break;
6016 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6017 case IDX_STATUS: status = 1; break;
6018 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6019 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6020 case IDX_LOOPBACK: loopback = 1; break;
6021 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6022 //case IDX_SESSION: session = optarg; break;
6023 case IDX_SESSION: break;
6024 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6025 hash_mode_chgd = 1; break;
6026 case IDX_RUNTIME: runtime = atoi (optarg);
6027 runtime_chgd = 1; break;
6028 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6029 attack_mode_chgd = 1; break;
6030 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6031 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6032 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6033 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6034 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6035 rp_gen_seed_chgd = 1; break;
6036 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6037 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6038 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6039 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6040 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6041 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6042 case IDX_OUTFILE: outfile = optarg; break;
6043 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6044 outfile_format_chgd = 1; break;
6045 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6046 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6047 case IDX_HEX_CHARSET: hex_charset = 1; break;
6048 case IDX_HEX_SALT: hex_salt = 1; break;
6049 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6050 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6051 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6052 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6053 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6054 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6055 opencl_vector_width_chgd = 1; break;
6056 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6057 workload_profile_chgd = 1; break;
6058 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6059 kernel_accel_chgd = 1; break;
6060 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6061 kernel_loops_chgd = 1; break;
6062 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6063 #ifdef HAVE_HWMON
6064 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6065 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6066 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6067 #endif // HAVE_HWMON
6068 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6069 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6070 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6071 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6072 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6073 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6074 case IDX_SEPARATOR: separator = optarg[0]; break;
6075 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6076 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6077 case IDX_INCREMENT: increment = 1; break;
6078 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6079 increment_min_chgd = 1; break;
6080 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6081 increment_max_chgd = 1; break;
6082 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6083 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6084 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6085 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6086
6087 default:
6088 log_error ("ERROR: Invalid argument specified");
6089 return (-1);
6090 }
6091 }
6092
6093 if (optopt != 0)
6094 {
6095 log_error ("ERROR: Invalid argument specified");
6096
6097 return (-1);
6098 }
6099
6100 /**
6101 * Inform user things getting started,
6102 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6103 * - we do not need to check algorithm_pos
6104 */
6105
6106 if (quiet == 0)
6107 {
6108 if (benchmark == 1)
6109 {
6110 if (machine_readable == 0)
6111 {
6112 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6113 log_info ("");
6114 log_info ("Note: Reported benchmark cracking speed = real cracking speed");
6115 log_info ("To verify, run hashcat like this: only_one_hash.txt -a 3 -w 3 ?b?b?b?b?b?b?b");
6116 log_info ("");
6117 }
6118 else
6119 {
6120 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6121 }
6122 }
6123 else if (restore == 1)
6124 {
6125 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6126 log_info ("");
6127 }
6128 else
6129 {
6130 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6131 log_info ("");
6132 }
6133 }
6134
6135 /**
6136 * sanity check
6137 */
6138
6139 if (attack_mode > 7)
6140 {
6141 log_error ("ERROR: Invalid attack-mode specified");
6142
6143 return (-1);
6144 }
6145
6146 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6147 {
6148 log_error ("ERROR: Invalid runtime specified");
6149
6150 return (-1);
6151 }
6152
6153 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6154 {
6155 log_error ("ERROR: Invalid hash-type specified");
6156
6157 return (-1);
6158 }
6159
6160 // renamed hash modes
6161
6162 if (hash_mode_chgd)
6163 {
6164 int n = -1;
6165
6166 switch (hash_mode)
6167 {
6168 case 123: n = 124;
6169 break;
6170 }
6171
6172 if (n >= 0)
6173 {
6174 log_error ("Old -m specified, use -m %d instead", n);
6175
6176 return (-1);
6177 }
6178 }
6179
6180 if (username == 1)
6181 {
6182 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6183 {
6184 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6185
6186 return (-1);
6187 }
6188 }
6189
6190 if (outfile_format > 16)
6191 {
6192 log_error ("ERROR: Invalid outfile-format specified");
6193
6194 return (-1);
6195 }
6196
6197 if (left == 1)
6198 {
6199 if (outfile_format_chgd == 1)
6200 {
6201 if (outfile_format > 1)
6202 {
6203 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6204
6205 return (-1);
6206 }
6207 }
6208 else
6209 {
6210 outfile_format = OUTFILE_FMT_HASH;
6211 }
6212 }
6213
6214 if (show == 1)
6215 {
6216 if (outfile_format_chgd == 1)
6217 {
6218 if ((outfile_format > 7) && (outfile_format < 16))
6219 {
6220 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6221
6222 return (-1);
6223 }
6224 }
6225 }
6226
6227 if (increment_min < INCREMENT_MIN)
6228 {
6229 log_error ("ERROR: Invalid increment-min specified");
6230
6231 return (-1);
6232 }
6233
6234 if (increment_max > INCREMENT_MAX)
6235 {
6236 log_error ("ERROR: Invalid increment-max specified");
6237
6238 return (-1);
6239 }
6240
6241 if (increment_min > increment_max)
6242 {
6243 log_error ("ERROR: Invalid increment-min specified");
6244
6245 return (-1);
6246 }
6247
6248 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6249 {
6250 log_error ("ERROR: increment is not allowed in attack-mode 0");
6251
6252 return (-1);
6253 }
6254
6255 if ((increment == 0) && (increment_min_chgd == 1))
6256 {
6257 log_error ("ERROR: increment-min is only supported together with increment switch");
6258
6259 return (-1);
6260 }
6261
6262 if ((increment == 0) && (increment_max_chgd == 1))
6263 {
6264 log_error ("ERROR: increment-max is only supported together with increment switch");
6265
6266 return (-1);
6267 }
6268
6269 if (rp_files_cnt && rp_gen)
6270 {
6271 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6272
6273 return (-1);
6274 }
6275
6276 if (rp_files_cnt || rp_gen)
6277 {
6278 if (attack_mode != ATTACK_MODE_STRAIGHT)
6279 {
6280 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6281
6282 return (-1);
6283 }
6284 }
6285
6286 if (rp_gen_func_min > rp_gen_func_max)
6287 {
6288 log_error ("ERROR: Invalid rp-gen-func-min specified");
6289
6290 return (-1);
6291 }
6292
6293 if (kernel_accel_chgd == 1)
6294 {
6295 if (force == 0)
6296 {
6297 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6298 log_info ("Please consider using the option -w instead");
6299 log_info ("You can use --force to override this but do not post error reports if you do so");
6300 log_info ("");
6301
6302 return (-1);
6303 }
6304
6305 if (kernel_accel < 1)
6306 {
6307 log_error ("ERROR: Invalid kernel-accel specified");
6308
6309 return (-1);
6310 }
6311
6312 if (kernel_accel > 1024)
6313 {
6314 log_error ("ERROR: Invalid kernel-accel specified");
6315
6316 return (-1);
6317 }
6318 }
6319
6320 if (kernel_loops_chgd == 1)
6321 {
6322 if (force == 0)
6323 {
6324 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6325 log_info ("Please consider using the option -w instead");
6326 log_info ("You can use --force to override this but do not post error reports if you do so");
6327 log_info ("");
6328
6329 return (-1);
6330 }
6331
6332 if (kernel_loops < 1)
6333 {
6334 log_error ("ERROR: Invalid kernel-loops specified");
6335
6336 return (-1);
6337 }
6338
6339 if (kernel_loops > 1024)
6340 {
6341 log_error ("ERROR: Invalid kernel-loops specified");
6342
6343 return (-1);
6344 }
6345 }
6346
6347 if ((workload_profile < 1) || (workload_profile > 4))
6348 {
6349 log_error ("ERROR: workload-profile %i not available", workload_profile);
6350
6351 return (-1);
6352 }
6353
6354 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6355 {
6356 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6357
6358 return (-1);
6359 }
6360
6361 if (show == 1 || left == 1)
6362 {
6363 attack_mode = ATTACK_MODE_NONE;
6364
6365 if (remove == 1)
6366 {
6367 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6368
6369 return (-1);
6370 }
6371
6372 if (potfile_disable == 1)
6373 {
6374 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6375
6376 return (-1);
6377 }
6378 }
6379
6380 uint attack_kern = ATTACK_KERN_NONE;
6381
6382 switch (attack_mode)
6383 {
6384 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6385 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6386 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6387 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6388 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6389 }
6390
6391 if (benchmark == 0)
6392 {
6393 if (keyspace == 1)
6394 {
6395 int num_additional_params = 1;
6396
6397 if (attack_kern == ATTACK_KERN_COMBI)
6398 {
6399 num_additional_params = 2;
6400 }
6401
6402 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6403
6404 if (keyspace_wordlist_specified == 0) optind--;
6405 }
6406
6407 if (attack_kern == ATTACK_KERN_NONE)
6408 {
6409 if ((optind + 1) != myargc)
6410 {
6411 usage_mini_print (myargv[0]);
6412
6413 return (-1);
6414 }
6415 }
6416 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6417 {
6418 if ((optind + 1) > myargc)
6419 {
6420 usage_mini_print (myargv[0]);
6421
6422 return (-1);
6423 }
6424 }
6425 else if (attack_kern == ATTACK_KERN_COMBI)
6426 {
6427 if ((optind + 3) != myargc)
6428 {
6429 usage_mini_print (myargv[0]);
6430
6431 return (-1);
6432 }
6433 }
6434 else if (attack_kern == ATTACK_KERN_BF)
6435 {
6436 if ((optind + 1) > myargc)
6437 {
6438 usage_mini_print (myargv[0]);
6439
6440 return (-1);
6441 }
6442 }
6443 else
6444 {
6445 usage_mini_print (myargv[0]);
6446
6447 return (-1);
6448 }
6449 }
6450 else
6451 {
6452 if (myargv[optind] != 0)
6453 {
6454 log_error ("ERROR: Invalid argument for benchmark mode specified");
6455
6456 return (-1);
6457 }
6458
6459 if (attack_mode_chgd == 1)
6460 {
6461 if (attack_mode != ATTACK_MODE_BF)
6462 {
6463 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6464
6465 return (-1);
6466 }
6467 }
6468 }
6469
6470 if (skip != 0 && limit != 0)
6471 {
6472 limit += skip;
6473 }
6474
6475 if (keyspace == 1)
6476 {
6477 if (show == 1)
6478 {
6479 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6480
6481 return (-1);
6482 }
6483 else if (left == 1)
6484 {
6485 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6486
6487 return (-1);
6488 }
6489
6490 potfile_disable = 1;
6491
6492 restore_disable = 1;
6493
6494 restore = 0;
6495
6496 weak_hash_threshold = 0;
6497
6498 quiet = 1;
6499 }
6500
6501 if (remove_timer_chgd == 1)
6502 {
6503 if (remove == 0)
6504 {
6505 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6506
6507 return (-1);
6508 }
6509
6510 if (remove_timer < 1)
6511 {
6512 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6513
6514 return (-1);
6515 }
6516 }
6517
6518 if (loopback == 1)
6519 {
6520 if (attack_mode == ATTACK_MODE_STRAIGHT)
6521 {
6522 if ((rp_files_cnt == 0) && (rp_gen == 0))
6523 {
6524 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6525
6526 return (-1);
6527 }
6528 }
6529 else
6530 {
6531 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6532
6533 return (-1);
6534 }
6535 }
6536
6537 if (debug_mode > 0)
6538 {
6539 if (attack_mode != ATTACK_MODE_STRAIGHT)
6540 {
6541 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6542
6543 return (-1);
6544 }
6545
6546 if ((rp_files_cnt == 0) && (rp_gen == 0))
6547 {
6548 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6549
6550 return (-1);
6551 }
6552 }
6553
6554 if (debug_mode > 4)
6555 {
6556 log_error ("ERROR: Invalid debug-mode specified");
6557
6558 return (-1);
6559 }
6560
6561 if (debug_file != NULL)
6562 {
6563 if (debug_mode < 1)
6564 {
6565 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6566
6567 return (-1);
6568 }
6569 }
6570
6571 if (induction_dir != NULL)
6572 {
6573 if (attack_mode == ATTACK_MODE_BF)
6574 {
6575 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6576
6577 return (-1);
6578 }
6579 }
6580
6581 if (attack_mode != ATTACK_MODE_STRAIGHT)
6582 {
6583 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6584 {
6585 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6586
6587 return (-1);
6588 }
6589
6590 weak_hash_threshold = 0;
6591 }
6592
6593 /**
6594 * induction directory
6595 */
6596
6597 char *induction_directory = NULL;
6598
6599 if (attack_mode != ATTACK_MODE_BF)
6600 {
6601 if (induction_dir == NULL)
6602 {
6603 induction_directory = (char *) mymalloc (session_size);
6604
6605 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6606
6607 // create induction folder if it does not already exist
6608
6609 if (keyspace == 0)
6610 {
6611 if (rmdir (induction_directory) == -1)
6612 {
6613 if (errno == ENOENT)
6614 {
6615 // good, we can ignore
6616 }
6617 else if (errno == ENOTEMPTY)
6618 {
6619 char *induction_directory_mv = (char *) mymalloc (session_size);
6620
6621 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6622
6623 if (rename (induction_directory, induction_directory_mv) != 0)
6624 {
6625 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6626
6627 return (-1);
6628 }
6629 }
6630 else
6631 {
6632 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6633
6634 return (-1);
6635 }
6636 }
6637
6638 if (mkdir (induction_directory, 0700) == -1)
6639 {
6640 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6641
6642 return (-1);
6643 }
6644 }
6645 }
6646 else
6647 {
6648 induction_directory = induction_dir;
6649 }
6650 }
6651
6652 data.induction_directory = induction_directory;
6653
6654 /**
6655 * loopback
6656 */
6657
6658 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6659
6660 char *loopback_file = (char *) mymalloc (loopback_size);
6661
6662 /**
6663 * tuning db
6664 */
6665
6666 char tuning_db_file[256] = { 0 };
6667
6668 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6669
6670 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6671
6672 /**
6673 * outfile-check directory
6674 */
6675
6676 char *outfile_check_directory = NULL;
6677
6678 if (outfile_check_dir == NULL)
6679 {
6680 outfile_check_directory = (char *) mymalloc (session_size);
6681
6682 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6683 }
6684 else
6685 {
6686 outfile_check_directory = outfile_check_dir;
6687 }
6688
6689 data.outfile_check_directory = outfile_check_directory;
6690
6691 if (keyspace == 0)
6692 {
6693 struct stat outfile_check_stat;
6694
6695 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6696 {
6697 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6698
6699 if (is_dir == 0)
6700 {
6701 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6702
6703 return (-1);
6704 }
6705 }
6706 else if (outfile_check_dir == NULL)
6707 {
6708 if (mkdir (outfile_check_directory, 0700) == -1)
6709 {
6710 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6711
6712 return (-1);
6713 }
6714 }
6715 }
6716
6717 /**
6718 * special other stuff
6719 */
6720
6721 if (hash_mode == 9710)
6722 {
6723 outfile_format = 5;
6724 outfile_format_chgd = 1;
6725 }
6726
6727 if (hash_mode == 9810)
6728 {
6729 outfile_format = 5;
6730 outfile_format_chgd = 1;
6731 }
6732
6733 if (hash_mode == 10410)
6734 {
6735 outfile_format = 5;
6736 outfile_format_chgd = 1;
6737 }
6738
6739 /**
6740 * store stuff
6741 */
6742
6743 data.hash_mode = hash_mode;
6744 data.restore = restore;
6745 data.restore_timer = restore_timer;
6746 data.restore_disable = restore_disable;
6747 data.status = status;
6748 data.status_timer = status_timer;
6749 data.machine_readable = machine_readable;
6750 data.loopback = loopback;
6751 data.runtime = runtime;
6752 data.remove = remove;
6753 data.remove_timer = remove_timer;
6754 data.debug_mode = debug_mode;
6755 data.debug_file = debug_file;
6756 data.username = username;
6757 data.quiet = quiet;
6758 data.outfile = outfile;
6759 data.outfile_format = outfile_format;
6760 data.outfile_autohex = outfile_autohex;
6761 data.hex_charset = hex_charset;
6762 data.hex_salt = hex_salt;
6763 data.hex_wordlist = hex_wordlist;
6764 data.separator = separator;
6765 data.rp_files = rp_files;
6766 data.rp_files_cnt = rp_files_cnt;
6767 data.rp_gen = rp_gen;
6768 data.rp_gen_seed = rp_gen_seed;
6769 data.force = force;
6770 data.benchmark = benchmark;
6771 data.skip = skip;
6772 data.limit = limit;
6773 #ifdef HAVE_HWMON
6774 data.powertune_enable = powertune_enable;
6775 #endif
6776 data.logfile_disable = logfile_disable;
6777 data.truecrypt_keyfiles = truecrypt_keyfiles;
6778 data.veracrypt_keyfiles = veracrypt_keyfiles;
6779 data.veracrypt_pim = veracrypt_pim;
6780 data.scrypt_tmto = scrypt_tmto;
6781 data.workload_profile = workload_profile;
6782
6783 /**
6784 * cpu affinity
6785 */
6786
6787 if (cpu_affinity)
6788 {
6789 set_cpu_affinity (cpu_affinity);
6790 }
6791
6792 if (rp_gen_seed_chgd == 0)
6793 {
6794 srand (proc_start);
6795 }
6796 else
6797 {
6798 srand (rp_gen_seed);
6799 }
6800
6801 /**
6802 * logfile init
6803 */
6804
6805 if (logfile_disable == 0)
6806 {
6807 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6808
6809 char *logfile = (char *) mymalloc (logfile_size);
6810
6811 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6812
6813 data.logfile = logfile;
6814
6815 char *topid = logfile_generate_topid ();
6816
6817 data.topid = topid;
6818 }
6819
6820 // logfile_append() checks for logfile_disable internally to make it easier from here
6821
6822 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6823 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6824 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6825 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6826 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6827 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6828 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6829 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6830 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6831 #define logfile_sub_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s\t%s", data.topid, data.subid, (var), (val));
6832
6833 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6834 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6835 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6836 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6837 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6838 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6839 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6840 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6841
6842 logfile_top_msg ("START");
6843
6844 logfile_top_uint (attack_mode);
6845 logfile_top_uint (attack_kern);
6846 logfile_top_uint (benchmark);
6847 logfile_top_uint (bitmap_min);
6848 logfile_top_uint (bitmap_max);
6849 logfile_top_uint (debug_mode);
6850 logfile_top_uint (force);
6851 logfile_top_uint (kernel_accel);
6852 logfile_top_uint (kernel_loops);
6853 logfile_top_uint (gpu_temp_disable);
6854 #ifdef HAVE_HWMON
6855 logfile_top_uint (gpu_temp_abort);
6856 logfile_top_uint (gpu_temp_retain);
6857 #endif
6858 logfile_top_uint (hash_mode);
6859 logfile_top_uint (hex_charset);
6860 logfile_top_uint (hex_salt);
6861 logfile_top_uint (hex_wordlist);
6862 logfile_top_uint (increment);
6863 logfile_top_uint (increment_max);
6864 logfile_top_uint (increment_min);
6865 logfile_top_uint (keyspace);
6866 logfile_top_uint (left);
6867 logfile_top_uint (logfile_disable);
6868 logfile_top_uint (loopback);
6869 logfile_top_uint (markov_classic);
6870 logfile_top_uint (markov_disable);
6871 logfile_top_uint (markov_threshold);
6872 logfile_top_uint (outfile_autohex);
6873 logfile_top_uint (outfile_check_timer);
6874 logfile_top_uint (outfile_format);
6875 logfile_top_uint (potfile_disable);
6876 logfile_top_string (potfile_path);
6877 #if defined(HAVE_HWMON)
6878 logfile_top_uint (powertune_enable);
6879 #endif
6880 logfile_top_uint (scrypt_tmto);
6881 logfile_top_uint (quiet);
6882 logfile_top_uint (remove);
6883 logfile_top_uint (remove_timer);
6884 logfile_top_uint (restore);
6885 logfile_top_uint (restore_disable);
6886 logfile_top_uint (restore_timer);
6887 logfile_top_uint (rp_gen);
6888 logfile_top_uint (rp_gen_func_max);
6889 logfile_top_uint (rp_gen_func_min);
6890 logfile_top_uint (rp_gen_seed);
6891 logfile_top_uint (runtime);
6892 logfile_top_uint (segment_size);
6893 logfile_top_uint (show);
6894 logfile_top_uint (status);
6895 logfile_top_uint (machine_readable);
6896 logfile_top_uint (status_timer);
6897 logfile_top_uint (usage);
6898 logfile_top_uint (username);
6899 logfile_top_uint (version);
6900 logfile_top_uint (weak_hash_threshold);
6901 logfile_top_uint (workload_profile);
6902 logfile_top_uint64 (limit);
6903 logfile_top_uint64 (skip);
6904 logfile_top_char (separator);
6905 logfile_top_string (cpu_affinity);
6906 logfile_top_string (custom_charset_1);
6907 logfile_top_string (custom_charset_2);
6908 logfile_top_string (custom_charset_3);
6909 logfile_top_string (custom_charset_4);
6910 logfile_top_string (debug_file);
6911 logfile_top_string (opencl_devices);
6912 logfile_top_string (opencl_platforms);
6913 logfile_top_string (opencl_device_types);
6914 logfile_top_uint (opencl_vector_width);
6915 logfile_top_string (induction_dir);
6916 logfile_top_string (markov_hcstat);
6917 logfile_top_string (outfile);
6918 logfile_top_string (outfile_check_dir);
6919 logfile_top_string (rule_buf_l);
6920 logfile_top_string (rule_buf_r);
6921 logfile_top_string (session);
6922 logfile_top_string (truecrypt_keyfiles);
6923 logfile_top_string (veracrypt_keyfiles);
6924 logfile_top_uint (veracrypt_pim);
6925
6926 /**
6927 * Init OpenCL library loader
6928 */
6929
6930 if (keyspace == 0)
6931 {
6932 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6933
6934 ocl_init (ocl);
6935
6936 data.ocl = ocl;
6937 }
6938
6939 /**
6940 * OpenCL platform selection
6941 */
6942
6943 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6944
6945 /**
6946 * OpenCL device selection
6947 */
6948
6949 u32 devices_filter = setup_devices_filter (opencl_devices);
6950
6951 /**
6952 * OpenCL device type selection
6953 */
6954
6955 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6956
6957 /**
6958 * benchmark
6959 */
6960
6961 if (benchmark == 1)
6962 {
6963 /**
6964 * disable useless stuff for benchmark
6965 */
6966
6967 status_timer = 0;
6968 restore_timer = 0;
6969 restore_disable = 1;
6970 potfile_disable = 1;
6971 weak_hash_threshold = 0;
6972 gpu_temp_disable = 1;
6973
6974 #ifdef HAVE_HWMON
6975 gpu_temp_disable = 0;
6976 powertune_enable = 1;
6977 #endif
6978
6979 data.status_timer = status_timer;
6980 data.restore_timer = restore_timer;
6981 data.restore_disable = restore_disable;
6982
6983 /**
6984 * force attack mode to be bruteforce
6985 */
6986
6987 attack_mode = ATTACK_MODE_BF;
6988 attack_kern = ATTACK_KERN_BF;
6989
6990 if (workload_profile_chgd == 0)
6991 {
6992 workload_profile = 3;
6993
6994 data.workload_profile = workload_profile;
6995 }
6996 }
6997
6998 /**
6999 * config
7000 */
7001
7002 uint hash_type = 0;
7003 uint salt_type = 0;
7004 uint attack_exec = 0;
7005 uint opts_type = 0;
7006 uint kern_type = 0;
7007 uint dgst_size = 0;
7008 uint esalt_size = 0;
7009 uint opti_type = 0;
7010 uint dgst_pos0 = -1;
7011 uint dgst_pos1 = -1;
7012 uint dgst_pos2 = -1;
7013 uint dgst_pos3 = -1;
7014
7015 int (*parse_func) (char *, uint, hash_t *);
7016 int (*sort_by_digest) (const void *, const void *);
7017
7018 uint algorithm_pos = 0;
7019 uint algorithm_max = 1;
7020
7021 uint *algorithms = default_benchmark_algorithms;
7022
7023 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7024
7025 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7026 {
7027 /*
7028 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7029 * the following algos are skipped entirely
7030 */
7031
7032 if (algorithm_pos > 0)
7033 {
7034 local_free (rd);
7035
7036 rd = init_restore (argc, argv);
7037
7038 data.rd = rd;
7039 }
7040
7041 /**
7042 * update hash_mode in case of multihash benchmark
7043 */
7044
7045 if (benchmark == 1)
7046 {
7047 if (hash_mode_chgd == 0)
7048 {
7049 hash_mode = algorithms[algorithm_pos];
7050
7051 data.hash_mode = hash_mode;
7052 }
7053
7054 quiet = 1;
7055
7056 data.quiet = quiet;
7057 }
7058
7059 switch (hash_mode)
7060 {
7061 case 0: hash_type = HASH_TYPE_MD5;
7062 salt_type = SALT_TYPE_NONE;
7063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7064 opts_type = OPTS_TYPE_PT_GENERATE_LE
7065 | OPTS_TYPE_PT_ADD80
7066 | OPTS_TYPE_PT_ADDBITS14;
7067 kern_type = KERN_TYPE_MD5;
7068 dgst_size = DGST_SIZE_4_4;
7069 parse_func = md5_parse_hash;
7070 sort_by_digest = sort_by_digest_4_4;
7071 opti_type = OPTI_TYPE_ZERO_BYTE
7072 | OPTI_TYPE_PRECOMPUTE_INIT
7073 | OPTI_TYPE_PRECOMPUTE_MERKLE
7074 | OPTI_TYPE_MEET_IN_MIDDLE
7075 | OPTI_TYPE_EARLY_SKIP
7076 | OPTI_TYPE_NOT_ITERATED
7077 | OPTI_TYPE_NOT_SALTED
7078 | OPTI_TYPE_RAW_HASH;
7079 dgst_pos0 = 0;
7080 dgst_pos1 = 3;
7081 dgst_pos2 = 2;
7082 dgst_pos3 = 1;
7083 break;
7084
7085 case 10: hash_type = HASH_TYPE_MD5;
7086 salt_type = SALT_TYPE_INTERN;
7087 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7088 opts_type = OPTS_TYPE_PT_GENERATE_LE
7089 | OPTS_TYPE_ST_ADD80
7090 | OPTS_TYPE_ST_ADDBITS14;
7091 kern_type = KERN_TYPE_MD5_PWSLT;
7092 dgst_size = DGST_SIZE_4_4;
7093 parse_func = md5s_parse_hash;
7094 sort_by_digest = sort_by_digest_4_4;
7095 opti_type = OPTI_TYPE_ZERO_BYTE
7096 | OPTI_TYPE_PRECOMPUTE_INIT
7097 | OPTI_TYPE_PRECOMPUTE_MERKLE
7098 | OPTI_TYPE_MEET_IN_MIDDLE
7099 | OPTI_TYPE_EARLY_SKIP
7100 | OPTI_TYPE_NOT_ITERATED
7101 | OPTI_TYPE_APPENDED_SALT
7102 | OPTI_TYPE_RAW_HASH;
7103 dgst_pos0 = 0;
7104 dgst_pos1 = 3;
7105 dgst_pos2 = 2;
7106 dgst_pos3 = 1;
7107 break;
7108
7109 case 11: hash_type = HASH_TYPE_MD5;
7110 salt_type = SALT_TYPE_INTERN;
7111 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7112 opts_type = OPTS_TYPE_PT_GENERATE_LE
7113 | OPTS_TYPE_ST_ADD80
7114 | OPTS_TYPE_ST_ADDBITS14;
7115 kern_type = KERN_TYPE_MD5_PWSLT;
7116 dgst_size = DGST_SIZE_4_4;
7117 parse_func = joomla_parse_hash;
7118 sort_by_digest = sort_by_digest_4_4;
7119 opti_type = OPTI_TYPE_ZERO_BYTE
7120 | OPTI_TYPE_PRECOMPUTE_INIT
7121 | OPTI_TYPE_PRECOMPUTE_MERKLE
7122 | OPTI_TYPE_MEET_IN_MIDDLE
7123 | OPTI_TYPE_EARLY_SKIP
7124 | OPTI_TYPE_NOT_ITERATED
7125 | OPTI_TYPE_APPENDED_SALT
7126 | OPTI_TYPE_RAW_HASH;
7127 dgst_pos0 = 0;
7128 dgst_pos1 = 3;
7129 dgst_pos2 = 2;
7130 dgst_pos3 = 1;
7131 break;
7132
7133 case 12: hash_type = HASH_TYPE_MD5;
7134 salt_type = SALT_TYPE_INTERN;
7135 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7136 opts_type = OPTS_TYPE_PT_GENERATE_LE
7137 | OPTS_TYPE_ST_ADD80
7138 | OPTS_TYPE_ST_ADDBITS14;
7139 kern_type = KERN_TYPE_MD5_PWSLT;
7140 dgst_size = DGST_SIZE_4_4;
7141 parse_func = postgresql_parse_hash;
7142 sort_by_digest = sort_by_digest_4_4;
7143 opti_type = OPTI_TYPE_ZERO_BYTE
7144 | OPTI_TYPE_PRECOMPUTE_INIT
7145 | OPTI_TYPE_PRECOMPUTE_MERKLE
7146 | OPTI_TYPE_MEET_IN_MIDDLE
7147 | OPTI_TYPE_EARLY_SKIP
7148 | OPTI_TYPE_NOT_ITERATED
7149 | OPTI_TYPE_APPENDED_SALT
7150 | OPTI_TYPE_RAW_HASH;
7151 dgst_pos0 = 0;
7152 dgst_pos1 = 3;
7153 dgst_pos2 = 2;
7154 dgst_pos3 = 1;
7155 break;
7156
7157 case 20: hash_type = HASH_TYPE_MD5;
7158 salt_type = SALT_TYPE_INTERN;
7159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7160 opts_type = OPTS_TYPE_PT_GENERATE_LE
7161 | OPTS_TYPE_PT_ADD80
7162 | OPTS_TYPE_PT_ADDBITS14;
7163 kern_type = KERN_TYPE_MD5_SLTPW;
7164 dgst_size = DGST_SIZE_4_4;
7165 parse_func = md5s_parse_hash;
7166 sort_by_digest = sort_by_digest_4_4;
7167 opti_type = OPTI_TYPE_ZERO_BYTE
7168 | OPTI_TYPE_PRECOMPUTE_INIT
7169 | OPTI_TYPE_PRECOMPUTE_MERKLE
7170 | OPTI_TYPE_EARLY_SKIP
7171 | OPTI_TYPE_NOT_ITERATED
7172 | OPTI_TYPE_PREPENDED_SALT
7173 | OPTI_TYPE_RAW_HASH;
7174 dgst_pos0 = 0;
7175 dgst_pos1 = 3;
7176 dgst_pos2 = 2;
7177 dgst_pos3 = 1;
7178 break;
7179
7180 case 21: hash_type = HASH_TYPE_MD5;
7181 salt_type = SALT_TYPE_INTERN;
7182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7183 opts_type = OPTS_TYPE_PT_GENERATE_LE
7184 | OPTS_TYPE_PT_ADD80
7185 | OPTS_TYPE_PT_ADDBITS14;
7186 kern_type = KERN_TYPE_MD5_SLTPW;
7187 dgst_size = DGST_SIZE_4_4;
7188 parse_func = osc_parse_hash;
7189 sort_by_digest = sort_by_digest_4_4;
7190 opti_type = OPTI_TYPE_ZERO_BYTE
7191 | OPTI_TYPE_PRECOMPUTE_INIT
7192 | OPTI_TYPE_PRECOMPUTE_MERKLE
7193 | OPTI_TYPE_EARLY_SKIP
7194 | OPTI_TYPE_NOT_ITERATED
7195 | OPTI_TYPE_PREPENDED_SALT
7196 | OPTI_TYPE_RAW_HASH;
7197 dgst_pos0 = 0;
7198 dgst_pos1 = 3;
7199 dgst_pos2 = 2;
7200 dgst_pos3 = 1;
7201 break;
7202
7203 case 22: hash_type = HASH_TYPE_MD5;
7204 salt_type = SALT_TYPE_EMBEDDED;
7205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7206 opts_type = OPTS_TYPE_PT_GENERATE_LE
7207 | OPTS_TYPE_PT_ADD80
7208 | OPTS_TYPE_PT_ADDBITS14;
7209 kern_type = KERN_TYPE_MD5_SLTPW;
7210 dgst_size = DGST_SIZE_4_4;
7211 parse_func = netscreen_parse_hash;
7212 sort_by_digest = sort_by_digest_4_4;
7213 opti_type = OPTI_TYPE_ZERO_BYTE
7214 | OPTI_TYPE_PRECOMPUTE_INIT
7215 | OPTI_TYPE_PRECOMPUTE_MERKLE
7216 | OPTI_TYPE_EARLY_SKIP
7217 | OPTI_TYPE_NOT_ITERATED
7218 | OPTI_TYPE_PREPENDED_SALT
7219 | OPTI_TYPE_RAW_HASH;
7220 dgst_pos0 = 0;
7221 dgst_pos1 = 3;
7222 dgst_pos2 = 2;
7223 dgst_pos3 = 1;
7224 break;
7225
7226 case 23: hash_type = HASH_TYPE_MD5;
7227 salt_type = SALT_TYPE_EMBEDDED;
7228 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7229 opts_type = OPTS_TYPE_PT_GENERATE_LE
7230 | OPTS_TYPE_PT_ADD80
7231 | OPTS_TYPE_PT_ADDBITS14;
7232 kern_type = KERN_TYPE_MD5_SLTPW;
7233 dgst_size = DGST_SIZE_4_4;
7234 parse_func = skype_parse_hash;
7235 sort_by_digest = sort_by_digest_4_4;
7236 opti_type = OPTI_TYPE_ZERO_BYTE
7237 | OPTI_TYPE_PRECOMPUTE_INIT
7238 | OPTI_TYPE_PRECOMPUTE_MERKLE
7239 | OPTI_TYPE_EARLY_SKIP
7240 | OPTI_TYPE_NOT_ITERATED
7241 | OPTI_TYPE_PREPENDED_SALT
7242 | OPTI_TYPE_RAW_HASH;
7243 dgst_pos0 = 0;
7244 dgst_pos1 = 3;
7245 dgst_pos2 = 2;
7246 dgst_pos3 = 1;
7247 break;
7248
7249 case 30: hash_type = HASH_TYPE_MD5;
7250 salt_type = SALT_TYPE_INTERN;
7251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7252 opts_type = OPTS_TYPE_PT_GENERATE_LE
7253 | OPTS_TYPE_PT_UNICODE
7254 | OPTS_TYPE_ST_ADD80
7255 | OPTS_TYPE_ST_ADDBITS14;
7256 kern_type = KERN_TYPE_MD5_PWUSLT;
7257 dgst_size = DGST_SIZE_4_4;
7258 parse_func = md5s_parse_hash;
7259 sort_by_digest = sort_by_digest_4_4;
7260 opti_type = OPTI_TYPE_ZERO_BYTE
7261 | OPTI_TYPE_PRECOMPUTE_INIT
7262 | OPTI_TYPE_PRECOMPUTE_MERKLE
7263 | OPTI_TYPE_MEET_IN_MIDDLE
7264 | OPTI_TYPE_EARLY_SKIP
7265 | OPTI_TYPE_NOT_ITERATED
7266 | OPTI_TYPE_APPENDED_SALT
7267 | OPTI_TYPE_RAW_HASH;
7268 dgst_pos0 = 0;
7269 dgst_pos1 = 3;
7270 dgst_pos2 = 2;
7271 dgst_pos3 = 1;
7272 break;
7273
7274 case 40: hash_type = HASH_TYPE_MD5;
7275 salt_type = SALT_TYPE_INTERN;
7276 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7277 opts_type = OPTS_TYPE_PT_GENERATE_LE
7278 | OPTS_TYPE_PT_ADD80
7279 | OPTS_TYPE_PT_ADDBITS14
7280 | OPTS_TYPE_PT_UNICODE;
7281 kern_type = KERN_TYPE_MD5_SLTPWU;
7282 dgst_size = DGST_SIZE_4_4;
7283 parse_func = md5s_parse_hash;
7284 sort_by_digest = sort_by_digest_4_4;
7285 opti_type = OPTI_TYPE_ZERO_BYTE
7286 | OPTI_TYPE_PRECOMPUTE_INIT
7287 | OPTI_TYPE_PRECOMPUTE_MERKLE
7288 | OPTI_TYPE_EARLY_SKIP
7289 | OPTI_TYPE_NOT_ITERATED
7290 | OPTI_TYPE_PREPENDED_SALT
7291 | OPTI_TYPE_RAW_HASH;
7292 dgst_pos0 = 0;
7293 dgst_pos1 = 3;
7294 dgst_pos2 = 2;
7295 dgst_pos3 = 1;
7296 break;
7297
7298 case 50: hash_type = HASH_TYPE_MD5;
7299 salt_type = SALT_TYPE_INTERN;
7300 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7301 opts_type = OPTS_TYPE_PT_GENERATE_LE
7302 | OPTS_TYPE_ST_ADD80
7303 | OPTS_TYPE_ST_ADDBITS14;
7304 kern_type = KERN_TYPE_HMACMD5_PW;
7305 dgst_size = DGST_SIZE_4_4;
7306 parse_func = hmacmd5_parse_hash;
7307 sort_by_digest = sort_by_digest_4_4;
7308 opti_type = OPTI_TYPE_ZERO_BYTE
7309 | OPTI_TYPE_NOT_ITERATED;
7310 dgst_pos0 = 0;
7311 dgst_pos1 = 3;
7312 dgst_pos2 = 2;
7313 dgst_pos3 = 1;
7314 break;
7315
7316 case 60: hash_type = HASH_TYPE_MD5;
7317 salt_type = SALT_TYPE_INTERN;
7318 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7319 opts_type = OPTS_TYPE_PT_GENERATE_LE
7320 | OPTS_TYPE_PT_ADD80
7321 | OPTS_TYPE_PT_ADDBITS14;
7322 kern_type = KERN_TYPE_HMACMD5_SLT;
7323 dgst_size = DGST_SIZE_4_4;
7324 parse_func = hmacmd5_parse_hash;
7325 sort_by_digest = sort_by_digest_4_4;
7326 opti_type = OPTI_TYPE_ZERO_BYTE
7327 | OPTI_TYPE_NOT_ITERATED;
7328 dgst_pos0 = 0;
7329 dgst_pos1 = 3;
7330 dgst_pos2 = 2;
7331 dgst_pos3 = 1;
7332 break;
7333
7334 case 100: hash_type = HASH_TYPE_SHA1;
7335 salt_type = SALT_TYPE_NONE;
7336 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7337 opts_type = OPTS_TYPE_PT_GENERATE_BE
7338 | OPTS_TYPE_PT_ADD80
7339 | OPTS_TYPE_PT_ADDBITS15;
7340 kern_type = KERN_TYPE_SHA1;
7341 dgst_size = DGST_SIZE_4_5;
7342 parse_func = sha1_parse_hash;
7343 sort_by_digest = sort_by_digest_4_5;
7344 opti_type = OPTI_TYPE_ZERO_BYTE
7345 | OPTI_TYPE_PRECOMPUTE_INIT
7346 | OPTI_TYPE_PRECOMPUTE_MERKLE
7347 | OPTI_TYPE_EARLY_SKIP
7348 | OPTI_TYPE_NOT_ITERATED
7349 | OPTI_TYPE_NOT_SALTED
7350 | OPTI_TYPE_RAW_HASH;
7351 dgst_pos0 = 3;
7352 dgst_pos1 = 4;
7353 dgst_pos2 = 2;
7354 dgst_pos3 = 1;
7355 break;
7356
7357 case 101: hash_type = HASH_TYPE_SHA1;
7358 salt_type = SALT_TYPE_NONE;
7359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7360 opts_type = OPTS_TYPE_PT_GENERATE_BE
7361 | OPTS_TYPE_PT_ADD80
7362 | OPTS_TYPE_PT_ADDBITS15;
7363 kern_type = KERN_TYPE_SHA1;
7364 dgst_size = DGST_SIZE_4_5;
7365 parse_func = sha1b64_parse_hash;
7366 sort_by_digest = sort_by_digest_4_5;
7367 opti_type = OPTI_TYPE_ZERO_BYTE
7368 | OPTI_TYPE_PRECOMPUTE_INIT
7369 | OPTI_TYPE_PRECOMPUTE_MERKLE
7370 | OPTI_TYPE_EARLY_SKIP
7371 | OPTI_TYPE_NOT_ITERATED
7372 | OPTI_TYPE_NOT_SALTED
7373 | OPTI_TYPE_RAW_HASH;
7374 dgst_pos0 = 3;
7375 dgst_pos1 = 4;
7376 dgst_pos2 = 2;
7377 dgst_pos3 = 1;
7378 break;
7379
7380 case 110: hash_type = HASH_TYPE_SHA1;
7381 salt_type = SALT_TYPE_INTERN;
7382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7383 opts_type = OPTS_TYPE_PT_GENERATE_BE
7384 | OPTS_TYPE_ST_ADD80
7385 | OPTS_TYPE_ST_ADDBITS15;
7386 kern_type = KERN_TYPE_SHA1_PWSLT;
7387 dgst_size = DGST_SIZE_4_5;
7388 parse_func = sha1s_parse_hash;
7389 sort_by_digest = sort_by_digest_4_5;
7390 opti_type = OPTI_TYPE_ZERO_BYTE
7391 | OPTI_TYPE_PRECOMPUTE_INIT
7392 | OPTI_TYPE_PRECOMPUTE_MERKLE
7393 | OPTI_TYPE_EARLY_SKIP
7394 | OPTI_TYPE_NOT_ITERATED
7395 | OPTI_TYPE_APPENDED_SALT
7396 | OPTI_TYPE_RAW_HASH;
7397 dgst_pos0 = 3;
7398 dgst_pos1 = 4;
7399 dgst_pos2 = 2;
7400 dgst_pos3 = 1;
7401 break;
7402
7403 case 111: hash_type = HASH_TYPE_SHA1;
7404 salt_type = SALT_TYPE_EMBEDDED;
7405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7406 opts_type = OPTS_TYPE_PT_GENERATE_BE
7407 | OPTS_TYPE_ST_ADD80
7408 | OPTS_TYPE_ST_ADDBITS15;
7409 kern_type = KERN_TYPE_SHA1_PWSLT;
7410 dgst_size = DGST_SIZE_4_5;
7411 parse_func = sha1b64s_parse_hash;
7412 sort_by_digest = sort_by_digest_4_5;
7413 opti_type = OPTI_TYPE_ZERO_BYTE
7414 | OPTI_TYPE_PRECOMPUTE_INIT
7415 | OPTI_TYPE_PRECOMPUTE_MERKLE
7416 | OPTI_TYPE_EARLY_SKIP
7417 | OPTI_TYPE_NOT_ITERATED
7418 | OPTI_TYPE_APPENDED_SALT
7419 | OPTI_TYPE_RAW_HASH;
7420 dgst_pos0 = 3;
7421 dgst_pos1 = 4;
7422 dgst_pos2 = 2;
7423 dgst_pos3 = 1;
7424 break;
7425
7426 case 112: hash_type = HASH_TYPE_SHA1;
7427 salt_type = SALT_TYPE_INTERN;
7428 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7429 opts_type = OPTS_TYPE_PT_GENERATE_BE
7430 | OPTS_TYPE_ST_ADD80
7431 | OPTS_TYPE_ST_ADDBITS15
7432 | OPTS_TYPE_ST_HEX;
7433 kern_type = KERN_TYPE_SHA1_PWSLT;
7434 dgst_size = DGST_SIZE_4_5;
7435 parse_func = oracles_parse_hash;
7436 sort_by_digest = sort_by_digest_4_5;
7437 opti_type = OPTI_TYPE_ZERO_BYTE
7438 | OPTI_TYPE_PRECOMPUTE_INIT
7439 | OPTI_TYPE_PRECOMPUTE_MERKLE
7440 | OPTI_TYPE_EARLY_SKIP
7441 | OPTI_TYPE_NOT_ITERATED
7442 | OPTI_TYPE_APPENDED_SALT
7443 | OPTI_TYPE_RAW_HASH;
7444 dgst_pos0 = 3;
7445 dgst_pos1 = 4;
7446 dgst_pos2 = 2;
7447 dgst_pos3 = 1;
7448 break;
7449
7450 case 120: hash_type = HASH_TYPE_SHA1;
7451 salt_type = SALT_TYPE_INTERN;
7452 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7453 opts_type = OPTS_TYPE_PT_GENERATE_BE
7454 | OPTS_TYPE_PT_ADD80
7455 | OPTS_TYPE_PT_ADDBITS15;
7456 kern_type = KERN_TYPE_SHA1_SLTPW;
7457 dgst_size = DGST_SIZE_4_5;
7458 parse_func = sha1s_parse_hash;
7459 sort_by_digest = sort_by_digest_4_5;
7460 opti_type = OPTI_TYPE_ZERO_BYTE
7461 | OPTI_TYPE_PRECOMPUTE_INIT
7462 | OPTI_TYPE_PRECOMPUTE_MERKLE
7463 | OPTI_TYPE_EARLY_SKIP
7464 | OPTI_TYPE_NOT_ITERATED
7465 | OPTI_TYPE_PREPENDED_SALT
7466 | OPTI_TYPE_RAW_HASH;
7467 dgst_pos0 = 3;
7468 dgst_pos1 = 4;
7469 dgst_pos2 = 2;
7470 dgst_pos3 = 1;
7471 break;
7472
7473 case 121: hash_type = HASH_TYPE_SHA1;
7474 salt_type = SALT_TYPE_INTERN;
7475 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7476 opts_type = OPTS_TYPE_PT_GENERATE_BE
7477 | OPTS_TYPE_PT_ADD80
7478 | OPTS_TYPE_PT_ADDBITS15
7479 | OPTS_TYPE_ST_LOWER;
7480 kern_type = KERN_TYPE_SHA1_SLTPW;
7481 dgst_size = DGST_SIZE_4_5;
7482 parse_func = smf_parse_hash;
7483 sort_by_digest = sort_by_digest_4_5;
7484 opti_type = OPTI_TYPE_ZERO_BYTE
7485 | OPTI_TYPE_PRECOMPUTE_INIT
7486 | OPTI_TYPE_PRECOMPUTE_MERKLE
7487 | OPTI_TYPE_EARLY_SKIP
7488 | OPTI_TYPE_NOT_ITERATED
7489 | OPTI_TYPE_PREPENDED_SALT
7490 | OPTI_TYPE_RAW_HASH;
7491 dgst_pos0 = 3;
7492 dgst_pos1 = 4;
7493 dgst_pos2 = 2;
7494 dgst_pos3 = 1;
7495 break;
7496
7497 case 122: hash_type = HASH_TYPE_SHA1;
7498 salt_type = SALT_TYPE_EMBEDDED;
7499 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7500 opts_type = OPTS_TYPE_PT_GENERATE_BE
7501 | OPTS_TYPE_PT_ADD80
7502 | OPTS_TYPE_PT_ADDBITS15
7503 | OPTS_TYPE_ST_HEX;
7504 kern_type = KERN_TYPE_SHA1_SLTPW;
7505 dgst_size = DGST_SIZE_4_5;
7506 parse_func = osx1_parse_hash;
7507 sort_by_digest = sort_by_digest_4_5;
7508 opti_type = OPTI_TYPE_ZERO_BYTE
7509 | OPTI_TYPE_PRECOMPUTE_INIT
7510 | OPTI_TYPE_PRECOMPUTE_MERKLE
7511 | OPTI_TYPE_EARLY_SKIP
7512 | OPTI_TYPE_NOT_ITERATED
7513 | OPTI_TYPE_PREPENDED_SALT
7514 | OPTI_TYPE_RAW_HASH;
7515 dgst_pos0 = 3;
7516 dgst_pos1 = 4;
7517 dgst_pos2 = 2;
7518 dgst_pos3 = 1;
7519 break;
7520
7521 case 124: hash_type = HASH_TYPE_SHA1;
7522 salt_type = SALT_TYPE_EMBEDDED;
7523 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7524 opts_type = OPTS_TYPE_PT_GENERATE_BE
7525 | OPTS_TYPE_PT_ADD80
7526 | OPTS_TYPE_PT_ADDBITS15;
7527 kern_type = KERN_TYPE_SHA1_SLTPW;
7528 dgst_size = DGST_SIZE_4_5;
7529 parse_func = djangosha1_parse_hash;
7530 sort_by_digest = sort_by_digest_4_5;
7531 opti_type = OPTI_TYPE_ZERO_BYTE
7532 | OPTI_TYPE_PRECOMPUTE_INIT
7533 | OPTI_TYPE_PRECOMPUTE_MERKLE
7534 | OPTI_TYPE_EARLY_SKIP
7535 | OPTI_TYPE_NOT_ITERATED
7536 | OPTI_TYPE_PREPENDED_SALT
7537 | OPTI_TYPE_RAW_HASH;
7538 dgst_pos0 = 3;
7539 dgst_pos1 = 4;
7540 dgst_pos2 = 2;
7541 dgst_pos3 = 1;
7542 break;
7543
7544 case 125: hash_type = HASH_TYPE_SHA1;
7545 salt_type = SALT_TYPE_EMBEDDED;
7546 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7547 opts_type = OPTS_TYPE_PT_GENERATE_BE
7548 | OPTS_TYPE_PT_ADD80
7549 | OPTS_TYPE_PT_ADDBITS15
7550 | OPTS_TYPE_ST_HEX;
7551 kern_type = KERN_TYPE_SHA1_SLTPW;
7552 dgst_size = DGST_SIZE_4_5;
7553 parse_func = arubaos_parse_hash;
7554 sort_by_digest = sort_by_digest_4_5;
7555 opti_type = OPTI_TYPE_ZERO_BYTE
7556 | OPTI_TYPE_PRECOMPUTE_INIT
7557 | OPTI_TYPE_PRECOMPUTE_MERKLE
7558 | OPTI_TYPE_EARLY_SKIP
7559 | OPTI_TYPE_NOT_ITERATED
7560 | OPTI_TYPE_PREPENDED_SALT
7561 | OPTI_TYPE_RAW_HASH;
7562 dgst_pos0 = 3;
7563 dgst_pos1 = 4;
7564 dgst_pos2 = 2;
7565 dgst_pos3 = 1;
7566 break;
7567
7568 case 130: hash_type = HASH_TYPE_SHA1;
7569 salt_type = SALT_TYPE_INTERN;
7570 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7571 opts_type = OPTS_TYPE_PT_GENERATE_BE
7572 | OPTS_TYPE_PT_UNICODE
7573 | OPTS_TYPE_ST_ADD80
7574 | OPTS_TYPE_ST_ADDBITS15;
7575 kern_type = KERN_TYPE_SHA1_PWUSLT;
7576 dgst_size = DGST_SIZE_4_5;
7577 parse_func = sha1s_parse_hash;
7578 sort_by_digest = sort_by_digest_4_5;
7579 opti_type = OPTI_TYPE_ZERO_BYTE
7580 | OPTI_TYPE_PRECOMPUTE_INIT
7581 | OPTI_TYPE_PRECOMPUTE_MERKLE
7582 | OPTI_TYPE_EARLY_SKIP
7583 | OPTI_TYPE_NOT_ITERATED
7584 | OPTI_TYPE_APPENDED_SALT
7585 | OPTI_TYPE_RAW_HASH;
7586 dgst_pos0 = 3;
7587 dgst_pos1 = 4;
7588 dgst_pos2 = 2;
7589 dgst_pos3 = 1;
7590 break;
7591
7592 case 131: hash_type = HASH_TYPE_SHA1;
7593 salt_type = SALT_TYPE_EMBEDDED;
7594 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7595 opts_type = OPTS_TYPE_PT_GENERATE_BE
7596 | OPTS_TYPE_PT_UNICODE
7597 | OPTS_TYPE_PT_UPPER
7598 | OPTS_TYPE_ST_ADD80
7599 | OPTS_TYPE_ST_ADDBITS15
7600 | OPTS_TYPE_ST_HEX;
7601 kern_type = KERN_TYPE_SHA1_PWUSLT;
7602 dgst_size = DGST_SIZE_4_5;
7603 parse_func = mssql2000_parse_hash;
7604 sort_by_digest = sort_by_digest_4_5;
7605 opti_type = OPTI_TYPE_ZERO_BYTE
7606 | OPTI_TYPE_PRECOMPUTE_INIT
7607 | OPTI_TYPE_PRECOMPUTE_MERKLE
7608 | OPTI_TYPE_EARLY_SKIP
7609 | OPTI_TYPE_NOT_ITERATED
7610 | OPTI_TYPE_APPENDED_SALT
7611 | OPTI_TYPE_RAW_HASH;
7612 dgst_pos0 = 3;
7613 dgst_pos1 = 4;
7614 dgst_pos2 = 2;
7615 dgst_pos3 = 1;
7616 break;
7617
7618 case 132: hash_type = HASH_TYPE_SHA1;
7619 salt_type = SALT_TYPE_EMBEDDED;
7620 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7621 opts_type = OPTS_TYPE_PT_GENERATE_BE
7622 | OPTS_TYPE_PT_UNICODE
7623 | OPTS_TYPE_ST_ADD80
7624 | OPTS_TYPE_ST_ADDBITS15
7625 | OPTS_TYPE_ST_HEX;
7626 kern_type = KERN_TYPE_SHA1_PWUSLT;
7627 dgst_size = DGST_SIZE_4_5;
7628 parse_func = mssql2005_parse_hash;
7629 sort_by_digest = sort_by_digest_4_5;
7630 opti_type = OPTI_TYPE_ZERO_BYTE
7631 | OPTI_TYPE_PRECOMPUTE_INIT
7632 | OPTI_TYPE_PRECOMPUTE_MERKLE
7633 | OPTI_TYPE_EARLY_SKIP
7634 | OPTI_TYPE_NOT_ITERATED
7635 | OPTI_TYPE_APPENDED_SALT
7636 | OPTI_TYPE_RAW_HASH;
7637 dgst_pos0 = 3;
7638 dgst_pos1 = 4;
7639 dgst_pos2 = 2;
7640 dgst_pos3 = 1;
7641 break;
7642
7643 case 133: hash_type = HASH_TYPE_SHA1;
7644 salt_type = SALT_TYPE_EMBEDDED;
7645 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7646 opts_type = OPTS_TYPE_PT_GENERATE_BE
7647 | OPTS_TYPE_PT_UNICODE
7648 | OPTS_TYPE_ST_ADD80
7649 | OPTS_TYPE_ST_ADDBITS15;
7650 kern_type = KERN_TYPE_SHA1_PWUSLT;
7651 dgst_size = DGST_SIZE_4_5;
7652 parse_func = peoplesoft_parse_hash;
7653 sort_by_digest = sort_by_digest_4_5;
7654 opti_type = OPTI_TYPE_ZERO_BYTE
7655 | OPTI_TYPE_PRECOMPUTE_INIT
7656 | OPTI_TYPE_PRECOMPUTE_MERKLE
7657 | OPTI_TYPE_EARLY_SKIP
7658 | OPTI_TYPE_NOT_ITERATED
7659 | OPTI_TYPE_APPENDED_SALT
7660 | OPTI_TYPE_RAW_HASH;
7661 dgst_pos0 = 3;
7662 dgst_pos1 = 4;
7663 dgst_pos2 = 2;
7664 dgst_pos3 = 1;
7665 break;
7666
7667 case 140: hash_type = HASH_TYPE_SHA1;
7668 salt_type = SALT_TYPE_INTERN;
7669 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7670 opts_type = OPTS_TYPE_PT_GENERATE_BE
7671 | OPTS_TYPE_PT_ADD80
7672 | OPTS_TYPE_PT_ADDBITS15
7673 | OPTS_TYPE_PT_UNICODE;
7674 kern_type = KERN_TYPE_SHA1_SLTPWU;
7675 dgst_size = DGST_SIZE_4_5;
7676 parse_func = sha1s_parse_hash;
7677 sort_by_digest = sort_by_digest_4_5;
7678 opti_type = OPTI_TYPE_ZERO_BYTE
7679 | OPTI_TYPE_PRECOMPUTE_INIT
7680 | OPTI_TYPE_PRECOMPUTE_MERKLE
7681 | OPTI_TYPE_EARLY_SKIP
7682 | OPTI_TYPE_NOT_ITERATED
7683 | OPTI_TYPE_PREPENDED_SALT
7684 | OPTI_TYPE_RAW_HASH;
7685 dgst_pos0 = 3;
7686 dgst_pos1 = 4;
7687 dgst_pos2 = 2;
7688 dgst_pos3 = 1;
7689 break;
7690
7691 case 141: hash_type = HASH_TYPE_SHA1;
7692 salt_type = SALT_TYPE_EMBEDDED;
7693 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7694 opts_type = OPTS_TYPE_PT_GENERATE_BE
7695 | OPTS_TYPE_PT_ADD80
7696 | OPTS_TYPE_PT_ADDBITS15
7697 | OPTS_TYPE_PT_UNICODE
7698 | OPTS_TYPE_ST_BASE64;
7699 kern_type = KERN_TYPE_SHA1_SLTPWU;
7700 dgst_size = DGST_SIZE_4_5;
7701 parse_func = episerver_parse_hash;
7702 sort_by_digest = sort_by_digest_4_5;
7703 opti_type = OPTI_TYPE_ZERO_BYTE
7704 | OPTI_TYPE_PRECOMPUTE_INIT
7705 | OPTI_TYPE_PRECOMPUTE_MERKLE
7706 | OPTI_TYPE_EARLY_SKIP
7707 | OPTI_TYPE_NOT_ITERATED
7708 | OPTI_TYPE_PREPENDED_SALT
7709 | OPTI_TYPE_RAW_HASH;
7710 dgst_pos0 = 3;
7711 dgst_pos1 = 4;
7712 dgst_pos2 = 2;
7713 dgst_pos3 = 1;
7714 break;
7715
7716 case 150: hash_type = HASH_TYPE_SHA1;
7717 salt_type = SALT_TYPE_INTERN;
7718 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7719 opts_type = OPTS_TYPE_PT_GENERATE_BE
7720 | OPTS_TYPE_ST_ADD80
7721 | OPTS_TYPE_ST_ADDBITS15;
7722 kern_type = KERN_TYPE_HMACSHA1_PW;
7723 dgst_size = DGST_SIZE_4_5;
7724 parse_func = hmacsha1_parse_hash;
7725 sort_by_digest = sort_by_digest_4_5;
7726 opti_type = OPTI_TYPE_ZERO_BYTE
7727 | OPTI_TYPE_NOT_ITERATED;
7728 dgst_pos0 = 3;
7729 dgst_pos1 = 4;
7730 dgst_pos2 = 2;
7731 dgst_pos3 = 1;
7732 break;
7733
7734 case 160: hash_type = HASH_TYPE_SHA1;
7735 salt_type = SALT_TYPE_INTERN;
7736 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7737 opts_type = OPTS_TYPE_PT_GENERATE_BE
7738 | OPTS_TYPE_PT_ADD80
7739 | OPTS_TYPE_PT_ADDBITS15;
7740 kern_type = KERN_TYPE_HMACSHA1_SLT;
7741 dgst_size = DGST_SIZE_4_5;
7742 parse_func = hmacsha1_parse_hash;
7743 sort_by_digest = sort_by_digest_4_5;
7744 opti_type = OPTI_TYPE_ZERO_BYTE
7745 | OPTI_TYPE_NOT_ITERATED;
7746 dgst_pos0 = 3;
7747 dgst_pos1 = 4;
7748 dgst_pos2 = 2;
7749 dgst_pos3 = 1;
7750 break;
7751
7752 case 190: hash_type = HASH_TYPE_SHA1;
7753 salt_type = SALT_TYPE_NONE;
7754 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7755 opts_type = OPTS_TYPE_PT_GENERATE_BE
7756 | OPTS_TYPE_PT_ADD80
7757 | OPTS_TYPE_PT_ADDBITS15;
7758 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7759 dgst_size = DGST_SIZE_4_5;
7760 parse_func = sha1linkedin_parse_hash;
7761 sort_by_digest = sort_by_digest_4_5;
7762 opti_type = OPTI_TYPE_ZERO_BYTE
7763 | OPTI_TYPE_PRECOMPUTE_INIT
7764 | OPTI_TYPE_EARLY_SKIP
7765 | OPTI_TYPE_NOT_ITERATED
7766 | OPTI_TYPE_NOT_SALTED;
7767 dgst_pos0 = 0;
7768 dgst_pos1 = 4;
7769 dgst_pos2 = 3;
7770 dgst_pos3 = 2;
7771 break;
7772
7773 case 200: hash_type = HASH_TYPE_MYSQL;
7774 salt_type = SALT_TYPE_NONE;
7775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7776 opts_type = 0;
7777 kern_type = KERN_TYPE_MYSQL;
7778 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7779 parse_func = mysql323_parse_hash;
7780 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7781 opti_type = OPTI_TYPE_ZERO_BYTE;
7782 dgst_pos0 = 0;
7783 dgst_pos1 = 1;
7784 dgst_pos2 = 2;
7785 dgst_pos3 = 3;
7786 break;
7787
7788 case 300: hash_type = HASH_TYPE_SHA1;
7789 salt_type = SALT_TYPE_NONE;
7790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7791 opts_type = OPTS_TYPE_PT_GENERATE_BE
7792 | OPTS_TYPE_PT_ADD80
7793 | OPTS_TYPE_PT_ADDBITS15;
7794 kern_type = KERN_TYPE_MYSQL41;
7795 dgst_size = DGST_SIZE_4_5;
7796 parse_func = sha1_parse_hash;
7797 sort_by_digest = sort_by_digest_4_5;
7798 opti_type = OPTI_TYPE_ZERO_BYTE
7799 | OPTI_TYPE_PRECOMPUTE_INIT
7800 | OPTI_TYPE_PRECOMPUTE_MERKLE
7801 | OPTI_TYPE_EARLY_SKIP
7802 | OPTI_TYPE_NOT_ITERATED
7803 | OPTI_TYPE_NOT_SALTED;
7804 dgst_pos0 = 3;
7805 dgst_pos1 = 4;
7806 dgst_pos2 = 2;
7807 dgst_pos3 = 1;
7808 break;
7809
7810 case 400: hash_type = HASH_TYPE_MD5;
7811 salt_type = SALT_TYPE_EMBEDDED;
7812 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7813 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7814 kern_type = KERN_TYPE_PHPASS;
7815 dgst_size = DGST_SIZE_4_4;
7816 parse_func = phpass_parse_hash;
7817 sort_by_digest = sort_by_digest_4_4;
7818 opti_type = OPTI_TYPE_ZERO_BYTE
7819 | OPTI_TYPE_SLOW_HASH_SIMD;
7820 dgst_pos0 = 0;
7821 dgst_pos1 = 1;
7822 dgst_pos2 = 2;
7823 dgst_pos3 = 3;
7824 break;
7825
7826 case 500: hash_type = HASH_TYPE_MD5;
7827 salt_type = SALT_TYPE_EMBEDDED;
7828 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7829 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7830 kern_type = KERN_TYPE_MD5CRYPT;
7831 dgst_size = DGST_SIZE_4_4;
7832 parse_func = md5crypt_parse_hash;
7833 sort_by_digest = sort_by_digest_4_4;
7834 opti_type = OPTI_TYPE_ZERO_BYTE;
7835 dgst_pos0 = 0;
7836 dgst_pos1 = 1;
7837 dgst_pos2 = 2;
7838 dgst_pos3 = 3;
7839 break;
7840
7841 case 501: hash_type = HASH_TYPE_MD5;
7842 salt_type = SALT_TYPE_EMBEDDED;
7843 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7844 opts_type = OPTS_TYPE_PT_GENERATE_LE
7845 | OPTS_TYPE_HASH_COPY;
7846 kern_type = KERN_TYPE_MD5CRYPT;
7847 dgst_size = DGST_SIZE_4_4;
7848 parse_func = juniper_parse_hash;
7849 sort_by_digest = sort_by_digest_4_4;
7850 opti_type = OPTI_TYPE_ZERO_BYTE;
7851 dgst_pos0 = 0;
7852 dgst_pos1 = 1;
7853 dgst_pos2 = 2;
7854 dgst_pos3 = 3;
7855 break;
7856
7857 case 900: hash_type = HASH_TYPE_MD4;
7858 salt_type = SALT_TYPE_NONE;
7859 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7860 opts_type = OPTS_TYPE_PT_GENERATE_LE
7861 | OPTS_TYPE_PT_ADD80
7862 | OPTS_TYPE_PT_ADDBITS14;
7863 kern_type = KERN_TYPE_MD4;
7864 dgst_size = DGST_SIZE_4_4;
7865 parse_func = md4_parse_hash;
7866 sort_by_digest = sort_by_digest_4_4;
7867 opti_type = OPTI_TYPE_ZERO_BYTE
7868 | OPTI_TYPE_PRECOMPUTE_INIT
7869 | OPTI_TYPE_PRECOMPUTE_MERKLE
7870 | OPTI_TYPE_MEET_IN_MIDDLE
7871 | OPTI_TYPE_EARLY_SKIP
7872 | OPTI_TYPE_NOT_ITERATED
7873 | OPTI_TYPE_NOT_SALTED
7874 | OPTI_TYPE_RAW_HASH;
7875 dgst_pos0 = 0;
7876 dgst_pos1 = 3;
7877 dgst_pos2 = 2;
7878 dgst_pos3 = 1;
7879 break;
7880
7881 case 1000: hash_type = HASH_TYPE_MD4;
7882 salt_type = SALT_TYPE_NONE;
7883 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7884 opts_type = OPTS_TYPE_PT_GENERATE_LE
7885 | OPTS_TYPE_PT_ADD80
7886 | OPTS_TYPE_PT_ADDBITS14
7887 | OPTS_TYPE_PT_UNICODE;
7888 kern_type = KERN_TYPE_MD4_PWU;
7889 dgst_size = DGST_SIZE_4_4;
7890 parse_func = md4_parse_hash;
7891 sort_by_digest = sort_by_digest_4_4;
7892 opti_type = OPTI_TYPE_ZERO_BYTE
7893 | OPTI_TYPE_PRECOMPUTE_INIT
7894 | OPTI_TYPE_PRECOMPUTE_MERKLE
7895 | OPTI_TYPE_MEET_IN_MIDDLE
7896 | OPTI_TYPE_EARLY_SKIP
7897 | OPTI_TYPE_NOT_ITERATED
7898 | OPTI_TYPE_NOT_SALTED
7899 | OPTI_TYPE_RAW_HASH;
7900 dgst_pos0 = 0;
7901 dgst_pos1 = 3;
7902 dgst_pos2 = 2;
7903 dgst_pos3 = 1;
7904 break;
7905
7906 case 1100: hash_type = HASH_TYPE_MD4;
7907 salt_type = SALT_TYPE_INTERN;
7908 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7909 opts_type = OPTS_TYPE_PT_GENERATE_LE
7910 | OPTS_TYPE_PT_ADD80
7911 | OPTS_TYPE_PT_ADDBITS14
7912 | OPTS_TYPE_PT_UNICODE
7913 | OPTS_TYPE_ST_ADD80
7914 | OPTS_TYPE_ST_UNICODE
7915 | OPTS_TYPE_ST_LOWER;
7916 kern_type = KERN_TYPE_MD44_PWUSLT;
7917 dgst_size = DGST_SIZE_4_4;
7918 parse_func = dcc_parse_hash;
7919 sort_by_digest = sort_by_digest_4_4;
7920 opti_type = OPTI_TYPE_ZERO_BYTE
7921 | OPTI_TYPE_PRECOMPUTE_INIT
7922 | OPTI_TYPE_PRECOMPUTE_MERKLE
7923 | OPTI_TYPE_EARLY_SKIP
7924 | OPTI_TYPE_NOT_ITERATED;
7925 dgst_pos0 = 0;
7926 dgst_pos1 = 3;
7927 dgst_pos2 = 2;
7928 dgst_pos3 = 1;
7929 break;
7930
7931 case 1400: hash_type = HASH_TYPE_SHA256;
7932 salt_type = SALT_TYPE_NONE;
7933 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7934 opts_type = OPTS_TYPE_PT_GENERATE_BE
7935 | OPTS_TYPE_PT_ADD80
7936 | OPTS_TYPE_PT_ADDBITS15;
7937 kern_type = KERN_TYPE_SHA256;
7938 dgst_size = DGST_SIZE_4_8;
7939 parse_func = sha256_parse_hash;
7940 sort_by_digest = sort_by_digest_4_8;
7941 opti_type = OPTI_TYPE_ZERO_BYTE
7942 | OPTI_TYPE_PRECOMPUTE_INIT
7943 | OPTI_TYPE_PRECOMPUTE_MERKLE
7944 | OPTI_TYPE_EARLY_SKIP
7945 | OPTI_TYPE_NOT_ITERATED
7946 | OPTI_TYPE_NOT_SALTED
7947 | OPTI_TYPE_RAW_HASH;
7948 dgst_pos0 = 3;
7949 dgst_pos1 = 7;
7950 dgst_pos2 = 2;
7951 dgst_pos3 = 6;
7952 break;
7953
7954 case 1410: hash_type = HASH_TYPE_SHA256;
7955 salt_type = SALT_TYPE_INTERN;
7956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7957 opts_type = OPTS_TYPE_PT_GENERATE_BE
7958 | OPTS_TYPE_ST_ADD80
7959 | OPTS_TYPE_ST_ADDBITS15;
7960 kern_type = KERN_TYPE_SHA256_PWSLT;
7961 dgst_size = DGST_SIZE_4_8;
7962 parse_func = sha256s_parse_hash;
7963 sort_by_digest = sort_by_digest_4_8;
7964 opti_type = OPTI_TYPE_ZERO_BYTE
7965 | OPTI_TYPE_PRECOMPUTE_INIT
7966 | OPTI_TYPE_PRECOMPUTE_MERKLE
7967 | OPTI_TYPE_EARLY_SKIP
7968 | OPTI_TYPE_NOT_ITERATED
7969 | OPTI_TYPE_APPENDED_SALT
7970 | OPTI_TYPE_RAW_HASH;
7971 dgst_pos0 = 3;
7972 dgst_pos1 = 7;
7973 dgst_pos2 = 2;
7974 dgst_pos3 = 6;
7975 break;
7976
7977 case 1420: hash_type = HASH_TYPE_SHA256;
7978 salt_type = SALT_TYPE_INTERN;
7979 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7980 opts_type = OPTS_TYPE_PT_GENERATE_BE
7981 | OPTS_TYPE_PT_ADD80
7982 | OPTS_TYPE_PT_ADDBITS15;
7983 kern_type = KERN_TYPE_SHA256_SLTPW;
7984 dgst_size = DGST_SIZE_4_8;
7985 parse_func = sha256s_parse_hash;
7986 sort_by_digest = sort_by_digest_4_8;
7987 opti_type = OPTI_TYPE_ZERO_BYTE
7988 | OPTI_TYPE_PRECOMPUTE_INIT
7989 | OPTI_TYPE_PRECOMPUTE_MERKLE
7990 | OPTI_TYPE_EARLY_SKIP
7991 | OPTI_TYPE_NOT_ITERATED
7992 | OPTI_TYPE_PREPENDED_SALT
7993 | OPTI_TYPE_RAW_HASH;
7994 dgst_pos0 = 3;
7995 dgst_pos1 = 7;
7996 dgst_pos2 = 2;
7997 dgst_pos3 = 6;
7998 break;
7999
8000 case 1421: hash_type = HASH_TYPE_SHA256;
8001 salt_type = SALT_TYPE_EMBEDDED;
8002 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8003 opts_type = OPTS_TYPE_PT_GENERATE_BE
8004 | OPTS_TYPE_PT_ADD80
8005 | OPTS_TYPE_PT_ADDBITS15;
8006 kern_type = KERN_TYPE_SHA256_SLTPW;
8007 dgst_size = DGST_SIZE_4_8;
8008 parse_func = hmailserver_parse_hash;
8009 sort_by_digest = sort_by_digest_4_8;
8010 opti_type = OPTI_TYPE_ZERO_BYTE
8011 | OPTI_TYPE_PRECOMPUTE_INIT
8012 | OPTI_TYPE_PRECOMPUTE_MERKLE
8013 | OPTI_TYPE_EARLY_SKIP
8014 | OPTI_TYPE_NOT_ITERATED
8015 | OPTI_TYPE_PREPENDED_SALT
8016 | OPTI_TYPE_RAW_HASH;
8017 dgst_pos0 = 3;
8018 dgst_pos1 = 7;
8019 dgst_pos2 = 2;
8020 dgst_pos3 = 6;
8021 break;
8022
8023 case 1430: hash_type = HASH_TYPE_SHA256;
8024 salt_type = SALT_TYPE_INTERN;
8025 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8026 opts_type = OPTS_TYPE_PT_GENERATE_BE
8027 | OPTS_TYPE_PT_UNICODE
8028 | OPTS_TYPE_ST_ADD80
8029 | OPTS_TYPE_ST_ADDBITS15;
8030 kern_type = KERN_TYPE_SHA256_PWUSLT;
8031 dgst_size = DGST_SIZE_4_8;
8032 parse_func = sha256s_parse_hash;
8033 sort_by_digest = sort_by_digest_4_8;
8034 opti_type = OPTI_TYPE_ZERO_BYTE
8035 | OPTI_TYPE_PRECOMPUTE_INIT
8036 | OPTI_TYPE_PRECOMPUTE_MERKLE
8037 | OPTI_TYPE_EARLY_SKIP
8038 | OPTI_TYPE_NOT_ITERATED
8039 | OPTI_TYPE_APPENDED_SALT
8040 | OPTI_TYPE_RAW_HASH;
8041 dgst_pos0 = 3;
8042 dgst_pos1 = 7;
8043 dgst_pos2 = 2;
8044 dgst_pos3 = 6;
8045 break;
8046
8047 case 1440: hash_type = HASH_TYPE_SHA256;
8048 salt_type = SALT_TYPE_INTERN;
8049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8050 opts_type = OPTS_TYPE_PT_GENERATE_BE
8051 | OPTS_TYPE_PT_ADD80
8052 | OPTS_TYPE_PT_ADDBITS15
8053 | OPTS_TYPE_PT_UNICODE;
8054 kern_type = KERN_TYPE_SHA256_SLTPWU;
8055 dgst_size = DGST_SIZE_4_8;
8056 parse_func = sha256s_parse_hash;
8057 sort_by_digest = sort_by_digest_4_8;
8058 opti_type = OPTI_TYPE_ZERO_BYTE
8059 | OPTI_TYPE_PRECOMPUTE_INIT
8060 | OPTI_TYPE_PRECOMPUTE_MERKLE
8061 | OPTI_TYPE_EARLY_SKIP
8062 | OPTI_TYPE_NOT_ITERATED
8063 | OPTI_TYPE_PREPENDED_SALT
8064 | OPTI_TYPE_RAW_HASH;
8065 dgst_pos0 = 3;
8066 dgst_pos1 = 7;
8067 dgst_pos2 = 2;
8068 dgst_pos3 = 6;
8069 break;
8070
8071 case 1441: hash_type = HASH_TYPE_SHA256;
8072 salt_type = SALT_TYPE_EMBEDDED;
8073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8074 opts_type = OPTS_TYPE_PT_GENERATE_BE
8075 | OPTS_TYPE_PT_ADD80
8076 | OPTS_TYPE_PT_ADDBITS15
8077 | OPTS_TYPE_PT_UNICODE
8078 | OPTS_TYPE_ST_BASE64;
8079 kern_type = KERN_TYPE_SHA256_SLTPWU;
8080 dgst_size = DGST_SIZE_4_8;
8081 parse_func = episerver4_parse_hash;
8082 sort_by_digest = sort_by_digest_4_8;
8083 opti_type = OPTI_TYPE_ZERO_BYTE
8084 | OPTI_TYPE_PRECOMPUTE_INIT
8085 | OPTI_TYPE_PRECOMPUTE_MERKLE
8086 | OPTI_TYPE_EARLY_SKIP
8087 | OPTI_TYPE_NOT_ITERATED
8088 | OPTI_TYPE_PREPENDED_SALT
8089 | OPTI_TYPE_RAW_HASH;
8090 dgst_pos0 = 3;
8091 dgst_pos1 = 7;
8092 dgst_pos2 = 2;
8093 dgst_pos3 = 6;
8094 break;
8095
8096 case 1450: hash_type = HASH_TYPE_SHA256;
8097 salt_type = SALT_TYPE_INTERN;
8098 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8099 opts_type = OPTS_TYPE_PT_GENERATE_BE
8100 | OPTS_TYPE_ST_ADD80;
8101 kern_type = KERN_TYPE_HMACSHA256_PW;
8102 dgst_size = DGST_SIZE_4_8;
8103 parse_func = hmacsha256_parse_hash;
8104 sort_by_digest = sort_by_digest_4_8;
8105 opti_type = OPTI_TYPE_ZERO_BYTE
8106 | OPTI_TYPE_NOT_ITERATED;
8107 dgst_pos0 = 3;
8108 dgst_pos1 = 7;
8109 dgst_pos2 = 2;
8110 dgst_pos3 = 6;
8111 break;
8112
8113 case 1460: hash_type = HASH_TYPE_SHA256;
8114 salt_type = SALT_TYPE_INTERN;
8115 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8116 opts_type = OPTS_TYPE_PT_GENERATE_BE
8117 | OPTS_TYPE_PT_ADD80
8118 | OPTS_TYPE_PT_ADDBITS15;
8119 kern_type = KERN_TYPE_HMACSHA256_SLT;
8120 dgst_size = DGST_SIZE_4_8;
8121 parse_func = hmacsha256_parse_hash;
8122 sort_by_digest = sort_by_digest_4_8;
8123 opti_type = OPTI_TYPE_ZERO_BYTE
8124 | OPTI_TYPE_NOT_ITERATED;
8125 dgst_pos0 = 3;
8126 dgst_pos1 = 7;
8127 dgst_pos2 = 2;
8128 dgst_pos3 = 6;
8129 break;
8130
8131 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8132 salt_type = SALT_TYPE_EMBEDDED;
8133 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8134 opts_type = OPTS_TYPE_PT_GENERATE_LE
8135 | OPTS_TYPE_PT_BITSLICE;
8136 kern_type = KERN_TYPE_DESCRYPT;
8137 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8138 parse_func = descrypt_parse_hash;
8139 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8140 opti_type = OPTI_TYPE_ZERO_BYTE
8141 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8142 dgst_pos0 = 0;
8143 dgst_pos1 = 1;
8144 dgst_pos2 = 2;
8145 dgst_pos3 = 3;
8146 break;
8147
8148 case 1600: hash_type = HASH_TYPE_MD5;
8149 salt_type = SALT_TYPE_EMBEDDED;
8150 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8151 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8152 kern_type = KERN_TYPE_APR1CRYPT;
8153 dgst_size = DGST_SIZE_4_4;
8154 parse_func = md5apr1_parse_hash;
8155 sort_by_digest = sort_by_digest_4_4;
8156 opti_type = OPTI_TYPE_ZERO_BYTE;
8157 dgst_pos0 = 0;
8158 dgst_pos1 = 1;
8159 dgst_pos2 = 2;
8160 dgst_pos3 = 3;
8161 break;
8162
8163 case 1700: hash_type = HASH_TYPE_SHA512;
8164 salt_type = SALT_TYPE_NONE;
8165 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8166 opts_type = OPTS_TYPE_PT_GENERATE_BE
8167 | OPTS_TYPE_PT_ADD80
8168 | OPTS_TYPE_PT_ADDBITS15;
8169 kern_type = KERN_TYPE_SHA512;
8170 dgst_size = DGST_SIZE_8_8;
8171 parse_func = sha512_parse_hash;
8172 sort_by_digest = sort_by_digest_8_8;
8173 opti_type = OPTI_TYPE_ZERO_BYTE
8174 | OPTI_TYPE_PRECOMPUTE_INIT
8175 | OPTI_TYPE_PRECOMPUTE_MERKLE
8176 | OPTI_TYPE_EARLY_SKIP
8177 | OPTI_TYPE_NOT_ITERATED
8178 | OPTI_TYPE_NOT_SALTED
8179 | OPTI_TYPE_USES_BITS_64
8180 | OPTI_TYPE_RAW_HASH;
8181 dgst_pos0 = 14;
8182 dgst_pos1 = 15;
8183 dgst_pos2 = 6;
8184 dgst_pos3 = 7;
8185 break;
8186
8187 case 1710: hash_type = HASH_TYPE_SHA512;
8188 salt_type = SALT_TYPE_INTERN;
8189 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8190 opts_type = OPTS_TYPE_PT_GENERATE_BE
8191 | OPTS_TYPE_ST_ADD80
8192 | OPTS_TYPE_ST_ADDBITS15;
8193 kern_type = KERN_TYPE_SHA512_PWSLT;
8194 dgst_size = DGST_SIZE_8_8;
8195 parse_func = sha512s_parse_hash;
8196 sort_by_digest = sort_by_digest_8_8;
8197 opti_type = OPTI_TYPE_ZERO_BYTE
8198 | OPTI_TYPE_PRECOMPUTE_INIT
8199 | OPTI_TYPE_PRECOMPUTE_MERKLE
8200 | OPTI_TYPE_EARLY_SKIP
8201 | OPTI_TYPE_NOT_ITERATED
8202 | OPTI_TYPE_APPENDED_SALT
8203 | OPTI_TYPE_USES_BITS_64
8204 | OPTI_TYPE_RAW_HASH;
8205 dgst_pos0 = 14;
8206 dgst_pos1 = 15;
8207 dgst_pos2 = 6;
8208 dgst_pos3 = 7;
8209 break;
8210
8211 case 1711: hash_type = HASH_TYPE_SHA512;
8212 salt_type = SALT_TYPE_EMBEDDED;
8213 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8214 opts_type = OPTS_TYPE_PT_GENERATE_BE
8215 | OPTS_TYPE_ST_ADD80
8216 | OPTS_TYPE_ST_ADDBITS15;
8217 kern_type = KERN_TYPE_SHA512_PWSLT;
8218 dgst_size = DGST_SIZE_8_8;
8219 parse_func = sha512b64s_parse_hash;
8220 sort_by_digest = sort_by_digest_8_8;
8221 opti_type = OPTI_TYPE_ZERO_BYTE
8222 | OPTI_TYPE_PRECOMPUTE_INIT
8223 | OPTI_TYPE_PRECOMPUTE_MERKLE
8224 | OPTI_TYPE_EARLY_SKIP
8225 | OPTI_TYPE_NOT_ITERATED
8226 | OPTI_TYPE_APPENDED_SALT
8227 | OPTI_TYPE_USES_BITS_64
8228 | OPTI_TYPE_RAW_HASH;
8229 dgst_pos0 = 14;
8230 dgst_pos1 = 15;
8231 dgst_pos2 = 6;
8232 dgst_pos3 = 7;
8233 break;
8234
8235 case 1720: hash_type = HASH_TYPE_SHA512;
8236 salt_type = SALT_TYPE_INTERN;
8237 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8238 opts_type = OPTS_TYPE_PT_GENERATE_BE
8239 | OPTS_TYPE_PT_ADD80
8240 | OPTS_TYPE_PT_ADDBITS15;
8241 kern_type = KERN_TYPE_SHA512_SLTPW;
8242 dgst_size = DGST_SIZE_8_8;
8243 parse_func = sha512s_parse_hash;
8244 sort_by_digest = sort_by_digest_8_8;
8245 opti_type = OPTI_TYPE_ZERO_BYTE
8246 | OPTI_TYPE_PRECOMPUTE_INIT
8247 | OPTI_TYPE_PRECOMPUTE_MERKLE
8248 | OPTI_TYPE_EARLY_SKIP
8249 | OPTI_TYPE_NOT_ITERATED
8250 | OPTI_TYPE_PREPENDED_SALT
8251 | OPTI_TYPE_USES_BITS_64
8252 | OPTI_TYPE_RAW_HASH;
8253 dgst_pos0 = 14;
8254 dgst_pos1 = 15;
8255 dgst_pos2 = 6;
8256 dgst_pos3 = 7;
8257 break;
8258
8259 case 1722: hash_type = HASH_TYPE_SHA512;
8260 salt_type = SALT_TYPE_EMBEDDED;
8261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8262 opts_type = OPTS_TYPE_PT_GENERATE_BE
8263 | OPTS_TYPE_PT_ADD80
8264 | OPTS_TYPE_PT_ADDBITS15
8265 | OPTS_TYPE_ST_HEX;
8266 kern_type = KERN_TYPE_SHA512_SLTPW;
8267 dgst_size = DGST_SIZE_8_8;
8268 parse_func = osx512_parse_hash;
8269 sort_by_digest = sort_by_digest_8_8;
8270 opti_type = OPTI_TYPE_ZERO_BYTE
8271 | OPTI_TYPE_PRECOMPUTE_INIT
8272 | OPTI_TYPE_PRECOMPUTE_MERKLE
8273 | OPTI_TYPE_EARLY_SKIP
8274 | OPTI_TYPE_NOT_ITERATED
8275 | OPTI_TYPE_PREPENDED_SALT
8276 | OPTI_TYPE_USES_BITS_64
8277 | OPTI_TYPE_RAW_HASH;
8278 dgst_pos0 = 14;
8279 dgst_pos1 = 15;
8280 dgst_pos2 = 6;
8281 dgst_pos3 = 7;
8282 break;
8283
8284 case 1730: hash_type = HASH_TYPE_SHA512;
8285 salt_type = SALT_TYPE_INTERN;
8286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8287 opts_type = OPTS_TYPE_PT_GENERATE_BE
8288 | OPTS_TYPE_PT_UNICODE
8289 | OPTS_TYPE_ST_ADD80
8290 | OPTS_TYPE_ST_ADDBITS15;
8291 kern_type = KERN_TYPE_SHA512_PWSLTU;
8292 dgst_size = DGST_SIZE_8_8;
8293 parse_func = sha512s_parse_hash;
8294 sort_by_digest = sort_by_digest_8_8;
8295 opti_type = OPTI_TYPE_ZERO_BYTE
8296 | OPTI_TYPE_PRECOMPUTE_INIT
8297 | OPTI_TYPE_PRECOMPUTE_MERKLE
8298 | OPTI_TYPE_EARLY_SKIP
8299 | OPTI_TYPE_NOT_ITERATED
8300 | OPTI_TYPE_APPENDED_SALT
8301 | OPTI_TYPE_USES_BITS_64
8302 | OPTI_TYPE_RAW_HASH;
8303 dgst_pos0 = 14;
8304 dgst_pos1 = 15;
8305 dgst_pos2 = 6;
8306 dgst_pos3 = 7;
8307 break;
8308
8309 case 1731: hash_type = HASH_TYPE_SHA512;
8310 salt_type = SALT_TYPE_EMBEDDED;
8311 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8312 opts_type = OPTS_TYPE_PT_GENERATE_BE
8313 | OPTS_TYPE_PT_UNICODE
8314 | OPTS_TYPE_ST_ADD80
8315 | OPTS_TYPE_ST_ADDBITS15
8316 | OPTS_TYPE_ST_HEX;
8317 kern_type = KERN_TYPE_SHA512_PWSLTU;
8318 dgst_size = DGST_SIZE_8_8;
8319 parse_func = mssql2012_parse_hash;
8320 sort_by_digest = sort_by_digest_8_8;
8321 opti_type = OPTI_TYPE_ZERO_BYTE
8322 | OPTI_TYPE_PRECOMPUTE_INIT
8323 | OPTI_TYPE_PRECOMPUTE_MERKLE
8324 | OPTI_TYPE_EARLY_SKIP
8325 | OPTI_TYPE_NOT_ITERATED
8326 | OPTI_TYPE_APPENDED_SALT
8327 | OPTI_TYPE_USES_BITS_64
8328 | OPTI_TYPE_RAW_HASH;
8329 dgst_pos0 = 14;
8330 dgst_pos1 = 15;
8331 dgst_pos2 = 6;
8332 dgst_pos3 = 7;
8333 break;
8334
8335 case 1740: hash_type = HASH_TYPE_SHA512;
8336 salt_type = SALT_TYPE_INTERN;
8337 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8338 opts_type = OPTS_TYPE_PT_GENERATE_BE
8339 | OPTS_TYPE_PT_ADD80
8340 | OPTS_TYPE_PT_ADDBITS15
8341 | OPTS_TYPE_PT_UNICODE;
8342 kern_type = KERN_TYPE_SHA512_SLTPWU;
8343 dgst_size = DGST_SIZE_8_8;
8344 parse_func = sha512s_parse_hash;
8345 sort_by_digest = sort_by_digest_8_8;
8346 opti_type = OPTI_TYPE_ZERO_BYTE
8347 | OPTI_TYPE_PRECOMPUTE_INIT
8348 | OPTI_TYPE_PRECOMPUTE_MERKLE
8349 | OPTI_TYPE_EARLY_SKIP
8350 | OPTI_TYPE_NOT_ITERATED
8351 | OPTI_TYPE_PREPENDED_SALT
8352 | OPTI_TYPE_USES_BITS_64
8353 | OPTI_TYPE_RAW_HASH;
8354 dgst_pos0 = 14;
8355 dgst_pos1 = 15;
8356 dgst_pos2 = 6;
8357 dgst_pos3 = 7;
8358 break;
8359
8360 case 1750: hash_type = HASH_TYPE_SHA512;
8361 salt_type = SALT_TYPE_INTERN;
8362 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8363 opts_type = OPTS_TYPE_PT_GENERATE_BE
8364 | OPTS_TYPE_ST_ADD80;
8365 kern_type = KERN_TYPE_HMACSHA512_PW;
8366 dgst_size = DGST_SIZE_8_8;
8367 parse_func = hmacsha512_parse_hash;
8368 sort_by_digest = sort_by_digest_8_8;
8369 opti_type = OPTI_TYPE_ZERO_BYTE
8370 | OPTI_TYPE_USES_BITS_64
8371 | OPTI_TYPE_NOT_ITERATED;
8372 dgst_pos0 = 14;
8373 dgst_pos1 = 15;
8374 dgst_pos2 = 6;
8375 dgst_pos3 = 7;
8376 break;
8377
8378 case 1760: hash_type = HASH_TYPE_SHA512;
8379 salt_type = SALT_TYPE_INTERN;
8380 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8381 opts_type = OPTS_TYPE_PT_GENERATE_BE
8382 | OPTS_TYPE_PT_ADD80
8383 | OPTS_TYPE_PT_ADDBITS15;
8384 kern_type = KERN_TYPE_HMACSHA512_SLT;
8385 dgst_size = DGST_SIZE_8_8;
8386 parse_func = hmacsha512_parse_hash;
8387 sort_by_digest = sort_by_digest_8_8;
8388 opti_type = OPTI_TYPE_ZERO_BYTE
8389 | OPTI_TYPE_USES_BITS_64
8390 | OPTI_TYPE_NOT_ITERATED;
8391 dgst_pos0 = 14;
8392 dgst_pos1 = 15;
8393 dgst_pos2 = 6;
8394 dgst_pos3 = 7;
8395 break;
8396
8397 case 1800: hash_type = HASH_TYPE_SHA512;
8398 salt_type = SALT_TYPE_EMBEDDED;
8399 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8400 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8401 kern_type = KERN_TYPE_SHA512CRYPT;
8402 dgst_size = DGST_SIZE_8_8;
8403 parse_func = sha512crypt_parse_hash;
8404 sort_by_digest = sort_by_digest_8_8;
8405 opti_type = OPTI_TYPE_ZERO_BYTE
8406 | OPTI_TYPE_USES_BITS_64;
8407 dgst_pos0 = 0;
8408 dgst_pos1 = 1;
8409 dgst_pos2 = 2;
8410 dgst_pos3 = 3;
8411 break;
8412
8413 case 2100: hash_type = HASH_TYPE_DCC2;
8414 salt_type = SALT_TYPE_EMBEDDED;
8415 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8416 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8417 | OPTS_TYPE_ST_LOWER
8418 | OPTS_TYPE_ST_UNICODE;
8419 kern_type = KERN_TYPE_DCC2;
8420 dgst_size = DGST_SIZE_4_4;
8421 parse_func = dcc2_parse_hash;
8422 sort_by_digest = sort_by_digest_4_4;
8423 opti_type = OPTI_TYPE_ZERO_BYTE
8424 | OPTI_TYPE_SLOW_HASH_SIMD;
8425 dgst_pos0 = 0;
8426 dgst_pos1 = 1;
8427 dgst_pos2 = 2;
8428 dgst_pos3 = 3;
8429 break;
8430
8431 case 2400: hash_type = HASH_TYPE_MD5;
8432 salt_type = SALT_TYPE_NONE;
8433 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8434 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8435 kern_type = KERN_TYPE_MD5PIX;
8436 dgst_size = DGST_SIZE_4_4;
8437 parse_func = md5pix_parse_hash;
8438 sort_by_digest = sort_by_digest_4_4;
8439 opti_type = OPTI_TYPE_ZERO_BYTE
8440 | OPTI_TYPE_PRECOMPUTE_INIT
8441 | OPTI_TYPE_PRECOMPUTE_MERKLE
8442 | OPTI_TYPE_EARLY_SKIP
8443 | OPTI_TYPE_NOT_ITERATED
8444 | OPTI_TYPE_NOT_SALTED;
8445 dgst_pos0 = 0;
8446 dgst_pos1 = 3;
8447 dgst_pos2 = 2;
8448 dgst_pos3 = 1;
8449 break;
8450
8451 case 2410: hash_type = HASH_TYPE_MD5;
8452 salt_type = SALT_TYPE_INTERN;
8453 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8454 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8455 kern_type = KERN_TYPE_MD5ASA;
8456 dgst_size = DGST_SIZE_4_4;
8457 parse_func = md5asa_parse_hash;
8458 sort_by_digest = sort_by_digest_4_4;
8459 opti_type = OPTI_TYPE_ZERO_BYTE
8460 | OPTI_TYPE_PRECOMPUTE_INIT
8461 | OPTI_TYPE_PRECOMPUTE_MERKLE
8462 | OPTI_TYPE_EARLY_SKIP
8463 | OPTI_TYPE_NOT_ITERATED;
8464 dgst_pos0 = 0;
8465 dgst_pos1 = 3;
8466 dgst_pos2 = 2;
8467 dgst_pos3 = 1;
8468 break;
8469
8470 case 2500: hash_type = HASH_TYPE_WPA;
8471 salt_type = SALT_TYPE_EMBEDDED;
8472 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8473 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8474 kern_type = KERN_TYPE_WPA;
8475 dgst_size = DGST_SIZE_4_4;
8476 parse_func = wpa_parse_hash;
8477 sort_by_digest = sort_by_digest_4_4;
8478 opti_type = OPTI_TYPE_ZERO_BYTE
8479 | OPTI_TYPE_SLOW_HASH_SIMD;
8480 dgst_pos0 = 0;
8481 dgst_pos1 = 1;
8482 dgst_pos2 = 2;
8483 dgst_pos3 = 3;
8484 break;
8485
8486 case 2600: hash_type = HASH_TYPE_MD5;
8487 salt_type = SALT_TYPE_VIRTUAL;
8488 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8489 opts_type = OPTS_TYPE_PT_GENERATE_LE
8490 | OPTS_TYPE_PT_ADD80
8491 | OPTS_TYPE_PT_ADDBITS14
8492 | OPTS_TYPE_ST_ADD80;
8493 kern_type = KERN_TYPE_MD55_PWSLT1;
8494 dgst_size = DGST_SIZE_4_4;
8495 parse_func = md5md5_parse_hash;
8496 sort_by_digest = sort_by_digest_4_4;
8497 opti_type = OPTI_TYPE_ZERO_BYTE
8498 | OPTI_TYPE_PRECOMPUTE_INIT
8499 | OPTI_TYPE_PRECOMPUTE_MERKLE
8500 | OPTI_TYPE_EARLY_SKIP;
8501 dgst_pos0 = 0;
8502 dgst_pos1 = 3;
8503 dgst_pos2 = 2;
8504 dgst_pos3 = 1;
8505 break;
8506
8507 case 2611: hash_type = HASH_TYPE_MD5;
8508 salt_type = SALT_TYPE_INTERN;
8509 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8510 opts_type = OPTS_TYPE_PT_GENERATE_LE
8511 | OPTS_TYPE_PT_ADD80
8512 | OPTS_TYPE_PT_ADDBITS14
8513 | OPTS_TYPE_ST_ADD80;
8514 kern_type = KERN_TYPE_MD55_PWSLT1;
8515 dgst_size = DGST_SIZE_4_4;
8516 parse_func = vb3_parse_hash;
8517 sort_by_digest = sort_by_digest_4_4;
8518 opti_type = OPTI_TYPE_ZERO_BYTE
8519 | OPTI_TYPE_PRECOMPUTE_INIT
8520 | OPTI_TYPE_PRECOMPUTE_MERKLE
8521 | OPTI_TYPE_EARLY_SKIP;
8522 dgst_pos0 = 0;
8523 dgst_pos1 = 3;
8524 dgst_pos2 = 2;
8525 dgst_pos3 = 1;
8526 break;
8527
8528 case 2612: hash_type = HASH_TYPE_MD5;
8529 salt_type = SALT_TYPE_EMBEDDED;
8530 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8531 opts_type = OPTS_TYPE_PT_GENERATE_LE
8532 | OPTS_TYPE_PT_ADD80
8533 | OPTS_TYPE_PT_ADDBITS14
8534 | OPTS_TYPE_ST_ADD80
8535 | OPTS_TYPE_ST_HEX;
8536 kern_type = KERN_TYPE_MD55_PWSLT1;
8537 dgst_size = DGST_SIZE_4_4;
8538 parse_func = phps_parse_hash;
8539 sort_by_digest = sort_by_digest_4_4;
8540 opti_type = OPTI_TYPE_ZERO_BYTE
8541 | OPTI_TYPE_PRECOMPUTE_INIT
8542 | OPTI_TYPE_PRECOMPUTE_MERKLE
8543 | OPTI_TYPE_EARLY_SKIP;
8544 dgst_pos0 = 0;
8545 dgst_pos1 = 3;
8546 dgst_pos2 = 2;
8547 dgst_pos3 = 1;
8548 break;
8549
8550 case 2711: hash_type = HASH_TYPE_MD5;
8551 salt_type = SALT_TYPE_INTERN;
8552 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8553 opts_type = OPTS_TYPE_PT_GENERATE_LE
8554 | OPTS_TYPE_PT_ADD80
8555 | OPTS_TYPE_PT_ADDBITS14
8556 | OPTS_TYPE_ST_ADD80;
8557 kern_type = KERN_TYPE_MD55_PWSLT2;
8558 dgst_size = DGST_SIZE_4_4;
8559 parse_func = vb30_parse_hash;
8560 sort_by_digest = sort_by_digest_4_4;
8561 opti_type = OPTI_TYPE_ZERO_BYTE
8562 | OPTI_TYPE_PRECOMPUTE_INIT
8563 | OPTI_TYPE_EARLY_SKIP;
8564 dgst_pos0 = 0;
8565 dgst_pos1 = 3;
8566 dgst_pos2 = 2;
8567 dgst_pos3 = 1;
8568 break;
8569
8570 case 2811: hash_type = HASH_TYPE_MD5;
8571 salt_type = SALT_TYPE_INTERN;
8572 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8573 opts_type = OPTS_TYPE_PT_GENERATE_LE
8574 | OPTS_TYPE_PT_ADD80
8575 | OPTS_TYPE_PT_ADDBITS14;
8576 kern_type = KERN_TYPE_MD55_SLTPW;
8577 dgst_size = DGST_SIZE_4_4;
8578 parse_func = ipb2_parse_hash;
8579 sort_by_digest = sort_by_digest_4_4;
8580 opti_type = OPTI_TYPE_ZERO_BYTE
8581 | OPTI_TYPE_PRECOMPUTE_INIT
8582 | OPTI_TYPE_EARLY_SKIP;
8583 dgst_pos0 = 0;
8584 dgst_pos1 = 3;
8585 dgst_pos2 = 2;
8586 dgst_pos3 = 1;
8587 break;
8588
8589 case 3000: hash_type = HASH_TYPE_LM;
8590 salt_type = SALT_TYPE_NONE;
8591 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8592 opts_type = OPTS_TYPE_PT_GENERATE_LE
8593 | OPTS_TYPE_PT_UPPER
8594 | OPTS_TYPE_PT_BITSLICE;
8595 kern_type = KERN_TYPE_LM;
8596 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8597 parse_func = lm_parse_hash;
8598 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8599 opti_type = OPTI_TYPE_ZERO_BYTE
8600 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8601 dgst_pos0 = 0;
8602 dgst_pos1 = 1;
8603 dgst_pos2 = 2;
8604 dgst_pos3 = 3;
8605 break;
8606
8607 case 3100: hash_type = HASH_TYPE_ORACLEH;
8608 salt_type = SALT_TYPE_INTERN;
8609 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8610 opts_type = OPTS_TYPE_PT_GENERATE_LE
8611 | OPTS_TYPE_PT_UPPER
8612 | OPTS_TYPE_ST_UPPER;
8613 kern_type = KERN_TYPE_ORACLEH;
8614 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8615 parse_func = oracleh_parse_hash;
8616 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8617 opti_type = OPTI_TYPE_ZERO_BYTE;
8618 dgst_pos0 = 0;
8619 dgst_pos1 = 1;
8620 dgst_pos2 = 2;
8621 dgst_pos3 = 3;
8622 break;
8623
8624 case 3200: hash_type = HASH_TYPE_BCRYPT;
8625 salt_type = SALT_TYPE_EMBEDDED;
8626 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8627 opts_type = OPTS_TYPE_PT_GENERATE_LE
8628 | OPTS_TYPE_ST_GENERATE_LE;
8629 kern_type = KERN_TYPE_BCRYPT;
8630 dgst_size = DGST_SIZE_4_6;
8631 parse_func = bcrypt_parse_hash;
8632 sort_by_digest = sort_by_digest_4_6;
8633 opti_type = OPTI_TYPE_ZERO_BYTE;
8634 dgst_pos0 = 0;
8635 dgst_pos1 = 1;
8636 dgst_pos2 = 2;
8637 dgst_pos3 = 3;
8638 break;
8639
8640 case 3710: hash_type = HASH_TYPE_MD5;
8641 salt_type = SALT_TYPE_INTERN;
8642 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8643 opts_type = OPTS_TYPE_PT_GENERATE_LE
8644 | OPTS_TYPE_PT_ADD80
8645 | OPTS_TYPE_PT_ADDBITS14;
8646 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8647 dgst_size = DGST_SIZE_4_4;
8648 parse_func = md5s_parse_hash;
8649 sort_by_digest = sort_by_digest_4_4;
8650 opti_type = OPTI_TYPE_ZERO_BYTE
8651 | OPTI_TYPE_PRECOMPUTE_INIT
8652 | OPTI_TYPE_PRECOMPUTE_MERKLE
8653 | OPTI_TYPE_EARLY_SKIP;
8654 dgst_pos0 = 0;
8655 dgst_pos1 = 3;
8656 dgst_pos2 = 2;
8657 dgst_pos3 = 1;
8658 break;
8659
8660 case 3711: hash_type = HASH_TYPE_MD5;
8661 salt_type = SALT_TYPE_EMBEDDED;
8662 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8663 opts_type = OPTS_TYPE_PT_GENERATE_LE
8664 | OPTS_TYPE_PT_ADD80
8665 | OPTS_TYPE_PT_ADDBITS14;
8666 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8667 dgst_size = DGST_SIZE_4_4;
8668 parse_func = mediawiki_b_parse_hash;
8669 sort_by_digest = sort_by_digest_4_4;
8670 opti_type = OPTI_TYPE_ZERO_BYTE
8671 | OPTI_TYPE_PRECOMPUTE_INIT
8672 | OPTI_TYPE_PRECOMPUTE_MERKLE
8673 | OPTI_TYPE_EARLY_SKIP;
8674 dgst_pos0 = 0;
8675 dgst_pos1 = 3;
8676 dgst_pos2 = 2;
8677 dgst_pos3 = 1;
8678 break;
8679
8680 case 3800: hash_type = HASH_TYPE_MD5;
8681 salt_type = SALT_TYPE_INTERN;
8682 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8683 opts_type = OPTS_TYPE_PT_GENERATE_LE
8684 | OPTS_TYPE_ST_ADDBITS14;
8685 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8686 dgst_size = DGST_SIZE_4_4;
8687 parse_func = md5s_parse_hash;
8688 sort_by_digest = sort_by_digest_4_4;
8689 opti_type = OPTI_TYPE_ZERO_BYTE
8690 | OPTI_TYPE_PRECOMPUTE_INIT
8691 | OPTI_TYPE_PRECOMPUTE_MERKLE
8692 | OPTI_TYPE_EARLY_SKIP
8693 | OPTI_TYPE_NOT_ITERATED
8694 | OPTI_TYPE_RAW_HASH;
8695 dgst_pos0 = 0;
8696 dgst_pos1 = 3;
8697 dgst_pos2 = 2;
8698 dgst_pos3 = 1;
8699 break;
8700
8701 case 4300: hash_type = HASH_TYPE_MD5;
8702 salt_type = SALT_TYPE_VIRTUAL;
8703 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8704 opts_type = OPTS_TYPE_PT_GENERATE_LE
8705 | OPTS_TYPE_PT_ADD80
8706 | OPTS_TYPE_PT_ADDBITS14
8707 | OPTS_TYPE_ST_ADD80;
8708 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8709 dgst_size = DGST_SIZE_4_4;
8710 parse_func = md5md5_parse_hash;
8711 sort_by_digest = sort_by_digest_4_4;
8712 opti_type = OPTI_TYPE_ZERO_BYTE
8713 | OPTI_TYPE_PRECOMPUTE_INIT
8714 | OPTI_TYPE_PRECOMPUTE_MERKLE
8715 | OPTI_TYPE_EARLY_SKIP;
8716 dgst_pos0 = 0;
8717 dgst_pos1 = 3;
8718 dgst_pos2 = 2;
8719 dgst_pos3 = 1;
8720 break;
8721
8722
8723 case 4400: hash_type = HASH_TYPE_MD5;
8724 salt_type = SALT_TYPE_NONE;
8725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8726 opts_type = OPTS_TYPE_PT_GENERATE_BE
8727 | OPTS_TYPE_PT_ADD80
8728 | OPTS_TYPE_PT_ADDBITS15;
8729 kern_type = KERN_TYPE_MD5_SHA1;
8730 dgst_size = DGST_SIZE_4_4;
8731 parse_func = md5_parse_hash;
8732 sort_by_digest = sort_by_digest_4_4;
8733 opti_type = OPTI_TYPE_ZERO_BYTE
8734 | OPTI_TYPE_PRECOMPUTE_INIT
8735 | OPTI_TYPE_PRECOMPUTE_MERKLE
8736 | OPTI_TYPE_EARLY_SKIP
8737 | OPTI_TYPE_NOT_ITERATED
8738 | OPTI_TYPE_NOT_SALTED
8739 | OPTI_TYPE_RAW_HASH;
8740 dgst_pos0 = 0;
8741 dgst_pos1 = 3;
8742 dgst_pos2 = 2;
8743 dgst_pos3 = 1;
8744 break;
8745
8746 case 4500: hash_type = HASH_TYPE_SHA1;
8747 salt_type = SALT_TYPE_NONE;
8748 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8749 opts_type = OPTS_TYPE_PT_GENERATE_BE
8750 | OPTS_TYPE_PT_ADD80
8751 | OPTS_TYPE_PT_ADDBITS15;
8752 kern_type = KERN_TYPE_SHA11;
8753 dgst_size = DGST_SIZE_4_5;
8754 parse_func = sha1_parse_hash;
8755 sort_by_digest = sort_by_digest_4_5;
8756 opti_type = OPTI_TYPE_ZERO_BYTE
8757 | OPTI_TYPE_PRECOMPUTE_INIT
8758 | OPTI_TYPE_PRECOMPUTE_MERKLE
8759 | OPTI_TYPE_EARLY_SKIP
8760 | OPTI_TYPE_NOT_SALTED;
8761 dgst_pos0 = 3;
8762 dgst_pos1 = 4;
8763 dgst_pos2 = 2;
8764 dgst_pos3 = 1;
8765 break;
8766
8767 case 4700: hash_type = HASH_TYPE_SHA1;
8768 salt_type = SALT_TYPE_NONE;
8769 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8770 opts_type = OPTS_TYPE_PT_GENERATE_LE
8771 | OPTS_TYPE_PT_ADD80
8772 | OPTS_TYPE_PT_ADDBITS14;
8773 kern_type = KERN_TYPE_SHA1_MD5;
8774 dgst_size = DGST_SIZE_4_5;
8775 parse_func = sha1_parse_hash;
8776 sort_by_digest = sort_by_digest_4_5;
8777 opti_type = OPTI_TYPE_ZERO_BYTE
8778 | OPTI_TYPE_PRECOMPUTE_INIT
8779 | OPTI_TYPE_PRECOMPUTE_MERKLE
8780 | OPTI_TYPE_EARLY_SKIP
8781 | OPTI_TYPE_NOT_ITERATED
8782 | OPTI_TYPE_NOT_SALTED
8783 | OPTI_TYPE_RAW_HASH;
8784 dgst_pos0 = 3;
8785 dgst_pos1 = 4;
8786 dgst_pos2 = 2;
8787 dgst_pos3 = 1;
8788 break;
8789
8790 case 4800: hash_type = HASH_TYPE_MD5;
8791 salt_type = SALT_TYPE_EMBEDDED;
8792 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8793 opts_type = OPTS_TYPE_PT_GENERATE_LE
8794 | OPTS_TYPE_PT_ADDBITS14;
8795 kern_type = KERN_TYPE_MD5_CHAP;
8796 dgst_size = DGST_SIZE_4_4;
8797 parse_func = chap_parse_hash;
8798 sort_by_digest = sort_by_digest_4_4;
8799 opti_type = OPTI_TYPE_ZERO_BYTE
8800 | OPTI_TYPE_PRECOMPUTE_INIT
8801 | OPTI_TYPE_PRECOMPUTE_MERKLE
8802 | OPTI_TYPE_MEET_IN_MIDDLE
8803 | OPTI_TYPE_EARLY_SKIP
8804 | OPTI_TYPE_NOT_ITERATED
8805 | OPTI_TYPE_RAW_HASH;
8806 dgst_pos0 = 0;
8807 dgst_pos1 = 3;
8808 dgst_pos2 = 2;
8809 dgst_pos3 = 1;
8810 break;
8811
8812 case 4900: hash_type = HASH_TYPE_SHA1;
8813 salt_type = SALT_TYPE_INTERN;
8814 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8815 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8816 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8817 dgst_size = DGST_SIZE_4_5;
8818 parse_func = sha1s_parse_hash;
8819 sort_by_digest = sort_by_digest_4_5;
8820 opti_type = OPTI_TYPE_ZERO_BYTE
8821 | OPTI_TYPE_PRECOMPUTE_INIT
8822 | OPTI_TYPE_PRECOMPUTE_MERKLE
8823 | OPTI_TYPE_EARLY_SKIP;
8824 dgst_pos0 = 3;
8825 dgst_pos1 = 4;
8826 dgst_pos2 = 2;
8827 dgst_pos3 = 1;
8828 break;
8829
8830 case 5000: hash_type = HASH_TYPE_KECCAK;
8831 salt_type = SALT_TYPE_EMBEDDED;
8832 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8833 opts_type = OPTS_TYPE_PT_GENERATE_LE
8834 | OPTS_TYPE_PT_ADD01;
8835 kern_type = KERN_TYPE_KECCAK;
8836 dgst_size = DGST_SIZE_8_25;
8837 parse_func = keccak_parse_hash;
8838 sort_by_digest = sort_by_digest_8_25;
8839 opti_type = OPTI_TYPE_ZERO_BYTE
8840 | OPTI_TYPE_USES_BITS_64
8841 | OPTI_TYPE_RAW_HASH;
8842 dgst_pos0 = 2;
8843 dgst_pos1 = 3;
8844 dgst_pos2 = 4;
8845 dgst_pos3 = 5;
8846 break;
8847
8848 case 5100: hash_type = HASH_TYPE_MD5H;
8849 salt_type = SALT_TYPE_NONE;
8850 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8851 opts_type = OPTS_TYPE_PT_GENERATE_LE
8852 | OPTS_TYPE_PT_ADD80
8853 | OPTS_TYPE_PT_ADDBITS14;
8854 kern_type = KERN_TYPE_MD5H;
8855 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8856 parse_func = md5half_parse_hash;
8857 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8858 opti_type = OPTI_TYPE_ZERO_BYTE
8859 | OPTI_TYPE_RAW_HASH;
8860 dgst_pos0 = 0;
8861 dgst_pos1 = 1;
8862 dgst_pos2 = 2;
8863 dgst_pos3 = 3;
8864 break;
8865
8866 case 5200: hash_type = HASH_TYPE_SHA256;
8867 salt_type = SALT_TYPE_EMBEDDED;
8868 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8869 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8870 kern_type = KERN_TYPE_PSAFE3;
8871 dgst_size = DGST_SIZE_4_8;
8872 parse_func = psafe3_parse_hash;
8873 sort_by_digest = sort_by_digest_4_8;
8874 opti_type = OPTI_TYPE_ZERO_BYTE;
8875 dgst_pos0 = 0;
8876 dgst_pos1 = 1;
8877 dgst_pos2 = 2;
8878 dgst_pos3 = 3;
8879 break;
8880
8881 case 5300: hash_type = HASH_TYPE_MD5;
8882 salt_type = SALT_TYPE_EMBEDDED;
8883 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8884 opts_type = OPTS_TYPE_PT_GENERATE_LE
8885 | OPTS_TYPE_ST_ADD80;
8886 kern_type = KERN_TYPE_IKEPSK_MD5;
8887 dgst_size = DGST_SIZE_4_4;
8888 parse_func = ikepsk_md5_parse_hash;
8889 sort_by_digest = sort_by_digest_4_4;
8890 opti_type = OPTI_TYPE_ZERO_BYTE;
8891 dgst_pos0 = 0;
8892 dgst_pos1 = 3;
8893 dgst_pos2 = 2;
8894 dgst_pos3 = 1;
8895 break;
8896
8897 case 5400: hash_type = HASH_TYPE_SHA1;
8898 salt_type = SALT_TYPE_EMBEDDED;
8899 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8900 opts_type = OPTS_TYPE_PT_GENERATE_BE
8901 | OPTS_TYPE_ST_ADD80;
8902 kern_type = KERN_TYPE_IKEPSK_SHA1;
8903 dgst_size = DGST_SIZE_4_5;
8904 parse_func = ikepsk_sha1_parse_hash;
8905 sort_by_digest = sort_by_digest_4_5;
8906 opti_type = OPTI_TYPE_ZERO_BYTE;
8907 dgst_pos0 = 3;
8908 dgst_pos1 = 4;
8909 dgst_pos2 = 2;
8910 dgst_pos3 = 1;
8911 break;
8912
8913 case 5500: hash_type = HASH_TYPE_NETNTLM;
8914 salt_type = SALT_TYPE_EMBEDDED;
8915 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8916 opts_type = OPTS_TYPE_PT_GENERATE_LE
8917 | OPTS_TYPE_PT_ADD80
8918 | OPTS_TYPE_PT_ADDBITS14
8919 | OPTS_TYPE_PT_UNICODE
8920 | OPTS_TYPE_ST_HEX;
8921 kern_type = KERN_TYPE_NETNTLMv1;
8922 dgst_size = DGST_SIZE_4_4;
8923 parse_func = netntlmv1_parse_hash;
8924 sort_by_digest = sort_by_digest_4_4;
8925 opti_type = OPTI_TYPE_ZERO_BYTE
8926 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8927 dgst_pos0 = 0;
8928 dgst_pos1 = 1;
8929 dgst_pos2 = 2;
8930 dgst_pos3 = 3;
8931 break;
8932
8933 case 5600: hash_type = HASH_TYPE_MD5;
8934 salt_type = SALT_TYPE_EMBEDDED;
8935 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8936 opts_type = OPTS_TYPE_PT_GENERATE_LE
8937 | OPTS_TYPE_PT_ADD80
8938 | OPTS_TYPE_PT_ADDBITS14
8939 | OPTS_TYPE_PT_UNICODE;
8940 kern_type = KERN_TYPE_NETNTLMv2;
8941 dgst_size = DGST_SIZE_4_4;
8942 parse_func = netntlmv2_parse_hash;
8943 sort_by_digest = sort_by_digest_4_4;
8944 opti_type = OPTI_TYPE_ZERO_BYTE;
8945 dgst_pos0 = 0;
8946 dgst_pos1 = 3;
8947 dgst_pos2 = 2;
8948 dgst_pos3 = 1;
8949 break;
8950
8951 case 5700: hash_type = HASH_TYPE_SHA256;
8952 salt_type = SALT_TYPE_NONE;
8953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8954 opts_type = OPTS_TYPE_PT_GENERATE_BE
8955 | OPTS_TYPE_PT_ADD80
8956 | OPTS_TYPE_PT_ADDBITS15;
8957 kern_type = KERN_TYPE_SHA256;
8958 dgst_size = DGST_SIZE_4_8;
8959 parse_func = cisco4_parse_hash;
8960 sort_by_digest = sort_by_digest_4_8;
8961 opti_type = OPTI_TYPE_ZERO_BYTE
8962 | OPTI_TYPE_PRECOMPUTE_INIT
8963 | OPTI_TYPE_PRECOMPUTE_MERKLE
8964 | OPTI_TYPE_EARLY_SKIP
8965 | OPTI_TYPE_NOT_ITERATED
8966 | OPTI_TYPE_NOT_SALTED
8967 | OPTI_TYPE_RAW_HASH;
8968 dgst_pos0 = 3;
8969 dgst_pos1 = 7;
8970 dgst_pos2 = 2;
8971 dgst_pos3 = 6;
8972 break;
8973
8974 case 5800: hash_type = HASH_TYPE_SHA1;
8975 salt_type = SALT_TYPE_INTERN;
8976 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8977 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8978 | OPTS_TYPE_ST_ADD80;
8979 kern_type = KERN_TYPE_ANDROIDPIN;
8980 dgst_size = DGST_SIZE_4_5;
8981 parse_func = androidpin_parse_hash;
8982 sort_by_digest = sort_by_digest_4_5;
8983 opti_type = OPTI_TYPE_ZERO_BYTE;
8984 dgst_pos0 = 0;
8985 dgst_pos1 = 1;
8986 dgst_pos2 = 2;
8987 dgst_pos3 = 3;
8988 break;
8989
8990 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8991 salt_type = SALT_TYPE_NONE;
8992 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8993 opts_type = OPTS_TYPE_PT_GENERATE_LE
8994 | OPTS_TYPE_PT_ADD80;
8995 kern_type = KERN_TYPE_RIPEMD160;
8996 dgst_size = DGST_SIZE_4_5;
8997 parse_func = ripemd160_parse_hash;
8998 sort_by_digest = sort_by_digest_4_5;
8999 opti_type = OPTI_TYPE_ZERO_BYTE;
9000 dgst_pos0 = 0;
9001 dgst_pos1 = 1;
9002 dgst_pos2 = 2;
9003 dgst_pos3 = 3;
9004 break;
9005
9006 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9007 salt_type = SALT_TYPE_NONE;
9008 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9009 opts_type = OPTS_TYPE_PT_GENERATE_BE
9010 | OPTS_TYPE_PT_ADD80;
9011 kern_type = KERN_TYPE_WHIRLPOOL;
9012 dgst_size = DGST_SIZE_4_16;
9013 parse_func = whirlpool_parse_hash;
9014 sort_by_digest = sort_by_digest_4_16;
9015 opti_type = OPTI_TYPE_ZERO_BYTE;
9016 dgst_pos0 = 0;
9017 dgst_pos1 = 1;
9018 dgst_pos2 = 2;
9019 dgst_pos3 = 3;
9020 break;
9021
9022 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9023 salt_type = SALT_TYPE_EMBEDDED;
9024 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9025 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9026 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9027 dgst_size = DGST_SIZE_4_5;
9028 parse_func = truecrypt_parse_hash_2k;
9029 sort_by_digest = sort_by_digest_4_5;
9030 opti_type = OPTI_TYPE_ZERO_BYTE;
9031 dgst_pos0 = 0;
9032 dgst_pos1 = 1;
9033 dgst_pos2 = 2;
9034 dgst_pos3 = 3;
9035 break;
9036
9037 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9038 salt_type = SALT_TYPE_EMBEDDED;
9039 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9040 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9041 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9042 dgst_size = DGST_SIZE_4_5;
9043 parse_func = truecrypt_parse_hash_2k;
9044 sort_by_digest = sort_by_digest_4_5;
9045 opti_type = OPTI_TYPE_ZERO_BYTE;
9046 dgst_pos0 = 0;
9047 dgst_pos1 = 1;
9048 dgst_pos2 = 2;
9049 dgst_pos3 = 3;
9050 break;
9051
9052 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9053 salt_type = SALT_TYPE_EMBEDDED;
9054 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9055 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9056 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9057 dgst_size = DGST_SIZE_4_5;
9058 parse_func = truecrypt_parse_hash_2k;
9059 sort_by_digest = sort_by_digest_4_5;
9060 opti_type = OPTI_TYPE_ZERO_BYTE;
9061 dgst_pos0 = 0;
9062 dgst_pos1 = 1;
9063 dgst_pos2 = 2;
9064 dgst_pos3 = 3;
9065 break;
9066
9067 case 6221: hash_type = HASH_TYPE_SHA512;
9068 salt_type = SALT_TYPE_EMBEDDED;
9069 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9070 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9071 kern_type = KERN_TYPE_TCSHA512_XTS512;
9072 dgst_size = DGST_SIZE_8_8;
9073 parse_func = truecrypt_parse_hash_1k;
9074 sort_by_digest = sort_by_digest_8_8;
9075 opti_type = OPTI_TYPE_ZERO_BYTE
9076 | OPTI_TYPE_USES_BITS_64;
9077 dgst_pos0 = 0;
9078 dgst_pos1 = 1;
9079 dgst_pos2 = 2;
9080 dgst_pos3 = 3;
9081 break;
9082
9083 case 6222: hash_type = HASH_TYPE_SHA512;
9084 salt_type = SALT_TYPE_EMBEDDED;
9085 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9086 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9087 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9088 dgst_size = DGST_SIZE_8_8;
9089 parse_func = truecrypt_parse_hash_1k;
9090 sort_by_digest = sort_by_digest_8_8;
9091 opti_type = OPTI_TYPE_ZERO_BYTE
9092 | OPTI_TYPE_USES_BITS_64;
9093 dgst_pos0 = 0;
9094 dgst_pos1 = 1;
9095 dgst_pos2 = 2;
9096 dgst_pos3 = 3;
9097 break;
9098
9099 case 6223: hash_type = HASH_TYPE_SHA512;
9100 salt_type = SALT_TYPE_EMBEDDED;
9101 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9102 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9103 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9104 dgst_size = DGST_SIZE_8_8;
9105 parse_func = truecrypt_parse_hash_1k;
9106 sort_by_digest = sort_by_digest_8_8;
9107 opti_type = OPTI_TYPE_ZERO_BYTE
9108 | OPTI_TYPE_USES_BITS_64;
9109 dgst_pos0 = 0;
9110 dgst_pos1 = 1;
9111 dgst_pos2 = 2;
9112 dgst_pos3 = 3;
9113 break;
9114
9115 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9116 salt_type = SALT_TYPE_EMBEDDED;
9117 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9118 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9119 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9120 dgst_size = DGST_SIZE_4_8;
9121 parse_func = truecrypt_parse_hash_1k;
9122 sort_by_digest = sort_by_digest_4_8;
9123 opti_type = OPTI_TYPE_ZERO_BYTE;
9124 dgst_pos0 = 0;
9125 dgst_pos1 = 1;
9126 dgst_pos2 = 2;
9127 dgst_pos3 = 3;
9128 break;
9129
9130 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9131 salt_type = SALT_TYPE_EMBEDDED;
9132 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9133 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9134 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9135 dgst_size = DGST_SIZE_4_8;
9136 parse_func = truecrypt_parse_hash_1k;
9137 sort_by_digest = sort_by_digest_4_8;
9138 opti_type = OPTI_TYPE_ZERO_BYTE;
9139 dgst_pos0 = 0;
9140 dgst_pos1 = 1;
9141 dgst_pos2 = 2;
9142 dgst_pos3 = 3;
9143 break;
9144
9145 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9146 salt_type = SALT_TYPE_EMBEDDED;
9147 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9148 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9149 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9150 dgst_size = DGST_SIZE_4_8;
9151 parse_func = truecrypt_parse_hash_1k;
9152 sort_by_digest = sort_by_digest_4_8;
9153 opti_type = OPTI_TYPE_ZERO_BYTE;
9154 dgst_pos0 = 0;
9155 dgst_pos1 = 1;
9156 dgst_pos2 = 2;
9157 dgst_pos3 = 3;
9158 break;
9159
9160 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9161 salt_type = SALT_TYPE_EMBEDDED;
9162 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9163 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9164 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9165 dgst_size = DGST_SIZE_4_5;
9166 parse_func = truecrypt_parse_hash_1k;
9167 sort_by_digest = sort_by_digest_4_5;
9168 opti_type = OPTI_TYPE_ZERO_BYTE;
9169 dgst_pos0 = 0;
9170 dgst_pos1 = 1;
9171 dgst_pos2 = 2;
9172 dgst_pos3 = 3;
9173 break;
9174
9175 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9176 salt_type = SALT_TYPE_EMBEDDED;
9177 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9178 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9179 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9180 dgst_size = DGST_SIZE_4_5;
9181 parse_func = truecrypt_parse_hash_1k;
9182 sort_by_digest = sort_by_digest_4_5;
9183 opti_type = OPTI_TYPE_ZERO_BYTE;
9184 dgst_pos0 = 0;
9185 dgst_pos1 = 1;
9186 dgst_pos2 = 2;
9187 dgst_pos3 = 3;
9188 break;
9189
9190 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9191 salt_type = SALT_TYPE_EMBEDDED;
9192 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9193 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9194 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9195 dgst_size = DGST_SIZE_4_5;
9196 parse_func = truecrypt_parse_hash_1k;
9197 sort_by_digest = sort_by_digest_4_5;
9198 opti_type = OPTI_TYPE_ZERO_BYTE;
9199 dgst_pos0 = 0;
9200 dgst_pos1 = 1;
9201 dgst_pos2 = 2;
9202 dgst_pos3 = 3;
9203 break;
9204
9205 case 6300: hash_type = HASH_TYPE_MD5;
9206 salt_type = SALT_TYPE_EMBEDDED;
9207 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9208 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9209 kern_type = KERN_TYPE_MD5AIX;
9210 dgst_size = DGST_SIZE_4_4;
9211 parse_func = md5aix_parse_hash;
9212 sort_by_digest = sort_by_digest_4_4;
9213 opti_type = OPTI_TYPE_ZERO_BYTE;
9214 dgst_pos0 = 0;
9215 dgst_pos1 = 1;
9216 dgst_pos2 = 2;
9217 dgst_pos3 = 3;
9218 break;
9219
9220 case 6400: hash_type = HASH_TYPE_SHA256;
9221 salt_type = SALT_TYPE_EMBEDDED;
9222 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9223 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9224 kern_type = KERN_TYPE_SHA256AIX;
9225 dgst_size = DGST_SIZE_4_8;
9226 parse_func = sha256aix_parse_hash;
9227 sort_by_digest = sort_by_digest_4_8;
9228 opti_type = OPTI_TYPE_ZERO_BYTE;
9229 dgst_pos0 = 0;
9230 dgst_pos1 = 1;
9231 dgst_pos2 = 2;
9232 dgst_pos3 = 3;
9233 break;
9234
9235 case 6500: hash_type = HASH_TYPE_SHA512;
9236 salt_type = SALT_TYPE_EMBEDDED;
9237 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9238 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9239 kern_type = KERN_TYPE_SHA512AIX;
9240 dgst_size = DGST_SIZE_8_8;
9241 parse_func = sha512aix_parse_hash;
9242 sort_by_digest = sort_by_digest_8_8;
9243 opti_type = OPTI_TYPE_ZERO_BYTE
9244 | OPTI_TYPE_USES_BITS_64;
9245 dgst_pos0 = 0;
9246 dgst_pos1 = 1;
9247 dgst_pos2 = 2;
9248 dgst_pos3 = 3;
9249 break;
9250
9251 case 6600: hash_type = HASH_TYPE_AES;
9252 salt_type = SALT_TYPE_EMBEDDED;
9253 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9254 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9255 kern_type = KERN_TYPE_AGILEKEY;
9256 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9257 parse_func = agilekey_parse_hash;
9258 sort_by_digest = sort_by_digest_4_5;
9259 opti_type = OPTI_TYPE_ZERO_BYTE;
9260 dgst_pos0 = 0;
9261 dgst_pos1 = 1;
9262 dgst_pos2 = 2;
9263 dgst_pos3 = 3;
9264 break;
9265
9266 case 6700: hash_type = HASH_TYPE_SHA1;
9267 salt_type = SALT_TYPE_EMBEDDED;
9268 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9269 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9270 kern_type = KERN_TYPE_SHA1AIX;
9271 dgst_size = DGST_SIZE_4_5;
9272 parse_func = sha1aix_parse_hash;
9273 sort_by_digest = sort_by_digest_4_5;
9274 opti_type = OPTI_TYPE_ZERO_BYTE;
9275 dgst_pos0 = 0;
9276 dgst_pos1 = 1;
9277 dgst_pos2 = 2;
9278 dgst_pos3 = 3;
9279 break;
9280
9281 case 6800: hash_type = HASH_TYPE_AES;
9282 salt_type = SALT_TYPE_EMBEDDED;
9283 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9284 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9285 kern_type = KERN_TYPE_LASTPASS;
9286 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9287 parse_func = lastpass_parse_hash;
9288 sort_by_digest = sort_by_digest_4_8;
9289 opti_type = OPTI_TYPE_ZERO_BYTE;
9290 dgst_pos0 = 0;
9291 dgst_pos1 = 1;
9292 dgst_pos2 = 2;
9293 dgst_pos3 = 3;
9294 break;
9295
9296 case 6900: hash_type = HASH_TYPE_GOST;
9297 salt_type = SALT_TYPE_NONE;
9298 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9299 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9300 kern_type = KERN_TYPE_GOST;
9301 dgst_size = DGST_SIZE_4_8;
9302 parse_func = gost_parse_hash;
9303 sort_by_digest = sort_by_digest_4_8;
9304 opti_type = OPTI_TYPE_ZERO_BYTE;
9305 dgst_pos0 = 0;
9306 dgst_pos1 = 1;
9307 dgst_pos2 = 2;
9308 dgst_pos3 = 3;
9309 break;
9310
9311 case 7100: hash_type = HASH_TYPE_SHA512;
9312 salt_type = SALT_TYPE_EMBEDDED;
9313 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9314 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9315 kern_type = KERN_TYPE_PBKDF2_SHA512;
9316 dgst_size = DGST_SIZE_8_16;
9317 parse_func = sha512osx_parse_hash;
9318 sort_by_digest = sort_by_digest_8_16;
9319 opti_type = OPTI_TYPE_ZERO_BYTE
9320 | OPTI_TYPE_USES_BITS_64
9321 | OPTI_TYPE_SLOW_HASH_SIMD;
9322 dgst_pos0 = 0;
9323 dgst_pos1 = 1;
9324 dgst_pos2 = 2;
9325 dgst_pos3 = 3;
9326 break;
9327
9328 case 7200: hash_type = HASH_TYPE_SHA512;
9329 salt_type = SALT_TYPE_EMBEDDED;
9330 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9331 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9332 kern_type = KERN_TYPE_PBKDF2_SHA512;
9333 dgst_size = DGST_SIZE_8_16;
9334 parse_func = sha512grub_parse_hash;
9335 sort_by_digest = sort_by_digest_8_16;
9336 opti_type = OPTI_TYPE_ZERO_BYTE
9337 | OPTI_TYPE_USES_BITS_64
9338 | OPTI_TYPE_SLOW_HASH_SIMD;
9339 dgst_pos0 = 0;
9340 dgst_pos1 = 1;
9341 dgst_pos2 = 2;
9342 dgst_pos3 = 3;
9343 break;
9344
9345 case 7300: hash_type = HASH_TYPE_SHA1;
9346 salt_type = SALT_TYPE_EMBEDDED;
9347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9348 opts_type = OPTS_TYPE_PT_GENERATE_BE
9349 | OPTS_TYPE_ST_ADD80
9350 | OPTS_TYPE_ST_ADDBITS15;
9351 kern_type = KERN_TYPE_RAKP;
9352 dgst_size = DGST_SIZE_4_5;
9353 parse_func = rakp_parse_hash;
9354 sort_by_digest = sort_by_digest_4_5;
9355 opti_type = OPTI_TYPE_ZERO_BYTE
9356 | OPTI_TYPE_NOT_ITERATED;
9357 dgst_pos0 = 3;
9358 dgst_pos1 = 4;
9359 dgst_pos2 = 2;
9360 dgst_pos3 = 1;
9361 break;
9362
9363 case 7400: hash_type = HASH_TYPE_SHA256;
9364 salt_type = SALT_TYPE_EMBEDDED;
9365 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9366 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9367 kern_type = KERN_TYPE_SHA256CRYPT;
9368 dgst_size = DGST_SIZE_4_8;
9369 parse_func = sha256crypt_parse_hash;
9370 sort_by_digest = sort_by_digest_4_8;
9371 opti_type = OPTI_TYPE_ZERO_BYTE;
9372 dgst_pos0 = 0;
9373 dgst_pos1 = 1;
9374 dgst_pos2 = 2;
9375 dgst_pos3 = 3;
9376 break;
9377
9378 case 7500: hash_type = HASH_TYPE_KRB5PA;
9379 salt_type = SALT_TYPE_EMBEDDED;
9380 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9381 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9382 kern_type = KERN_TYPE_KRB5PA;
9383 dgst_size = DGST_SIZE_4_4;
9384 parse_func = krb5pa_parse_hash;
9385 sort_by_digest = sort_by_digest_4_4;
9386 opti_type = OPTI_TYPE_ZERO_BYTE
9387 | OPTI_TYPE_NOT_ITERATED;
9388 dgst_pos0 = 0;
9389 dgst_pos1 = 1;
9390 dgst_pos2 = 2;
9391 dgst_pos3 = 3;
9392 break;
9393
9394 case 7600: hash_type = HASH_TYPE_SHA1;
9395 salt_type = SALT_TYPE_INTERN;
9396 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9397 opts_type = OPTS_TYPE_PT_GENERATE_BE
9398 | OPTS_TYPE_PT_ADD80
9399 | OPTS_TYPE_PT_ADDBITS15;
9400 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9401 dgst_size = DGST_SIZE_4_5;
9402 parse_func = redmine_parse_hash;
9403 sort_by_digest = sort_by_digest_4_5;
9404 opti_type = OPTI_TYPE_ZERO_BYTE
9405 | OPTI_TYPE_PRECOMPUTE_INIT
9406 | OPTI_TYPE_EARLY_SKIP
9407 | OPTI_TYPE_NOT_ITERATED
9408 | OPTI_TYPE_PREPENDED_SALT;
9409 dgst_pos0 = 3;
9410 dgst_pos1 = 4;
9411 dgst_pos2 = 2;
9412 dgst_pos3 = 1;
9413 break;
9414
9415 case 7700: hash_type = HASH_TYPE_SAPB;
9416 salt_type = SALT_TYPE_EMBEDDED;
9417 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9418 opts_type = OPTS_TYPE_PT_GENERATE_LE
9419 | OPTS_TYPE_PT_UPPER
9420 | OPTS_TYPE_ST_UPPER;
9421 kern_type = KERN_TYPE_SAPB;
9422 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9423 parse_func = sapb_parse_hash;
9424 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9425 opti_type = OPTI_TYPE_ZERO_BYTE
9426 | OPTI_TYPE_PRECOMPUTE_INIT
9427 | OPTI_TYPE_NOT_ITERATED;
9428 dgst_pos0 = 0;
9429 dgst_pos1 = 1;
9430 dgst_pos2 = 2;
9431 dgst_pos3 = 3;
9432 break;
9433
9434 case 7800: hash_type = HASH_TYPE_SAPG;
9435 salt_type = SALT_TYPE_EMBEDDED;
9436 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9437 opts_type = OPTS_TYPE_PT_GENERATE_BE
9438 | OPTS_TYPE_ST_ADD80
9439 | OPTS_TYPE_ST_UPPER;
9440 kern_type = KERN_TYPE_SAPG;
9441 dgst_size = DGST_SIZE_4_5;
9442 parse_func = sapg_parse_hash;
9443 sort_by_digest = sort_by_digest_4_5;
9444 opti_type = OPTI_TYPE_ZERO_BYTE
9445 | OPTI_TYPE_PRECOMPUTE_INIT
9446 | OPTI_TYPE_NOT_ITERATED;
9447 dgst_pos0 = 3;
9448 dgst_pos1 = 4;
9449 dgst_pos2 = 2;
9450 dgst_pos3 = 1;
9451 break;
9452
9453 case 7900: hash_type = HASH_TYPE_SHA512;
9454 salt_type = SALT_TYPE_EMBEDDED;
9455 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9456 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9457 kern_type = KERN_TYPE_DRUPAL7;
9458 dgst_size = DGST_SIZE_8_8;
9459 parse_func = drupal7_parse_hash;
9460 sort_by_digest = sort_by_digest_8_8;
9461 opti_type = OPTI_TYPE_ZERO_BYTE
9462 | OPTI_TYPE_USES_BITS_64;
9463 dgst_pos0 = 0;
9464 dgst_pos1 = 1;
9465 dgst_pos2 = 2;
9466 dgst_pos3 = 3;
9467 break;
9468
9469 case 8000: hash_type = HASH_TYPE_SHA256;
9470 salt_type = SALT_TYPE_EMBEDDED;
9471 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9472 opts_type = OPTS_TYPE_PT_GENERATE_BE
9473 | OPTS_TYPE_PT_UNICODE
9474 | OPTS_TYPE_ST_ADD80
9475 | OPTS_TYPE_ST_HEX;
9476 kern_type = KERN_TYPE_SYBASEASE;
9477 dgst_size = DGST_SIZE_4_8;
9478 parse_func = sybasease_parse_hash;
9479 sort_by_digest = sort_by_digest_4_8;
9480 opti_type = OPTI_TYPE_ZERO_BYTE
9481 | OPTI_TYPE_PRECOMPUTE_INIT
9482 | OPTI_TYPE_EARLY_SKIP
9483 | OPTI_TYPE_NOT_ITERATED
9484 | OPTI_TYPE_RAW_HASH;
9485 dgst_pos0 = 3;
9486 dgst_pos1 = 7;
9487 dgst_pos2 = 2;
9488 dgst_pos3 = 6;
9489 break;
9490
9491 case 8100: hash_type = HASH_TYPE_SHA1;
9492 salt_type = SALT_TYPE_EMBEDDED;
9493 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9494 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9495 kern_type = KERN_TYPE_NETSCALER;
9496 dgst_size = DGST_SIZE_4_5;
9497 parse_func = netscaler_parse_hash;
9498 sort_by_digest = sort_by_digest_4_5;
9499 opti_type = OPTI_TYPE_ZERO_BYTE
9500 | OPTI_TYPE_PRECOMPUTE_INIT
9501 | OPTI_TYPE_PRECOMPUTE_MERKLE
9502 | OPTI_TYPE_EARLY_SKIP
9503 | OPTI_TYPE_NOT_ITERATED
9504 | OPTI_TYPE_PREPENDED_SALT
9505 | OPTI_TYPE_RAW_HASH;
9506 dgst_pos0 = 3;
9507 dgst_pos1 = 4;
9508 dgst_pos2 = 2;
9509 dgst_pos3 = 1;
9510 break;
9511
9512 case 8200: hash_type = HASH_TYPE_SHA256;
9513 salt_type = SALT_TYPE_EMBEDDED;
9514 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9515 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9516 kern_type = KERN_TYPE_CLOUDKEY;
9517 dgst_size = DGST_SIZE_4_8;
9518 parse_func = cloudkey_parse_hash;
9519 sort_by_digest = sort_by_digest_4_8;
9520 opti_type = OPTI_TYPE_ZERO_BYTE;
9521 dgst_pos0 = 0;
9522 dgst_pos1 = 1;
9523 dgst_pos2 = 2;
9524 dgst_pos3 = 3;
9525 break;
9526
9527 case 8300: hash_type = HASH_TYPE_SHA1;
9528 salt_type = SALT_TYPE_EMBEDDED;
9529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9530 opts_type = OPTS_TYPE_PT_GENERATE_BE
9531 | OPTS_TYPE_ST_HEX
9532 | OPTS_TYPE_ST_ADD80;
9533 kern_type = KERN_TYPE_NSEC3;
9534 dgst_size = DGST_SIZE_4_5;
9535 parse_func = nsec3_parse_hash;
9536 sort_by_digest = sort_by_digest_4_5;
9537 opti_type = OPTI_TYPE_ZERO_BYTE;
9538 dgst_pos0 = 3;
9539 dgst_pos1 = 4;
9540 dgst_pos2 = 2;
9541 dgst_pos3 = 1;
9542 break;
9543
9544 case 8400: hash_type = HASH_TYPE_SHA1;
9545 salt_type = SALT_TYPE_INTERN;
9546 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9547 opts_type = OPTS_TYPE_PT_GENERATE_BE
9548 | OPTS_TYPE_PT_ADD80
9549 | OPTS_TYPE_PT_ADDBITS15;
9550 kern_type = KERN_TYPE_WBB3;
9551 dgst_size = DGST_SIZE_4_5;
9552 parse_func = wbb3_parse_hash;
9553 sort_by_digest = sort_by_digest_4_5;
9554 opti_type = OPTI_TYPE_ZERO_BYTE
9555 | OPTI_TYPE_PRECOMPUTE_INIT
9556 | OPTI_TYPE_NOT_ITERATED;
9557 dgst_pos0 = 3;
9558 dgst_pos1 = 4;
9559 dgst_pos2 = 2;
9560 dgst_pos3 = 1;
9561 break;
9562
9563 case 8500: hash_type = HASH_TYPE_DESRACF;
9564 salt_type = SALT_TYPE_EMBEDDED;
9565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9566 opts_type = OPTS_TYPE_PT_GENERATE_LE
9567 | OPTS_TYPE_ST_UPPER;
9568 kern_type = KERN_TYPE_RACF;
9569 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9570 parse_func = racf_parse_hash;
9571 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9572 opti_type = OPTI_TYPE_ZERO_BYTE
9573 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9574 dgst_pos0 = 0;
9575 dgst_pos1 = 1;
9576 dgst_pos2 = 2;
9577 dgst_pos3 = 3;
9578 break;
9579
9580 case 8600: hash_type = HASH_TYPE_LOTUS5;
9581 salt_type = SALT_TYPE_NONE;
9582 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9583 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9584 kern_type = KERN_TYPE_LOTUS5;
9585 dgst_size = DGST_SIZE_4_4;
9586 parse_func = lotus5_parse_hash;
9587 sort_by_digest = sort_by_digest_4_4;
9588 opti_type = OPTI_TYPE_EARLY_SKIP
9589 | OPTI_TYPE_NOT_ITERATED
9590 | OPTI_TYPE_NOT_SALTED
9591 | OPTI_TYPE_RAW_HASH;
9592 dgst_pos0 = 0;
9593 dgst_pos1 = 1;
9594 dgst_pos2 = 2;
9595 dgst_pos3 = 3;
9596 break;
9597
9598 case 8700: hash_type = HASH_TYPE_LOTUS6;
9599 salt_type = SALT_TYPE_EMBEDDED;
9600 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9601 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9602 kern_type = KERN_TYPE_LOTUS6;
9603 dgst_size = DGST_SIZE_4_4;
9604 parse_func = lotus6_parse_hash;
9605 sort_by_digest = sort_by_digest_4_4;
9606 opti_type = OPTI_TYPE_EARLY_SKIP
9607 | OPTI_TYPE_NOT_ITERATED
9608 | OPTI_TYPE_RAW_HASH;
9609 dgst_pos0 = 0;
9610 dgst_pos1 = 1;
9611 dgst_pos2 = 2;
9612 dgst_pos3 = 3;
9613 break;
9614
9615 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9616 salt_type = SALT_TYPE_EMBEDDED;
9617 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9618 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9619 kern_type = KERN_TYPE_ANDROIDFDE;
9620 dgst_size = DGST_SIZE_4_4;
9621 parse_func = androidfde_parse_hash;
9622 sort_by_digest = sort_by_digest_4_4;
9623 opti_type = OPTI_TYPE_ZERO_BYTE;
9624 dgst_pos0 = 0;
9625 dgst_pos1 = 1;
9626 dgst_pos2 = 2;
9627 dgst_pos3 = 3;
9628 break;
9629
9630 case 8900: hash_type = HASH_TYPE_SCRYPT;
9631 salt_type = SALT_TYPE_EMBEDDED;
9632 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9633 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9634 kern_type = KERN_TYPE_SCRYPT;
9635 dgst_size = DGST_SIZE_4_8;
9636 parse_func = scrypt_parse_hash;
9637 sort_by_digest = sort_by_digest_4_8;
9638 opti_type = OPTI_TYPE_ZERO_BYTE;
9639 dgst_pos0 = 0;
9640 dgst_pos1 = 1;
9641 dgst_pos2 = 2;
9642 dgst_pos3 = 3;
9643 break;
9644
9645 case 9000: hash_type = HASH_TYPE_SHA1;
9646 salt_type = SALT_TYPE_EMBEDDED;
9647 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9648 opts_type = OPTS_TYPE_PT_GENERATE_LE
9649 | OPTS_TYPE_ST_GENERATE_LE;
9650 kern_type = KERN_TYPE_PSAFE2;
9651 dgst_size = DGST_SIZE_4_5;
9652 parse_func = psafe2_parse_hash;
9653 sort_by_digest = sort_by_digest_4_5;
9654 opti_type = OPTI_TYPE_ZERO_BYTE;
9655 dgst_pos0 = 0;
9656 dgst_pos1 = 1;
9657 dgst_pos2 = 2;
9658 dgst_pos3 = 3;
9659 break;
9660
9661 case 9100: hash_type = HASH_TYPE_LOTUS8;
9662 salt_type = SALT_TYPE_EMBEDDED;
9663 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9664 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9665 kern_type = KERN_TYPE_LOTUS8;
9666 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9667 parse_func = lotus8_parse_hash;
9668 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9669 opti_type = OPTI_TYPE_ZERO_BYTE;
9670 dgst_pos0 = 0;
9671 dgst_pos1 = 1;
9672 dgst_pos2 = 2;
9673 dgst_pos3 = 3;
9674 break;
9675
9676 case 9200: hash_type = HASH_TYPE_SHA256;
9677 salt_type = SALT_TYPE_EMBEDDED;
9678 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9679 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9680 kern_type = KERN_TYPE_PBKDF2_SHA256;
9681 dgst_size = DGST_SIZE_4_32;
9682 parse_func = cisco8_parse_hash;
9683 sort_by_digest = sort_by_digest_4_32;
9684 opti_type = OPTI_TYPE_ZERO_BYTE
9685 | OPTI_TYPE_SLOW_HASH_SIMD;
9686 dgst_pos0 = 0;
9687 dgst_pos1 = 1;
9688 dgst_pos2 = 2;
9689 dgst_pos3 = 3;
9690 break;
9691
9692 case 9300: hash_type = HASH_TYPE_SCRYPT;
9693 salt_type = SALT_TYPE_EMBEDDED;
9694 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9695 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9696 kern_type = KERN_TYPE_SCRYPT;
9697 dgst_size = DGST_SIZE_4_8;
9698 parse_func = cisco9_parse_hash;
9699 sort_by_digest = sort_by_digest_4_8;
9700 opti_type = OPTI_TYPE_ZERO_BYTE;
9701 dgst_pos0 = 0;
9702 dgst_pos1 = 1;
9703 dgst_pos2 = 2;
9704 dgst_pos3 = 3;
9705 break;
9706
9707 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9708 salt_type = SALT_TYPE_EMBEDDED;
9709 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9710 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9711 kern_type = KERN_TYPE_OFFICE2007;
9712 dgst_size = DGST_SIZE_4_4;
9713 parse_func = office2007_parse_hash;
9714 sort_by_digest = sort_by_digest_4_4;
9715 opti_type = OPTI_TYPE_ZERO_BYTE;
9716 dgst_pos0 = 0;
9717 dgst_pos1 = 1;
9718 dgst_pos2 = 2;
9719 dgst_pos3 = 3;
9720 break;
9721
9722 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9723 salt_type = SALT_TYPE_EMBEDDED;
9724 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9725 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9726 kern_type = KERN_TYPE_OFFICE2010;
9727 dgst_size = DGST_SIZE_4_4;
9728 parse_func = office2010_parse_hash;
9729 sort_by_digest = sort_by_digest_4_4;
9730 opti_type = OPTI_TYPE_ZERO_BYTE;
9731 dgst_pos0 = 0;
9732 dgst_pos1 = 1;
9733 dgst_pos2 = 2;
9734 dgst_pos3 = 3;
9735 break;
9736
9737 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9738 salt_type = SALT_TYPE_EMBEDDED;
9739 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9740 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9741 kern_type = KERN_TYPE_OFFICE2013;
9742 dgst_size = DGST_SIZE_4_4;
9743 parse_func = office2013_parse_hash;
9744 sort_by_digest = sort_by_digest_4_4;
9745 opti_type = OPTI_TYPE_ZERO_BYTE;
9746 dgst_pos0 = 0;
9747 dgst_pos1 = 1;
9748 dgst_pos2 = 2;
9749 dgst_pos3 = 3;
9750 break;
9751
9752 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9753 salt_type = SALT_TYPE_EMBEDDED;
9754 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9755 opts_type = OPTS_TYPE_PT_GENERATE_LE
9756 | OPTS_TYPE_PT_ADD80
9757 | OPTS_TYPE_PT_UNICODE;
9758 kern_type = KERN_TYPE_OLDOFFICE01;
9759 dgst_size = DGST_SIZE_4_4;
9760 parse_func = oldoffice01_parse_hash;
9761 sort_by_digest = sort_by_digest_4_4;
9762 opti_type = OPTI_TYPE_ZERO_BYTE
9763 | OPTI_TYPE_PRECOMPUTE_INIT
9764 | OPTI_TYPE_NOT_ITERATED;
9765 dgst_pos0 = 0;
9766 dgst_pos1 = 1;
9767 dgst_pos2 = 2;
9768 dgst_pos3 = 3;
9769 break;
9770
9771 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9772 salt_type = SALT_TYPE_EMBEDDED;
9773 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9774 opts_type = OPTS_TYPE_PT_GENERATE_LE
9775 | OPTS_TYPE_PT_ADD80;
9776 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9777 dgst_size = DGST_SIZE_4_4;
9778 parse_func = oldoffice01cm1_parse_hash;
9779 sort_by_digest = sort_by_digest_4_4;
9780 opti_type = OPTI_TYPE_ZERO_BYTE
9781 | OPTI_TYPE_PRECOMPUTE_INIT
9782 | OPTI_TYPE_NOT_ITERATED;
9783 dgst_pos0 = 0;
9784 dgst_pos1 = 1;
9785 dgst_pos2 = 2;
9786 dgst_pos3 = 3;
9787 break;
9788
9789 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9790 salt_type = SALT_TYPE_EMBEDDED;
9791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9792 opts_type = OPTS_TYPE_PT_GENERATE_LE
9793 | OPTS_TYPE_PT_ADD80
9794 | OPTS_TYPE_PT_UNICODE
9795 | OPTS_TYPE_PT_NEVERCRACK;
9796 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9797 dgst_size = DGST_SIZE_4_4;
9798 parse_func = oldoffice01cm2_parse_hash;
9799 sort_by_digest = sort_by_digest_4_4;
9800 opti_type = OPTI_TYPE_ZERO_BYTE
9801 | OPTI_TYPE_PRECOMPUTE_INIT
9802 | OPTI_TYPE_NOT_ITERATED;
9803 dgst_pos0 = 0;
9804 dgst_pos1 = 1;
9805 dgst_pos2 = 2;
9806 dgst_pos3 = 3;
9807 break;
9808
9809 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9810 salt_type = SALT_TYPE_EMBEDDED;
9811 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9812 opts_type = OPTS_TYPE_PT_GENERATE_BE
9813 | OPTS_TYPE_PT_ADD80
9814 | OPTS_TYPE_PT_UNICODE;
9815 kern_type = KERN_TYPE_OLDOFFICE34;
9816 dgst_size = DGST_SIZE_4_4;
9817 parse_func = oldoffice34_parse_hash;
9818 sort_by_digest = sort_by_digest_4_4;
9819 opti_type = OPTI_TYPE_ZERO_BYTE
9820 | OPTI_TYPE_PRECOMPUTE_INIT
9821 | OPTI_TYPE_NOT_ITERATED;
9822 dgst_pos0 = 0;
9823 dgst_pos1 = 1;
9824 dgst_pos2 = 2;
9825 dgst_pos3 = 3;
9826 break;
9827
9828 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9829 salt_type = SALT_TYPE_EMBEDDED;
9830 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9831 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9832 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9833 dgst_size = DGST_SIZE_4_4;
9834 parse_func = oldoffice34cm1_parse_hash;
9835 sort_by_digest = sort_by_digest_4_4;
9836 opti_type = OPTI_TYPE_ZERO_BYTE
9837 | OPTI_TYPE_PRECOMPUTE_INIT
9838 | OPTI_TYPE_NOT_ITERATED;
9839 dgst_pos0 = 0;
9840 dgst_pos1 = 1;
9841 dgst_pos2 = 2;
9842 dgst_pos3 = 3;
9843 break;
9844
9845 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9846 salt_type = SALT_TYPE_EMBEDDED;
9847 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9848 opts_type = OPTS_TYPE_PT_GENERATE_BE
9849 | OPTS_TYPE_PT_ADD80
9850 | OPTS_TYPE_PT_UNICODE
9851 | OPTS_TYPE_PT_NEVERCRACK;
9852 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9853 dgst_size = DGST_SIZE_4_4;
9854 parse_func = oldoffice34cm2_parse_hash;
9855 sort_by_digest = sort_by_digest_4_4;
9856 opti_type = OPTI_TYPE_ZERO_BYTE
9857 | OPTI_TYPE_PRECOMPUTE_INIT
9858 | OPTI_TYPE_NOT_ITERATED;
9859 dgst_pos0 = 0;
9860 dgst_pos1 = 1;
9861 dgst_pos2 = 2;
9862 dgst_pos3 = 3;
9863 break;
9864
9865 case 9900: hash_type = HASH_TYPE_MD5;
9866 salt_type = SALT_TYPE_NONE;
9867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9868 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9869 kern_type = KERN_TYPE_RADMIN2;
9870 dgst_size = DGST_SIZE_4_4;
9871 parse_func = radmin2_parse_hash;
9872 sort_by_digest = sort_by_digest_4_4;
9873 opti_type = OPTI_TYPE_ZERO_BYTE
9874 | OPTI_TYPE_PRECOMPUTE_INIT
9875 | OPTI_TYPE_EARLY_SKIP
9876 | OPTI_TYPE_NOT_ITERATED
9877 | OPTI_TYPE_NOT_SALTED;
9878 dgst_pos0 = 0;
9879 dgst_pos1 = 3;
9880 dgst_pos2 = 2;
9881 dgst_pos3 = 1;
9882 break;
9883
9884 case 10000: hash_type = HASH_TYPE_SHA256;
9885 salt_type = SALT_TYPE_EMBEDDED;
9886 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9887 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9888 kern_type = KERN_TYPE_PBKDF2_SHA256;
9889 dgst_size = DGST_SIZE_4_32;
9890 parse_func = djangopbkdf2_parse_hash;
9891 sort_by_digest = sort_by_digest_4_32;
9892 opti_type = OPTI_TYPE_ZERO_BYTE
9893 | OPTI_TYPE_SLOW_HASH_SIMD;
9894 dgst_pos0 = 0;
9895 dgst_pos1 = 1;
9896 dgst_pos2 = 2;
9897 dgst_pos3 = 3;
9898 break;
9899
9900 case 10100: hash_type = HASH_TYPE_SIPHASH;
9901 salt_type = SALT_TYPE_EMBEDDED;
9902 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9903 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9904 kern_type = KERN_TYPE_SIPHASH;
9905 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9906 parse_func = siphash_parse_hash;
9907 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9908 opti_type = OPTI_TYPE_ZERO_BYTE
9909 | OPTI_TYPE_NOT_ITERATED
9910 | OPTI_TYPE_RAW_HASH;
9911 dgst_pos0 = 0;
9912 dgst_pos1 = 1;
9913 dgst_pos2 = 2;
9914 dgst_pos3 = 3;
9915 break;
9916
9917 case 10200: hash_type = HASH_TYPE_MD5;
9918 salt_type = SALT_TYPE_EMBEDDED;
9919 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9920 opts_type = OPTS_TYPE_PT_GENERATE_LE
9921 | OPTS_TYPE_ST_ADD80
9922 | OPTS_TYPE_ST_ADDBITS14;
9923 kern_type = KERN_TYPE_HMACMD5_PW;
9924 dgst_size = DGST_SIZE_4_4;
9925 parse_func = crammd5_parse_hash;
9926 sort_by_digest = sort_by_digest_4_4;
9927 opti_type = OPTI_TYPE_ZERO_BYTE
9928 | OPTI_TYPE_NOT_ITERATED;
9929 dgst_pos0 = 0;
9930 dgst_pos1 = 3;
9931 dgst_pos2 = 2;
9932 dgst_pos3 = 1;
9933 break;
9934
9935 case 10300: hash_type = HASH_TYPE_SHA1;
9936 salt_type = SALT_TYPE_EMBEDDED;
9937 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9938 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9939 kern_type = KERN_TYPE_SAPH_SHA1;
9940 dgst_size = DGST_SIZE_4_5;
9941 parse_func = saph_sha1_parse_hash;
9942 sort_by_digest = sort_by_digest_4_5;
9943 opti_type = OPTI_TYPE_ZERO_BYTE;
9944 dgst_pos0 = 0;
9945 dgst_pos1 = 1;
9946 dgst_pos2 = 2;
9947 dgst_pos3 = 3;
9948 break;
9949
9950 case 10400: hash_type = HASH_TYPE_PDFU16;
9951 salt_type = SALT_TYPE_EMBEDDED;
9952 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9953 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9954 kern_type = KERN_TYPE_PDF11;
9955 dgst_size = DGST_SIZE_4_4;
9956 parse_func = pdf11_parse_hash;
9957 sort_by_digest = sort_by_digest_4_4;
9958 opti_type = OPTI_TYPE_ZERO_BYTE
9959 | OPTI_TYPE_NOT_ITERATED;
9960 dgst_pos0 = 0;
9961 dgst_pos1 = 1;
9962 dgst_pos2 = 2;
9963 dgst_pos3 = 3;
9964 break;
9965
9966 case 10410: hash_type = HASH_TYPE_PDFU16;
9967 salt_type = SALT_TYPE_EMBEDDED;
9968 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9969 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9970 kern_type = KERN_TYPE_PDF11CM1;
9971 dgst_size = DGST_SIZE_4_4;
9972 parse_func = pdf11cm1_parse_hash;
9973 sort_by_digest = sort_by_digest_4_4;
9974 opti_type = OPTI_TYPE_ZERO_BYTE
9975 | OPTI_TYPE_NOT_ITERATED;
9976 dgst_pos0 = 0;
9977 dgst_pos1 = 1;
9978 dgst_pos2 = 2;
9979 dgst_pos3 = 3;
9980 break;
9981
9982 case 10420: hash_type = HASH_TYPE_PDFU16;
9983 salt_type = SALT_TYPE_EMBEDDED;
9984 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9985 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9986 kern_type = KERN_TYPE_PDF11CM2;
9987 dgst_size = DGST_SIZE_4_4;
9988 parse_func = pdf11cm2_parse_hash;
9989 sort_by_digest = sort_by_digest_4_4;
9990 opti_type = OPTI_TYPE_ZERO_BYTE
9991 | OPTI_TYPE_NOT_ITERATED;
9992 dgst_pos0 = 0;
9993 dgst_pos1 = 1;
9994 dgst_pos2 = 2;
9995 dgst_pos3 = 3;
9996 break;
9997
9998 case 10500: hash_type = HASH_TYPE_PDFU16;
9999 salt_type = SALT_TYPE_EMBEDDED;
10000 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10001 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10002 kern_type = KERN_TYPE_PDF14;
10003 dgst_size = DGST_SIZE_4_4;
10004 parse_func = pdf14_parse_hash;
10005 sort_by_digest = sort_by_digest_4_4;
10006 opti_type = OPTI_TYPE_ZERO_BYTE
10007 | OPTI_TYPE_NOT_ITERATED;
10008 dgst_pos0 = 0;
10009 dgst_pos1 = 1;
10010 dgst_pos2 = 2;
10011 dgst_pos3 = 3;
10012 break;
10013
10014 case 10600: hash_type = HASH_TYPE_SHA256;
10015 salt_type = SALT_TYPE_EMBEDDED;
10016 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10017 opts_type = OPTS_TYPE_PT_GENERATE_BE
10018 | OPTS_TYPE_ST_ADD80
10019 | OPTS_TYPE_ST_ADDBITS15
10020 | OPTS_TYPE_HASH_COPY;
10021 kern_type = KERN_TYPE_SHA256_PWSLT;
10022 dgst_size = DGST_SIZE_4_8;
10023 parse_func = pdf17l3_parse_hash;
10024 sort_by_digest = sort_by_digest_4_8;
10025 opti_type = OPTI_TYPE_ZERO_BYTE
10026 | OPTI_TYPE_PRECOMPUTE_INIT
10027 | OPTI_TYPE_PRECOMPUTE_MERKLE
10028 | OPTI_TYPE_EARLY_SKIP
10029 | OPTI_TYPE_NOT_ITERATED
10030 | OPTI_TYPE_APPENDED_SALT
10031 | OPTI_TYPE_RAW_HASH;
10032 dgst_pos0 = 3;
10033 dgst_pos1 = 7;
10034 dgst_pos2 = 2;
10035 dgst_pos3 = 6;
10036 break;
10037
10038 case 10700: hash_type = HASH_TYPE_PDFU32;
10039 salt_type = SALT_TYPE_EMBEDDED;
10040 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10041 opts_type = OPTS_TYPE_PT_GENERATE_LE
10042 | OPTS_TYPE_HASH_COPY;
10043 kern_type = KERN_TYPE_PDF17L8;
10044 dgst_size = DGST_SIZE_4_8;
10045 parse_func = pdf17l8_parse_hash;
10046 sort_by_digest = sort_by_digest_4_8;
10047 opti_type = OPTI_TYPE_ZERO_BYTE
10048 | OPTI_TYPE_NOT_ITERATED;
10049 dgst_pos0 = 0;
10050 dgst_pos1 = 1;
10051 dgst_pos2 = 2;
10052 dgst_pos3 = 3;
10053 break;
10054
10055 case 10800: hash_type = HASH_TYPE_SHA384;
10056 salt_type = SALT_TYPE_NONE;
10057 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10058 opts_type = OPTS_TYPE_PT_GENERATE_BE
10059 | OPTS_TYPE_PT_ADD80
10060 | OPTS_TYPE_PT_ADDBITS15;
10061 kern_type = KERN_TYPE_SHA384;
10062 dgst_size = DGST_SIZE_8_8;
10063 parse_func = sha384_parse_hash;
10064 sort_by_digest = sort_by_digest_8_8;
10065 opti_type = OPTI_TYPE_ZERO_BYTE
10066 | OPTI_TYPE_PRECOMPUTE_INIT
10067 | OPTI_TYPE_PRECOMPUTE_MERKLE
10068 | OPTI_TYPE_EARLY_SKIP
10069 | OPTI_TYPE_NOT_ITERATED
10070 | OPTI_TYPE_NOT_SALTED
10071 | OPTI_TYPE_USES_BITS_64
10072 | OPTI_TYPE_RAW_HASH;
10073 dgst_pos0 = 6;
10074 dgst_pos1 = 7;
10075 dgst_pos2 = 4;
10076 dgst_pos3 = 5;
10077 break;
10078
10079 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10080 salt_type = SALT_TYPE_EMBEDDED;
10081 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10082 opts_type = OPTS_TYPE_PT_GENERATE_LE
10083 | OPTS_TYPE_ST_BASE64
10084 | OPTS_TYPE_HASH_COPY;
10085 kern_type = KERN_TYPE_PBKDF2_SHA256;
10086 dgst_size = DGST_SIZE_4_32;
10087 parse_func = pbkdf2_sha256_parse_hash;
10088 sort_by_digest = sort_by_digest_4_32;
10089 opti_type = OPTI_TYPE_ZERO_BYTE
10090 | OPTI_TYPE_SLOW_HASH_SIMD;
10091 dgst_pos0 = 0;
10092 dgst_pos1 = 1;
10093 dgst_pos2 = 2;
10094 dgst_pos3 = 3;
10095 break;
10096
10097 case 11000: hash_type = HASH_TYPE_MD5;
10098 salt_type = SALT_TYPE_INTERN;
10099 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10100 opts_type = OPTS_TYPE_PT_GENERATE_LE
10101 | OPTS_TYPE_PT_ADD80;
10102 kern_type = KERN_TYPE_PRESTASHOP;
10103 dgst_size = DGST_SIZE_4_4;
10104 parse_func = prestashop_parse_hash;
10105 sort_by_digest = sort_by_digest_4_4;
10106 opti_type = OPTI_TYPE_ZERO_BYTE
10107 | OPTI_TYPE_PRECOMPUTE_INIT
10108 | OPTI_TYPE_NOT_ITERATED
10109 | OPTI_TYPE_PREPENDED_SALT;
10110 dgst_pos0 = 0;
10111 dgst_pos1 = 3;
10112 dgst_pos2 = 2;
10113 dgst_pos3 = 1;
10114 break;
10115
10116 case 11100: hash_type = HASH_TYPE_MD5;
10117 salt_type = SALT_TYPE_EMBEDDED;
10118 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10119 opts_type = OPTS_TYPE_PT_GENERATE_LE
10120 | OPTS_TYPE_ST_ADD80;
10121 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10122 dgst_size = DGST_SIZE_4_4;
10123 parse_func = postgresql_auth_parse_hash;
10124 sort_by_digest = sort_by_digest_4_4;
10125 opti_type = OPTI_TYPE_ZERO_BYTE
10126 | OPTI_TYPE_PRECOMPUTE_INIT
10127 | OPTI_TYPE_PRECOMPUTE_MERKLE
10128 | OPTI_TYPE_EARLY_SKIP;
10129 dgst_pos0 = 0;
10130 dgst_pos1 = 3;
10131 dgst_pos2 = 2;
10132 dgst_pos3 = 1;
10133 break;
10134
10135 case 11200: hash_type = HASH_TYPE_SHA1;
10136 salt_type = SALT_TYPE_EMBEDDED;
10137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10138 opts_type = OPTS_TYPE_PT_GENERATE_BE
10139 | OPTS_TYPE_PT_ADD80
10140 | OPTS_TYPE_ST_HEX;
10141 kern_type = KERN_TYPE_MYSQL_AUTH;
10142 dgst_size = DGST_SIZE_4_5;
10143 parse_func = mysql_auth_parse_hash;
10144 sort_by_digest = sort_by_digest_4_5;
10145 opti_type = OPTI_TYPE_ZERO_BYTE
10146 | OPTI_TYPE_EARLY_SKIP;
10147 dgst_pos0 = 3;
10148 dgst_pos1 = 4;
10149 dgst_pos2 = 2;
10150 dgst_pos3 = 1;
10151 break;
10152
10153 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10154 salt_type = SALT_TYPE_EMBEDDED;
10155 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10156 opts_type = OPTS_TYPE_PT_GENERATE_LE
10157 | OPTS_TYPE_ST_HEX
10158 | OPTS_TYPE_ST_ADD80;
10159 kern_type = KERN_TYPE_BITCOIN_WALLET;
10160 dgst_size = DGST_SIZE_4_4;
10161 parse_func = bitcoin_wallet_parse_hash;
10162 sort_by_digest = sort_by_digest_4_4;
10163 opti_type = OPTI_TYPE_ZERO_BYTE;
10164 dgst_pos0 = 0;
10165 dgst_pos1 = 1;
10166 dgst_pos2 = 2;
10167 dgst_pos3 = 3;
10168 break;
10169
10170 case 11400: hash_type = HASH_TYPE_MD5;
10171 salt_type = SALT_TYPE_EMBEDDED;
10172 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10173 opts_type = OPTS_TYPE_PT_GENERATE_LE
10174 | OPTS_TYPE_PT_ADD80
10175 | OPTS_TYPE_HASH_COPY;
10176 kern_type = KERN_TYPE_SIP_AUTH;
10177 dgst_size = DGST_SIZE_4_4;
10178 parse_func = sip_auth_parse_hash;
10179 sort_by_digest = sort_by_digest_4_4;
10180 opti_type = OPTI_TYPE_ZERO_BYTE;
10181 dgst_pos0 = 0;
10182 dgst_pos1 = 3;
10183 dgst_pos2 = 2;
10184 dgst_pos3 = 1;
10185 break;
10186
10187 case 11500: hash_type = HASH_TYPE_CRC32;
10188 salt_type = SALT_TYPE_INTERN;
10189 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10190 opts_type = OPTS_TYPE_PT_GENERATE_LE
10191 | OPTS_TYPE_ST_GENERATE_LE
10192 | OPTS_TYPE_ST_HEX;
10193 kern_type = KERN_TYPE_CRC32;
10194 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10195 parse_func = crc32_parse_hash;
10196 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10197 opti_type = OPTI_TYPE_ZERO_BYTE;
10198 dgst_pos0 = 0;
10199 dgst_pos1 = 1;
10200 dgst_pos2 = 2;
10201 dgst_pos3 = 3;
10202 break;
10203
10204 case 11600: hash_type = HASH_TYPE_AES;
10205 salt_type = SALT_TYPE_EMBEDDED;
10206 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10207 opts_type = OPTS_TYPE_PT_GENERATE_LE
10208 | OPTS_TYPE_PT_NEVERCRACK;
10209 kern_type = KERN_TYPE_SEVEN_ZIP;
10210 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10211 parse_func = seven_zip_parse_hash;
10212 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10213 opti_type = OPTI_TYPE_ZERO_BYTE;
10214 dgst_pos0 = 0;
10215 dgst_pos1 = 1;
10216 dgst_pos2 = 2;
10217 dgst_pos3 = 3;
10218 break;
10219
10220 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10221 salt_type = SALT_TYPE_NONE;
10222 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10223 opts_type = OPTS_TYPE_PT_GENERATE_LE
10224 | OPTS_TYPE_PT_ADD01;
10225 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10226 dgst_size = DGST_SIZE_4_8;
10227 parse_func = gost2012sbog_256_parse_hash;
10228 sort_by_digest = sort_by_digest_4_8;
10229 opti_type = OPTI_TYPE_ZERO_BYTE;
10230 dgst_pos0 = 0;
10231 dgst_pos1 = 1;
10232 dgst_pos2 = 2;
10233 dgst_pos3 = 3;
10234 break;
10235
10236 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10237 salt_type = SALT_TYPE_NONE;
10238 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10239 opts_type = OPTS_TYPE_PT_GENERATE_LE
10240 | OPTS_TYPE_PT_ADD01;
10241 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10242 dgst_size = DGST_SIZE_4_16;
10243 parse_func = gost2012sbog_512_parse_hash;
10244 sort_by_digest = sort_by_digest_4_16;
10245 opti_type = OPTI_TYPE_ZERO_BYTE;
10246 dgst_pos0 = 0;
10247 dgst_pos1 = 1;
10248 dgst_pos2 = 2;
10249 dgst_pos3 = 3;
10250 break;
10251
10252 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10253 salt_type = SALT_TYPE_EMBEDDED;
10254 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10255 opts_type = OPTS_TYPE_PT_GENERATE_LE
10256 | OPTS_TYPE_ST_BASE64
10257 | OPTS_TYPE_HASH_COPY;
10258 kern_type = KERN_TYPE_PBKDF2_MD5;
10259 dgst_size = DGST_SIZE_4_32;
10260 parse_func = pbkdf2_md5_parse_hash;
10261 sort_by_digest = sort_by_digest_4_32;
10262 opti_type = OPTI_TYPE_ZERO_BYTE
10263 | OPTI_TYPE_SLOW_HASH_SIMD;
10264 dgst_pos0 = 0;
10265 dgst_pos1 = 1;
10266 dgst_pos2 = 2;
10267 dgst_pos3 = 3;
10268 break;
10269
10270 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10271 salt_type = SALT_TYPE_EMBEDDED;
10272 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10273 opts_type = OPTS_TYPE_PT_GENERATE_LE
10274 | OPTS_TYPE_ST_BASE64
10275 | OPTS_TYPE_HASH_COPY;
10276 kern_type = KERN_TYPE_PBKDF2_SHA1;
10277 dgst_size = DGST_SIZE_4_32;
10278 parse_func = pbkdf2_sha1_parse_hash;
10279 sort_by_digest = sort_by_digest_4_32;
10280 opti_type = OPTI_TYPE_ZERO_BYTE
10281 | OPTI_TYPE_SLOW_HASH_SIMD;
10282 dgst_pos0 = 0;
10283 dgst_pos1 = 1;
10284 dgst_pos2 = 2;
10285 dgst_pos3 = 3;
10286 break;
10287
10288 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10289 salt_type = SALT_TYPE_EMBEDDED;
10290 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10291 opts_type = OPTS_TYPE_PT_GENERATE_LE
10292 | OPTS_TYPE_ST_BASE64
10293 | OPTS_TYPE_HASH_COPY;
10294 kern_type = KERN_TYPE_PBKDF2_SHA512;
10295 dgst_size = DGST_SIZE_8_16;
10296 parse_func = pbkdf2_sha512_parse_hash;
10297 sort_by_digest = sort_by_digest_8_16;
10298 opti_type = OPTI_TYPE_ZERO_BYTE
10299 | OPTI_TYPE_USES_BITS_64
10300 | OPTI_TYPE_SLOW_HASH_SIMD;
10301 dgst_pos0 = 0;
10302 dgst_pos1 = 1;
10303 dgst_pos2 = 2;
10304 dgst_pos3 = 3;
10305 break;
10306
10307 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10308 salt_type = SALT_TYPE_EMBEDDED;
10309 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10310 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10311 kern_type = KERN_TYPE_ECRYPTFS;
10312 dgst_size = DGST_SIZE_8_8;
10313 parse_func = ecryptfs_parse_hash;
10314 sort_by_digest = sort_by_digest_8_8;
10315 opti_type = OPTI_TYPE_ZERO_BYTE
10316 | OPTI_TYPE_USES_BITS_64;
10317 dgst_pos0 = 0;
10318 dgst_pos1 = 1;
10319 dgst_pos2 = 2;
10320 dgst_pos3 = 3;
10321 break;
10322
10323 case 12300: hash_type = HASH_TYPE_ORACLET;
10324 salt_type = SALT_TYPE_EMBEDDED;
10325 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10326 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10327 kern_type = KERN_TYPE_ORACLET;
10328 dgst_size = DGST_SIZE_8_16;
10329 parse_func = oraclet_parse_hash;
10330 sort_by_digest = sort_by_digest_8_16;
10331 opti_type = OPTI_TYPE_ZERO_BYTE
10332 | OPTI_TYPE_USES_BITS_64;
10333 dgst_pos0 = 0;
10334 dgst_pos1 = 1;
10335 dgst_pos2 = 2;
10336 dgst_pos3 = 3;
10337 break;
10338
10339 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10340 salt_type = SALT_TYPE_EMBEDDED;
10341 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10342 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10343 kern_type = KERN_TYPE_BSDICRYPT;
10344 dgst_size = DGST_SIZE_4_4;
10345 parse_func = bsdicrypt_parse_hash;
10346 sort_by_digest = sort_by_digest_4_4;
10347 opti_type = OPTI_TYPE_ZERO_BYTE
10348 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10349 dgst_pos0 = 0;
10350 dgst_pos1 = 1;
10351 dgst_pos2 = 2;
10352 dgst_pos3 = 3;
10353 break;
10354
10355 case 12500: hash_type = HASH_TYPE_RAR3HP;
10356 salt_type = SALT_TYPE_EMBEDDED;
10357 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10358 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10359 kern_type = KERN_TYPE_RAR3;
10360 dgst_size = DGST_SIZE_4_4;
10361 parse_func = rar3hp_parse_hash;
10362 sort_by_digest = sort_by_digest_4_4;
10363 opti_type = OPTI_TYPE_ZERO_BYTE;
10364 dgst_pos0 = 0;
10365 dgst_pos1 = 1;
10366 dgst_pos2 = 2;
10367 dgst_pos3 = 3;
10368 break;
10369
10370 case 12600: hash_type = HASH_TYPE_SHA256;
10371 salt_type = SALT_TYPE_INTERN;
10372 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10373 opts_type = OPTS_TYPE_PT_GENERATE_BE
10374 | OPTS_TYPE_PT_ADD80;
10375 kern_type = KERN_TYPE_CF10;
10376 dgst_size = DGST_SIZE_4_8;
10377 parse_func = cf10_parse_hash;
10378 sort_by_digest = sort_by_digest_4_8;
10379 opti_type = OPTI_TYPE_ZERO_BYTE
10380 | OPTI_TYPE_PRECOMPUTE_INIT
10381 | OPTI_TYPE_EARLY_SKIP
10382 | OPTI_TYPE_NOT_ITERATED;
10383 dgst_pos0 = 3;
10384 dgst_pos1 = 7;
10385 dgst_pos2 = 2;
10386 dgst_pos3 = 6;
10387 break;
10388
10389 case 12700: hash_type = HASH_TYPE_AES;
10390 salt_type = SALT_TYPE_EMBEDDED;
10391 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10392 opts_type = OPTS_TYPE_PT_GENERATE_LE
10393 | OPTS_TYPE_HASH_COPY;
10394 kern_type = KERN_TYPE_MYWALLET;
10395 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10396 parse_func = mywallet_parse_hash;
10397 sort_by_digest = sort_by_digest_4_5;
10398 opti_type = OPTI_TYPE_ZERO_BYTE;
10399 dgst_pos0 = 0;
10400 dgst_pos1 = 1;
10401 dgst_pos2 = 2;
10402 dgst_pos3 = 3;
10403 break;
10404
10405 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10406 salt_type = SALT_TYPE_EMBEDDED;
10407 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10408 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10409 kern_type = KERN_TYPE_MS_DRSR;
10410 dgst_size = DGST_SIZE_4_8;
10411 parse_func = ms_drsr_parse_hash;
10412 sort_by_digest = sort_by_digest_4_8;
10413 opti_type = OPTI_TYPE_ZERO_BYTE;
10414 dgst_pos0 = 0;
10415 dgst_pos1 = 1;
10416 dgst_pos2 = 2;
10417 dgst_pos3 = 3;
10418 break;
10419
10420 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10421 salt_type = SALT_TYPE_EMBEDDED;
10422 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10423 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10424 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10425 dgst_size = DGST_SIZE_4_8;
10426 parse_func = androidfde_samsung_parse_hash;
10427 sort_by_digest = sort_by_digest_4_8;
10428 opti_type = OPTI_TYPE_ZERO_BYTE;
10429 dgst_pos0 = 0;
10430 dgst_pos1 = 1;
10431 dgst_pos2 = 2;
10432 dgst_pos3 = 3;
10433 break;
10434
10435 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10436 salt_type = SALT_TYPE_EMBEDDED;
10437 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10438 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10439 kern_type = KERN_TYPE_RAR5;
10440 dgst_size = DGST_SIZE_4_4;
10441 parse_func = rar5_parse_hash;
10442 sort_by_digest = sort_by_digest_4_4;
10443 opti_type = OPTI_TYPE_ZERO_BYTE;
10444 dgst_pos0 = 0;
10445 dgst_pos1 = 1;
10446 dgst_pos2 = 2;
10447 dgst_pos3 = 3;
10448 break;
10449
10450 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10451 salt_type = SALT_TYPE_EMBEDDED;
10452 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10453 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10454 kern_type = KERN_TYPE_KRB5TGS;
10455 dgst_size = DGST_SIZE_4_4;
10456 parse_func = krb5tgs_parse_hash;
10457 sort_by_digest = sort_by_digest_4_4;
10458 opti_type = OPTI_TYPE_ZERO_BYTE
10459 | OPTI_TYPE_NOT_ITERATED;
10460 dgst_pos0 = 0;
10461 dgst_pos1 = 1;
10462 dgst_pos2 = 2;
10463 dgst_pos3 = 3;
10464 break;
10465
10466 case 13200: hash_type = HASH_TYPE_AES;
10467 salt_type = SALT_TYPE_EMBEDDED;
10468 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10469 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10470 kern_type = KERN_TYPE_AXCRYPT;
10471 dgst_size = DGST_SIZE_4_4;
10472 parse_func = axcrypt_parse_hash;
10473 sort_by_digest = sort_by_digest_4_4;
10474 opti_type = OPTI_TYPE_ZERO_BYTE;
10475 dgst_pos0 = 0;
10476 dgst_pos1 = 1;
10477 dgst_pos2 = 2;
10478 dgst_pos3 = 3;
10479 break;
10480
10481 case 13300: hash_type = HASH_TYPE_SHA1;
10482 salt_type = SALT_TYPE_NONE;
10483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10484 opts_type = OPTS_TYPE_PT_GENERATE_BE
10485 | OPTS_TYPE_PT_ADD80
10486 | OPTS_TYPE_PT_ADDBITS15;
10487 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10488 dgst_size = DGST_SIZE_4_5;
10489 parse_func = sha1axcrypt_parse_hash;
10490 sort_by_digest = sort_by_digest_4_5;
10491 opti_type = OPTI_TYPE_ZERO_BYTE
10492 | OPTI_TYPE_PRECOMPUTE_INIT
10493 | OPTI_TYPE_EARLY_SKIP
10494 | OPTI_TYPE_NOT_ITERATED
10495 | OPTI_TYPE_NOT_SALTED;
10496 dgst_pos0 = 0;
10497 dgst_pos1 = 4;
10498 dgst_pos2 = 3;
10499 dgst_pos3 = 2;
10500 break;
10501
10502 case 13400: hash_type = HASH_TYPE_AES;
10503 salt_type = SALT_TYPE_EMBEDDED;
10504 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10505 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10506 kern_type = KERN_TYPE_KEEPASS;
10507 dgst_size = DGST_SIZE_4_4;
10508 parse_func = keepass_parse_hash;
10509 sort_by_digest = sort_by_digest_4_4;
10510 opti_type = OPTI_TYPE_ZERO_BYTE;
10511 dgst_pos0 = 0;
10512 dgst_pos1 = 1;
10513 dgst_pos2 = 2;
10514 dgst_pos3 = 3;
10515 break;
10516
10517 case 13500: hash_type = HASH_TYPE_SHA1;
10518 salt_type = SALT_TYPE_EMBEDDED;
10519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10520 opts_type = OPTS_TYPE_PT_GENERATE_BE
10521 | OPTS_TYPE_PT_UNICODE
10522 | OPTS_TYPE_PT_ADD80;
10523 kern_type = KERN_TYPE_PSTOKEN;
10524 dgst_size = DGST_SIZE_4_5;
10525 parse_func = pstoken_parse_hash;
10526 sort_by_digest = sort_by_digest_4_5;
10527 opti_type = OPTI_TYPE_ZERO_BYTE
10528 | OPTI_TYPE_PRECOMPUTE_INIT
10529 | OPTI_TYPE_EARLY_SKIP
10530 | OPTI_TYPE_NOT_ITERATED
10531 | OPTI_TYPE_PREPENDED_SALT
10532 | OPTI_TYPE_RAW_HASH;
10533 dgst_pos0 = 3;
10534 dgst_pos1 = 4;
10535 dgst_pos2 = 2;
10536 dgst_pos3 = 1;
10537 break;
10538
10539 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10540 salt_type = SALT_TYPE_EMBEDDED;
10541 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10542 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10543 kern_type = KERN_TYPE_ZIP2;
10544 dgst_size = DGST_SIZE_4_4;
10545 parse_func = zip2_parse_hash;
10546 sort_by_digest = sort_by_digest_4_4;
10547 opti_type = OPTI_TYPE_ZERO_BYTE;
10548 dgst_pos0 = 0;
10549 dgst_pos1 = 1;
10550 dgst_pos2 = 2;
10551 dgst_pos3 = 3;
10552 break;
10553
10554 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10555 salt_type = SALT_TYPE_EMBEDDED;
10556 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10557 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10558 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10559 dgst_size = DGST_SIZE_4_5;
10560 parse_func = veracrypt_parse_hash_655331;
10561 sort_by_digest = sort_by_digest_4_5;
10562 opti_type = OPTI_TYPE_ZERO_BYTE;
10563 dgst_pos0 = 0;
10564 dgst_pos1 = 1;
10565 dgst_pos2 = 2;
10566 dgst_pos3 = 3;
10567 break;
10568
10569 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10570 salt_type = SALT_TYPE_EMBEDDED;
10571 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10572 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10573 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10574 dgst_size = DGST_SIZE_4_5;
10575 parse_func = veracrypt_parse_hash_655331;
10576 sort_by_digest = sort_by_digest_4_5;
10577 opti_type = OPTI_TYPE_ZERO_BYTE;
10578 dgst_pos0 = 0;
10579 dgst_pos1 = 1;
10580 dgst_pos2 = 2;
10581 dgst_pos3 = 3;
10582 break;
10583
10584 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10585 salt_type = SALT_TYPE_EMBEDDED;
10586 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10587 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10588 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10589 dgst_size = DGST_SIZE_4_5;
10590 parse_func = veracrypt_parse_hash_655331;
10591 sort_by_digest = sort_by_digest_4_5;
10592 opti_type = OPTI_TYPE_ZERO_BYTE;
10593 dgst_pos0 = 0;
10594 dgst_pos1 = 1;
10595 dgst_pos2 = 2;
10596 dgst_pos3 = 3;
10597 break;
10598
10599 case 13721: hash_type = HASH_TYPE_SHA512;
10600 salt_type = SALT_TYPE_EMBEDDED;
10601 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10602 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10603 kern_type = KERN_TYPE_TCSHA512_XTS512;
10604 dgst_size = DGST_SIZE_8_8;
10605 parse_func = veracrypt_parse_hash_500000;
10606 sort_by_digest = sort_by_digest_8_8;
10607 opti_type = OPTI_TYPE_ZERO_BYTE
10608 | OPTI_TYPE_USES_BITS_64;
10609 dgst_pos0 = 0;
10610 dgst_pos1 = 1;
10611 dgst_pos2 = 2;
10612 dgst_pos3 = 3;
10613 break;
10614
10615 case 13722: hash_type = HASH_TYPE_SHA512;
10616 salt_type = SALT_TYPE_EMBEDDED;
10617 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10618 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10619 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10620 dgst_size = DGST_SIZE_8_8;
10621 parse_func = veracrypt_parse_hash_500000;
10622 sort_by_digest = sort_by_digest_8_8;
10623 opti_type = OPTI_TYPE_ZERO_BYTE
10624 | OPTI_TYPE_USES_BITS_64;
10625 dgst_pos0 = 0;
10626 dgst_pos1 = 1;
10627 dgst_pos2 = 2;
10628 dgst_pos3 = 3;
10629 break;
10630
10631 case 13723: hash_type = HASH_TYPE_SHA512;
10632 salt_type = SALT_TYPE_EMBEDDED;
10633 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10634 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10635 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10636 dgst_size = DGST_SIZE_8_8;
10637 parse_func = veracrypt_parse_hash_500000;
10638 sort_by_digest = sort_by_digest_8_8;
10639 opti_type = OPTI_TYPE_ZERO_BYTE
10640 | OPTI_TYPE_USES_BITS_64;
10641 dgst_pos0 = 0;
10642 dgst_pos1 = 1;
10643 dgst_pos2 = 2;
10644 dgst_pos3 = 3;
10645 break;
10646
10647 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10648 salt_type = SALT_TYPE_EMBEDDED;
10649 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10650 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10651 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10652 dgst_size = DGST_SIZE_4_8;
10653 parse_func = veracrypt_parse_hash_500000;
10654 sort_by_digest = sort_by_digest_4_8;
10655 opti_type = OPTI_TYPE_ZERO_BYTE;
10656 dgst_pos0 = 0;
10657 dgst_pos1 = 1;
10658 dgst_pos2 = 2;
10659 dgst_pos3 = 3;
10660 break;
10661
10662 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10663 salt_type = SALT_TYPE_EMBEDDED;
10664 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10665 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10666 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10667 dgst_size = DGST_SIZE_4_8;
10668 parse_func = veracrypt_parse_hash_500000;
10669 sort_by_digest = sort_by_digest_4_8;
10670 opti_type = OPTI_TYPE_ZERO_BYTE;
10671 dgst_pos0 = 0;
10672 dgst_pos1 = 1;
10673 dgst_pos2 = 2;
10674 dgst_pos3 = 3;
10675 break;
10676
10677 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10678 salt_type = SALT_TYPE_EMBEDDED;
10679 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10680 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10681 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10682 dgst_size = DGST_SIZE_4_8;
10683 parse_func = veracrypt_parse_hash_500000;
10684 sort_by_digest = sort_by_digest_4_8;
10685 opti_type = OPTI_TYPE_ZERO_BYTE;
10686 dgst_pos0 = 0;
10687 dgst_pos1 = 1;
10688 dgst_pos2 = 2;
10689 dgst_pos3 = 3;
10690 break;
10691
10692 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10693 salt_type = SALT_TYPE_EMBEDDED;
10694 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10695 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10696 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10697 dgst_size = DGST_SIZE_4_5;
10698 parse_func = veracrypt_parse_hash_327661;
10699 sort_by_digest = sort_by_digest_4_5;
10700 opti_type = OPTI_TYPE_ZERO_BYTE;
10701 dgst_pos0 = 0;
10702 dgst_pos1 = 1;
10703 dgst_pos2 = 2;
10704 dgst_pos3 = 3;
10705 break;
10706
10707 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10708 salt_type = SALT_TYPE_EMBEDDED;
10709 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10710 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10711 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10712 dgst_size = DGST_SIZE_4_5;
10713 parse_func = veracrypt_parse_hash_327661;
10714 sort_by_digest = sort_by_digest_4_5;
10715 opti_type = OPTI_TYPE_ZERO_BYTE;
10716 dgst_pos0 = 0;
10717 dgst_pos1 = 1;
10718 dgst_pos2 = 2;
10719 dgst_pos3 = 3;
10720 break;
10721
10722 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10723 salt_type = SALT_TYPE_EMBEDDED;
10724 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10725 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10726 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10727 dgst_size = DGST_SIZE_4_5;
10728 parse_func = veracrypt_parse_hash_327661;
10729 sort_by_digest = sort_by_digest_4_5;
10730 opti_type = OPTI_TYPE_ZERO_BYTE;
10731 dgst_pos0 = 0;
10732 dgst_pos1 = 1;
10733 dgst_pos2 = 2;
10734 dgst_pos3 = 3;
10735 break;
10736
10737 case 13751: hash_type = HASH_TYPE_SHA256;
10738 salt_type = SALT_TYPE_EMBEDDED;
10739 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10740 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10741 kern_type = KERN_TYPE_VCSHA256_XTS512;
10742 dgst_size = DGST_SIZE_4_8;
10743 parse_func = veracrypt_parse_hash_500000;
10744 sort_by_digest = sort_by_digest_4_8;
10745 opti_type = OPTI_TYPE_ZERO_BYTE;
10746 dgst_pos0 = 0;
10747 dgst_pos1 = 1;
10748 dgst_pos2 = 2;
10749 dgst_pos3 = 3;
10750 break;
10751
10752 case 13752: hash_type = HASH_TYPE_SHA256;
10753 salt_type = SALT_TYPE_EMBEDDED;
10754 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10755 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10756 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10757 dgst_size = DGST_SIZE_4_8;
10758 parse_func = veracrypt_parse_hash_500000;
10759 sort_by_digest = sort_by_digest_4_8;
10760 opti_type = OPTI_TYPE_ZERO_BYTE;
10761 dgst_pos0 = 0;
10762 dgst_pos1 = 1;
10763 dgst_pos2 = 2;
10764 dgst_pos3 = 3;
10765 break;
10766
10767 case 13753: hash_type = HASH_TYPE_SHA256;
10768 salt_type = SALT_TYPE_EMBEDDED;
10769 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10770 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10771 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10772 dgst_size = DGST_SIZE_4_8;
10773 parse_func = veracrypt_parse_hash_500000;
10774 sort_by_digest = sort_by_digest_4_8;
10775 opti_type = OPTI_TYPE_ZERO_BYTE;
10776 dgst_pos0 = 0;
10777 dgst_pos1 = 1;
10778 dgst_pos2 = 2;
10779 dgst_pos3 = 3;
10780 break;
10781
10782 case 13761: hash_type = HASH_TYPE_SHA256;
10783 salt_type = SALT_TYPE_EMBEDDED;
10784 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10785 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10786 kern_type = KERN_TYPE_VCSHA256_XTS512;
10787 dgst_size = DGST_SIZE_4_8;
10788 parse_func = veracrypt_parse_hash_200000;
10789 sort_by_digest = sort_by_digest_4_8;
10790 opti_type = OPTI_TYPE_ZERO_BYTE;
10791 dgst_pos0 = 0;
10792 dgst_pos1 = 1;
10793 dgst_pos2 = 2;
10794 dgst_pos3 = 3;
10795 break;
10796
10797 case 13762: hash_type = HASH_TYPE_SHA256;
10798 salt_type = SALT_TYPE_EMBEDDED;
10799 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10800 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10801 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10802 dgst_size = DGST_SIZE_4_8;
10803 parse_func = veracrypt_parse_hash_200000;
10804 sort_by_digest = sort_by_digest_4_8;
10805 opti_type = OPTI_TYPE_ZERO_BYTE;
10806 dgst_pos0 = 0;
10807 dgst_pos1 = 1;
10808 dgst_pos2 = 2;
10809 dgst_pos3 = 3;
10810 break;
10811
10812 case 13763: hash_type = HASH_TYPE_SHA256;
10813 salt_type = SALT_TYPE_EMBEDDED;
10814 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10815 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10816 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10817 dgst_size = DGST_SIZE_4_8;
10818 parse_func = veracrypt_parse_hash_200000;
10819 sort_by_digest = sort_by_digest_4_8;
10820 opti_type = OPTI_TYPE_ZERO_BYTE;
10821 dgst_pos0 = 0;
10822 dgst_pos1 = 1;
10823 dgst_pos2 = 2;
10824 dgst_pos3 = 3;
10825 break;
10826
10827 case 13800: hash_type = HASH_TYPE_SHA256;
10828 salt_type = SALT_TYPE_EMBEDDED;
10829 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10830 opts_type = OPTS_TYPE_PT_GENERATE_BE
10831 | OPTS_TYPE_PT_UNICODE;
10832 kern_type = KERN_TYPE_WIN8PHONE;
10833 dgst_size = DGST_SIZE_4_8;
10834 parse_func = win8phone_parse_hash;
10835 sort_by_digest = sort_by_digest_4_8;
10836 opti_type = OPTI_TYPE_ZERO_BYTE
10837 | OPTI_TYPE_PRECOMPUTE_INIT
10838 | OPTI_TYPE_EARLY_SKIP
10839 | OPTI_TYPE_NOT_ITERATED
10840 | OPTI_TYPE_RAW_HASH;
10841 dgst_pos0 = 3;
10842 dgst_pos1 = 7;
10843 dgst_pos2 = 2;
10844 dgst_pos3 = 6;
10845 break;
10846
10847
10848 default: usage_mini_print (PROGNAME); return (-1);
10849 }
10850
10851 /**
10852 * parser
10853 */
10854
10855 data.parse_func = parse_func;
10856
10857 /**
10858 * misc stuff
10859 */
10860
10861 if (hex_salt)
10862 {
10863 if (salt_type == SALT_TYPE_INTERN)
10864 {
10865 opts_type |= OPTS_TYPE_ST_HEX;
10866 }
10867 else
10868 {
10869 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10870
10871 return (-1);
10872 }
10873 }
10874
10875 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10876 | (salt_type == SALT_TYPE_EXTERN)
10877 | (salt_type == SALT_TYPE_EMBEDDED)
10878 | (salt_type == SALT_TYPE_VIRTUAL));
10879
10880 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10881
10882 data.hash_type = hash_type;
10883 data.attack_mode = attack_mode;
10884 data.attack_kern = attack_kern;
10885 data.attack_exec = attack_exec;
10886 data.kern_type = kern_type;
10887 data.opts_type = opts_type;
10888 data.dgst_size = dgst_size;
10889 data.salt_type = salt_type;
10890 data.isSalted = isSalted;
10891 data.sort_by_digest = sort_by_digest;
10892 data.dgst_pos0 = dgst_pos0;
10893 data.dgst_pos1 = dgst_pos1;
10894 data.dgst_pos2 = dgst_pos2;
10895 data.dgst_pos3 = dgst_pos3;
10896
10897 esalt_size = 0;
10898
10899 switch (hash_mode)
10900 {
10901 case 2500: esalt_size = sizeof (wpa_t); break;
10902 case 5300: esalt_size = sizeof (ikepsk_t); break;
10903 case 5400: esalt_size = sizeof (ikepsk_t); break;
10904 case 5500: esalt_size = sizeof (netntlm_t); break;
10905 case 5600: esalt_size = sizeof (netntlm_t); break;
10906 case 6211: esalt_size = sizeof (tc_t); break;
10907 case 6212: esalt_size = sizeof (tc_t); break;
10908 case 6213: esalt_size = sizeof (tc_t); break;
10909 case 6221: esalt_size = sizeof (tc_t); break;
10910 case 6222: esalt_size = sizeof (tc_t); break;
10911 case 6223: esalt_size = sizeof (tc_t); break;
10912 case 6231: esalt_size = sizeof (tc_t); break;
10913 case 6232: esalt_size = sizeof (tc_t); break;
10914 case 6233: esalt_size = sizeof (tc_t); break;
10915 case 6241: esalt_size = sizeof (tc_t); break;
10916 case 6242: esalt_size = sizeof (tc_t); break;
10917 case 6243: esalt_size = sizeof (tc_t); break;
10918 case 6600: esalt_size = sizeof (agilekey_t); break;
10919 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10920 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10921 case 7300: esalt_size = sizeof (rakp_t); break;
10922 case 7500: esalt_size = sizeof (krb5pa_t); break;
10923 case 8200: esalt_size = sizeof (cloudkey_t); break;
10924 case 8800: esalt_size = sizeof (androidfde_t); break;
10925 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10926 case 9400: esalt_size = sizeof (office2007_t); break;
10927 case 9500: esalt_size = sizeof (office2010_t); break;
10928 case 9600: esalt_size = sizeof (office2013_t); break;
10929 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10930 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10931 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10932 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10933 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10934 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10935 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10936 case 10200: esalt_size = sizeof (cram_md5_t); break;
10937 case 10400: esalt_size = sizeof (pdf_t); break;
10938 case 10410: esalt_size = sizeof (pdf_t); break;
10939 case 10420: esalt_size = sizeof (pdf_t); break;
10940 case 10500: esalt_size = sizeof (pdf_t); break;
10941 case 10600: esalt_size = sizeof (pdf_t); break;
10942 case 10700: esalt_size = sizeof (pdf_t); break;
10943 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10944 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10945 case 11400: esalt_size = sizeof (sip_t); break;
10946 case 11600: esalt_size = sizeof (seven_zip_t); break;
10947 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10948 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10949 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10950 case 13000: esalt_size = sizeof (rar5_t); break;
10951 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10952 case 13400: esalt_size = sizeof (keepass_t); break;
10953 case 13500: esalt_size = sizeof (pstoken_t); break;
10954 case 13600: esalt_size = sizeof (zip2_t); break;
10955 case 13711: esalt_size = sizeof (tc_t); break;
10956 case 13712: esalt_size = sizeof (tc_t); break;
10957 case 13713: esalt_size = sizeof (tc_t); break;
10958 case 13721: esalt_size = sizeof (tc_t); break;
10959 case 13722: esalt_size = sizeof (tc_t); break;
10960 case 13723: esalt_size = sizeof (tc_t); break;
10961 case 13731: esalt_size = sizeof (tc_t); break;
10962 case 13732: esalt_size = sizeof (tc_t); break;
10963 case 13733: esalt_size = sizeof (tc_t); break;
10964 case 13741: esalt_size = sizeof (tc_t); break;
10965 case 13742: esalt_size = sizeof (tc_t); break;
10966 case 13743: esalt_size = sizeof (tc_t); break;
10967 case 13751: esalt_size = sizeof (tc_t); break;
10968 case 13752: esalt_size = sizeof (tc_t); break;
10969 case 13753: esalt_size = sizeof (tc_t); break;
10970 case 13761: esalt_size = sizeof (tc_t); break;
10971 case 13762: esalt_size = sizeof (tc_t); break;
10972 case 13763: esalt_size = sizeof (tc_t); break;
10973 case 13800: esalt_size = sizeof (win8phone_t); break;
10974 }
10975
10976 data.esalt_size = esalt_size;
10977
10978 /**
10979 * choose dictionary parser
10980 */
10981
10982 if (hash_type == HASH_TYPE_LM)
10983 {
10984 get_next_word_func = get_next_word_lm;
10985 }
10986 else if (opts_type & OPTS_TYPE_PT_UPPER)
10987 {
10988 get_next_word_func = get_next_word_uc;
10989 }
10990 else
10991 {
10992 get_next_word_func = get_next_word_std;
10993 }
10994
10995 /**
10996 * dictstat
10997 */
10998
10999 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11000
11001 #ifdef _POSIX
11002 size_t dictstat_nmemb = 0;
11003 #endif
11004
11005 #ifdef _WIN
11006 uint dictstat_nmemb = 0;
11007 #endif
11008
11009 char dictstat[256] = { 0 };
11010
11011 FILE *dictstat_fp = NULL;
11012
11013 if (keyspace == 0)
11014 {
11015 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11016
11017 dictstat_fp = fopen (dictstat, "rb");
11018
11019 if (dictstat_fp)
11020 {
11021 #ifdef _POSIX
11022 struct stat tmpstat;
11023
11024 fstat (fileno (dictstat_fp), &tmpstat);
11025 #endif
11026
11027 #ifdef _WIN
11028 struct stat64 tmpstat;
11029
11030 _fstat64 (fileno (dictstat_fp), &tmpstat);
11031 #endif
11032
11033 if (tmpstat.st_mtime < COMPTIME)
11034 {
11035 /* with v0.15 the format changed so we have to ensure user is using a good version
11036 since there is no version-header in the dictstat file */
11037
11038 fclose (dictstat_fp);
11039
11040 unlink (dictstat);
11041 }
11042 else
11043 {
11044 while (!feof (dictstat_fp))
11045 {
11046 dictstat_t d;
11047
11048 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11049
11050 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11051
11052 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11053 {
11054 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11055
11056 return -1;
11057 }
11058 }
11059
11060 fclose (dictstat_fp);
11061 }
11062 }
11063 }
11064
11065 /**
11066 * potfile
11067 */
11068
11069 char potfile[256] = { 0 };
11070
11071 if (potfile_path == NULL)
11072 {
11073 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11074 }
11075 else
11076 {
11077 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11078 }
11079
11080 data.pot_fp = NULL;
11081
11082 FILE *out_fp = NULL;
11083 FILE *pot_fp = NULL;
11084
11085 if (show == 1 || left == 1)
11086 {
11087 pot_fp = fopen (potfile, "rb");
11088
11089 if (pot_fp == NULL)
11090 {
11091 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11092
11093 return (-1);
11094 }
11095
11096 if (outfile != NULL)
11097 {
11098 if ((out_fp = fopen (outfile, "ab")) == NULL)
11099 {
11100 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11101
11102 fclose (pot_fp);
11103
11104 return (-1);
11105 }
11106 }
11107 else
11108 {
11109 out_fp = stdout;
11110 }
11111 }
11112 else
11113 {
11114 if (potfile_disable == 0)
11115 {
11116 pot_fp = fopen (potfile, "ab");
11117
11118 if (pot_fp == NULL)
11119 {
11120 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11121
11122 return (-1);
11123 }
11124
11125 data.pot_fp = pot_fp;
11126 }
11127 }
11128
11129 pot_t *pot = NULL;
11130
11131 uint pot_cnt = 0;
11132 uint pot_avail = 0;
11133
11134 if (show == 1 || left == 1)
11135 {
11136 SUPPRESS_OUTPUT = 1;
11137
11138 pot_avail = count_lines (pot_fp);
11139
11140 rewind (pot_fp);
11141
11142 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11143
11144 uint pot_hashes_avail = 0;
11145
11146 uint line_num = 0;
11147
11148 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11149
11150 while (!feof (pot_fp))
11151 {
11152 line_num++;
11153
11154 int line_len = fgetl (pot_fp, line_buf);
11155
11156 if (line_len == 0) continue;
11157
11158 char *plain_buf = line_buf + line_len;
11159
11160 pot_t *pot_ptr = &pot[pot_cnt];
11161
11162 hash_t *hashes_buf = &pot_ptr->hash;
11163
11164 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11165 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11166
11167 if (pot_cnt == pot_hashes_avail)
11168 {
11169 uint pos = 0;
11170
11171 for (pos = 0; pos < INCR_POT; pos++)
11172 {
11173 if ((pot_cnt + pos) >= pot_avail) break;
11174
11175 pot_t *tmp_pot = &pot[pot_cnt + pos];
11176
11177 hash_t *tmp_hash = &tmp_pot->hash;
11178
11179 tmp_hash->digest = mymalloc (dgst_size);
11180
11181 if (isSalted)
11182 {
11183 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11184 }
11185
11186 if (esalt_size)
11187 {
11188 tmp_hash->esalt = mymalloc (esalt_size);
11189 }
11190
11191 pot_hashes_avail++;
11192 }
11193 }
11194
11195 int plain_len = 0;
11196
11197 int parser_status;
11198
11199 int iter = MAX_CUT_TRIES;
11200
11201 do
11202 {
11203 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11204 {
11205 if (line_buf[i] == ':')
11206 {
11207 line_len--;
11208
11209 break;
11210 }
11211 }
11212
11213 if (data.hash_mode != 2500)
11214 {
11215 parser_status = parse_func (line_buf, line_len, hashes_buf);
11216 }
11217 else
11218 {
11219 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11220
11221 if (line_len > max_salt_size)
11222 {
11223 parser_status = PARSER_GLOBAL_LENGTH;
11224 }
11225 else
11226 {
11227 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11228
11229 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11230
11231 hashes_buf->salt->salt_len = line_len;
11232
11233 parser_status = PARSER_OK;
11234 }
11235 }
11236
11237 // if NOT parsed without error, we add the ":" to the plain
11238
11239 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11240 {
11241 plain_len++;
11242 plain_buf--;
11243 }
11244
11245 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11246
11247 if (parser_status < PARSER_GLOBAL_ZERO)
11248 {
11249 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11250
11251 continue;
11252 }
11253
11254 if (plain_len >= 255) continue;
11255
11256 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11257
11258 pot_ptr->plain_len = plain_len;
11259
11260 pot_cnt++;
11261 }
11262
11263 myfree (line_buf);
11264
11265 fclose (pot_fp);
11266
11267 SUPPRESS_OUTPUT = 0;
11268
11269 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11270 }
11271
11272 /**
11273 * word len
11274 */
11275
11276 uint pw_min = PW_MIN;
11277 uint pw_max = PW_MAX;
11278
11279 switch (hash_mode)
11280 {
11281 case 125: if (pw_max > 32) pw_max = 32;
11282 break;
11283 case 400: if (pw_max > 40) pw_max = 40;
11284 break;
11285 case 500: if (pw_max > 16) pw_max = 16;
11286 break;
11287 case 1500: if (pw_max > 8) pw_max = 8;
11288 break;
11289 case 1600: if (pw_max > 16) pw_max = 16;
11290 break;
11291 case 1800: if (pw_max > 16) pw_max = 16;
11292 break;
11293 case 2100: if (pw_max > 16) pw_max = 16;
11294 break;
11295 case 2500: if (pw_min < 8) pw_min = 8;
11296 break;
11297 case 3000: if (pw_max > 7) pw_max = 7;
11298 break;
11299 case 5200: if (pw_max > 24) pw_max = 24;
11300 break;
11301 case 5800: if (pw_max > 16) pw_max = 16;
11302 break;
11303 case 6300: if (pw_max > 16) pw_max = 16;
11304 break;
11305 case 7400: if (pw_max > 16) pw_max = 16;
11306 break;
11307 case 7700: if (pw_max > 8) pw_max = 8;
11308 break;
11309 case 7900: if (pw_max > 48) pw_max = 48;
11310 break;
11311 case 8500: if (pw_max > 8) pw_max = 8;
11312 break;
11313 case 8600: if (pw_max > 16) pw_max = 16;
11314 break;
11315 case 9710: pw_min = 5;
11316 pw_max = 5;
11317 break;
11318 case 9810: pw_min = 5;
11319 pw_max = 5;
11320 break;
11321 case 10410: pw_min = 5;
11322 pw_max = 5;
11323 break;
11324 case 10300: if (pw_max < 3) pw_min = 3;
11325 if (pw_max > 40) pw_max = 40;
11326 break;
11327 case 10500: if (pw_max < 3) pw_min = 3;
11328 if (pw_max > 40) pw_max = 40;
11329 break;
11330 case 10700: if (pw_max > 16) pw_max = 16;
11331 break;
11332 case 11300: if (pw_max > 40) pw_max = 40;
11333 break;
11334 case 11600: if (pw_max > 32) pw_max = 32;
11335 break;
11336 case 12500: if (pw_max > 20) pw_max = 20;
11337 break;
11338 case 12800: if (pw_max > 24) pw_max = 24;
11339 break;
11340 }
11341
11342 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11343 {
11344 switch (attack_kern)
11345 {
11346 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11347 break;
11348 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11349 break;
11350 }
11351 }
11352
11353 /**
11354 * charsets : keep them together for more easy maintainnce
11355 */
11356
11357 cs_t mp_sys[6] = { { { 0 }, 0 } };
11358 cs_t mp_usr[4] = { { { 0 }, 0 } };
11359
11360 mp_setup_sys (mp_sys);
11361
11362 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11363 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11364 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11365 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11366
11367 /**
11368 * load hashes, part I: find input mode, count hashes
11369 */
11370
11371 uint hashlist_mode = 0;
11372 uint hashlist_format = HLFMT_HASHCAT;
11373
11374 uint hashes_avail = 0;
11375
11376 if (benchmark == 0)
11377 {
11378 struct stat f;
11379
11380 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11381
11382 if ((hash_mode == 2500) ||
11383 (hash_mode == 5200) ||
11384 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11385 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11386 (hash_mode == 9000))
11387 {
11388 hashlist_mode = HL_MODE_ARG;
11389
11390 char *hashfile = myargv[optind];
11391
11392 data.hashfile = hashfile;
11393
11394 logfile_top_var_string ("target", hashfile);
11395 }
11396
11397 if (hashlist_mode == HL_MODE_ARG)
11398 {
11399 if (hash_mode == 2500)
11400 {
11401 struct stat st;
11402
11403 if (stat (data.hashfile, &st) == -1)
11404 {
11405 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11406
11407 return (-1);
11408 }
11409
11410 hashes_avail = st.st_size / sizeof (hccap_t);
11411 }
11412 else
11413 {
11414 hashes_avail = 1;
11415 }
11416 }
11417 else if (hashlist_mode == HL_MODE_FILE)
11418 {
11419 char *hashfile = myargv[optind];
11420
11421 data.hashfile = hashfile;
11422
11423 logfile_top_var_string ("target", hashfile);
11424
11425 FILE *fp = NULL;
11426
11427 if ((fp = fopen (hashfile, "rb")) == NULL)
11428 {
11429 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11430
11431 return (-1);
11432 }
11433
11434 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11435
11436 hashes_avail = count_lines (fp);
11437
11438 rewind (fp);
11439
11440 if (hashes_avail == 0)
11441 {
11442 log_error ("ERROR: hashfile is empty or corrupt");
11443
11444 fclose (fp);
11445
11446 return (-1);
11447 }
11448
11449 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11450
11451 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11452 {
11453 log_error ("ERROR: remove not supported in native hashfile-format mode");
11454
11455 fclose (fp);
11456
11457 return (-1);
11458 }
11459
11460 fclose (fp);
11461 }
11462 }
11463 else
11464 {
11465 hashlist_mode = HL_MODE_ARG;
11466
11467 hashes_avail = 1;
11468 }
11469
11470 if (hash_mode == 3000) hashes_avail *= 2;
11471
11472 data.hashlist_mode = hashlist_mode;
11473 data.hashlist_format = hashlist_format;
11474
11475 logfile_top_uint (hashlist_mode);
11476 logfile_top_uint (hashlist_format);
11477
11478 /**
11479 * load hashes, part II: allocate required memory, set pointers
11480 */
11481
11482 hash_t *hashes_buf = NULL;
11483 void *digests_buf = NULL;
11484 salt_t *salts_buf = NULL;
11485 void *esalts_buf = NULL;
11486
11487 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11488
11489 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11490
11491 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11492 {
11493 u32 hash_pos;
11494
11495 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11496 {
11497 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11498
11499 hashes_buf[hash_pos].hash_info = hash_info;
11500
11501 if (username && (remove || show || left))
11502 {
11503 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11504 }
11505
11506 if (benchmark)
11507 {
11508 hash_info->orighash = (char *) mymalloc (256);
11509 }
11510 }
11511 }
11512
11513 if (isSalted)
11514 {
11515 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11516
11517 if (esalt_size)
11518 {
11519 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11520 }
11521 }
11522 else
11523 {
11524 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11525 }
11526
11527 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11528 {
11529 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11530
11531 if (isSalted)
11532 {
11533 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11534
11535 if (esalt_size)
11536 {
11537 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11538 }
11539 }
11540 else
11541 {
11542 hashes_buf[hash_pos].salt = &salts_buf[0];
11543 }
11544 }
11545
11546 /**
11547 * load hashes, part III: parse hashes or generate them if benchmark
11548 */
11549
11550 uint hashes_cnt = 0;
11551
11552 if (benchmark == 0)
11553 {
11554 if (keyspace == 1)
11555 {
11556 // useless to read hash file for keyspace, cheat a little bit w/ optind
11557 }
11558 else if (hashes_avail == 0)
11559 {
11560 }
11561 else if (hashlist_mode == HL_MODE_ARG)
11562 {
11563 char *input_buf = myargv[optind];
11564
11565 uint input_len = strlen (input_buf);
11566
11567 logfile_top_var_string ("target", input_buf);
11568
11569 char *hash_buf = NULL;
11570 int hash_len = 0;
11571
11572 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11573
11574 bool hash_fmt_error = 0;
11575
11576 if (hash_len < 1) hash_fmt_error = 1;
11577 if (hash_buf == NULL) hash_fmt_error = 1;
11578
11579 if (hash_fmt_error)
11580 {
11581 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11582 }
11583 else
11584 {
11585 if (opts_type & OPTS_TYPE_HASH_COPY)
11586 {
11587 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11588
11589 hash_info_tmp->orighash = mystrdup (hash_buf);
11590 }
11591
11592 if (isSalted)
11593 {
11594 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11595 }
11596
11597 int parser_status = PARSER_OK;
11598
11599 if (hash_mode == 2500)
11600 {
11601 if (hash_len == 0)
11602 {
11603 log_error ("ERROR: hccap file not specified");
11604
11605 return (-1);
11606 }
11607
11608 hashlist_mode = HL_MODE_FILE;
11609
11610 data.hashlist_mode = hashlist_mode;
11611
11612 FILE *fp = fopen (hash_buf, "rb");
11613
11614 if (fp == NULL)
11615 {
11616 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11617
11618 return (-1);
11619 }
11620
11621 if (hashes_avail < 1)
11622 {
11623 log_error ("ERROR: hccap file is empty or corrupt");
11624
11625 fclose (fp);
11626
11627 return (-1);
11628 }
11629
11630 uint hccap_size = sizeof (hccap_t);
11631
11632 char *in = (char *) mymalloc (hccap_size);
11633
11634 while (!feof (fp))
11635 {
11636 int n = fread (in, hccap_size, 1, fp);
11637
11638 if (n != 1)
11639 {
11640 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11641
11642 break;
11643 }
11644
11645 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11646
11647 if (parser_status != PARSER_OK)
11648 {
11649 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11650
11651 continue;
11652 }
11653
11654 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11655
11656 if ((show == 1) || (left == 1))
11657 {
11658 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11659
11660 char *salt_ptr = (char *) tmp_salt->salt_buf;
11661
11662 int cur_pos = tmp_salt->salt_len;
11663 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11664
11665 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11666
11667 // do the appending task
11668
11669 snprintf (salt_ptr + cur_pos,
11670 rem_len,
11671 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11672 wpa->orig_mac1[0],
11673 wpa->orig_mac1[1],
11674 wpa->orig_mac1[2],
11675 wpa->orig_mac1[3],
11676 wpa->orig_mac1[4],
11677 wpa->orig_mac1[5],
11678 wpa->orig_mac2[0],
11679 wpa->orig_mac2[1],
11680 wpa->orig_mac2[2],
11681 wpa->orig_mac2[3],
11682 wpa->orig_mac2[4],
11683 wpa->orig_mac2[5]);
11684
11685 // memset () the remaining part of the salt
11686
11687 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11688 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11689
11690 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11691
11692 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11693 }
11694
11695 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);
11696 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);
11697
11698 hashes_cnt++;
11699 }
11700
11701 fclose (fp);
11702
11703 myfree (in);
11704 }
11705 else if (hash_mode == 3000)
11706 {
11707 if (hash_len == 32)
11708 {
11709 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11710
11711 hash_t *lm_hash_left = NULL;
11712
11713 if (parser_status == PARSER_OK)
11714 {
11715 lm_hash_left = &hashes_buf[hashes_cnt];
11716
11717 hashes_cnt++;
11718 }
11719 else
11720 {
11721 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11722 }
11723
11724 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11725
11726 hash_t *lm_hash_right = NULL;
11727
11728 if (parser_status == PARSER_OK)
11729 {
11730 lm_hash_right = &hashes_buf[hashes_cnt];
11731
11732 hashes_cnt++;
11733 }
11734 else
11735 {
11736 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11737 }
11738
11739 // show / left
11740
11741 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11742 {
11743 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);
11744 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);
11745 }
11746 }
11747 else
11748 {
11749 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11750
11751 if (parser_status == PARSER_OK)
11752 {
11753 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11754 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11755 }
11756
11757 if (parser_status == PARSER_OK)
11758 {
11759 hashes_cnt++;
11760 }
11761 else
11762 {
11763 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11764 }
11765 }
11766 }
11767 else
11768 {
11769 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11770
11771 if (parser_status == PARSER_OK)
11772 {
11773 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11774 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11775 }
11776
11777 if (parser_status == PARSER_OK)
11778 {
11779 hashes_cnt++;
11780 }
11781 else
11782 {
11783 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11784 }
11785 }
11786 }
11787 }
11788 else if (hashlist_mode == HL_MODE_FILE)
11789 {
11790 char *hashfile = data.hashfile;
11791
11792 FILE *fp;
11793
11794 if ((fp = fopen (hashfile, "rb")) == NULL)
11795 {
11796 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11797
11798 return (-1);
11799 }
11800
11801 uint line_num = 0;
11802
11803 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11804
11805 while (!feof (fp))
11806 {
11807 line_num++;
11808
11809 int line_len = fgetl (fp, line_buf);
11810
11811 if (line_len == 0) continue;
11812
11813 char *hash_buf = NULL;
11814 int hash_len = 0;
11815
11816 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11817
11818 bool hash_fmt_error = 0;
11819
11820 if (hash_len < 1) hash_fmt_error = 1;
11821 if (hash_buf == NULL) hash_fmt_error = 1;
11822
11823 if (hash_fmt_error)
11824 {
11825 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11826
11827 continue;
11828 }
11829
11830 if (username)
11831 {
11832 char *user_buf = NULL;
11833 int user_len = 0;
11834
11835 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11836
11837 if (remove || show)
11838 {
11839 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11840
11841 *user = (user_t *) mymalloc (sizeof (user_t));
11842
11843 user_t *user_ptr = *user;
11844
11845 if (user_buf != NULL)
11846 {
11847 user_ptr->user_name = mystrdup (user_buf);
11848 }
11849 else
11850 {
11851 user_ptr->user_name = mystrdup ("");
11852 }
11853
11854 user_ptr->user_len = user_len;
11855 }
11856 }
11857
11858 if (opts_type & OPTS_TYPE_HASH_COPY)
11859 {
11860 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11861
11862 hash_info_tmp->orighash = mystrdup (hash_buf);
11863 }
11864
11865 if (isSalted)
11866 {
11867 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11868 }
11869
11870 if (hash_mode == 3000)
11871 {
11872 if (hash_len == 32)
11873 {
11874 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11875
11876 if (parser_status < PARSER_GLOBAL_ZERO)
11877 {
11878 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11879
11880 continue;
11881 }
11882
11883 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11884
11885 hashes_cnt++;
11886
11887 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11888
11889 if (parser_status < PARSER_GLOBAL_ZERO)
11890 {
11891 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11892
11893 continue;
11894 }
11895
11896 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11897
11898 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);
11899
11900 hashes_cnt++;
11901
11902 // show / left
11903
11904 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);
11905 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);
11906 }
11907 else
11908 {
11909 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11910
11911 if (parser_status < PARSER_GLOBAL_ZERO)
11912 {
11913 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11914
11915 continue;
11916 }
11917
11918 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);
11919
11920 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11921 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11922
11923 hashes_cnt++;
11924 }
11925 }
11926 else
11927 {
11928 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11929
11930 if (parser_status < PARSER_GLOBAL_ZERO)
11931 {
11932 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11933
11934 continue;
11935 }
11936
11937 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);
11938
11939 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11940 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11941
11942 hashes_cnt++;
11943 }
11944 }
11945
11946 myfree (line_buf);
11947
11948 fclose (fp);
11949
11950 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11951
11952 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11953 }
11954 }
11955 else
11956 {
11957 if (isSalted)
11958 {
11959 hashes_buf[0].salt->salt_len = 8;
11960
11961 // special salt handling
11962
11963 switch (hash_mode)
11964 {
11965 case 1500: hashes_buf[0].salt->salt_len = 2;
11966 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11967 break;
11968 case 1731: hashes_buf[0].salt->salt_len = 4;
11969 break;
11970 case 2410: hashes_buf[0].salt->salt_len = 4;
11971 break;
11972 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11973 break;
11974 case 3100: hashes_buf[0].salt->salt_len = 1;
11975 break;
11976 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11977 break;
11978 case 5800: hashes_buf[0].salt->salt_len = 16;
11979 break;
11980 case 6800: hashes_buf[0].salt->salt_len = 32;
11981 break;
11982 case 8400: hashes_buf[0].salt->salt_len = 40;
11983 break;
11984 case 8800: hashes_buf[0].salt->salt_len = 16;
11985 break;
11986 case 8900: hashes_buf[0].salt->salt_len = 16;
11987 hashes_buf[0].salt->scrypt_N = 1024;
11988 hashes_buf[0].salt->scrypt_r = 1;
11989 hashes_buf[0].salt->scrypt_p = 1;
11990 break;
11991 case 9100: hashes_buf[0].salt->salt_len = 16;
11992 break;
11993 case 9300: hashes_buf[0].salt->salt_len = 14;
11994 hashes_buf[0].salt->scrypt_N = 16384;
11995 hashes_buf[0].salt->scrypt_r = 1;
11996 hashes_buf[0].salt->scrypt_p = 1;
11997 break;
11998 case 9400: hashes_buf[0].salt->salt_len = 16;
11999 break;
12000 case 9500: hashes_buf[0].salt->salt_len = 16;
12001 break;
12002 case 9600: hashes_buf[0].salt->salt_len = 16;
12003 break;
12004 case 9700: hashes_buf[0].salt->salt_len = 16;
12005 break;
12006 case 9710: hashes_buf[0].salt->salt_len = 16;
12007 break;
12008 case 9720: hashes_buf[0].salt->salt_len = 16;
12009 break;
12010 case 9800: hashes_buf[0].salt->salt_len = 16;
12011 break;
12012 case 9810: hashes_buf[0].salt->salt_len = 16;
12013 break;
12014 case 9820: hashes_buf[0].salt->salt_len = 16;
12015 break;
12016 case 10300: hashes_buf[0].salt->salt_len = 12;
12017 break;
12018 case 11500: hashes_buf[0].salt->salt_len = 4;
12019 break;
12020 case 11600: hashes_buf[0].salt->salt_len = 4;
12021 break;
12022 case 12400: hashes_buf[0].salt->salt_len = 4;
12023 break;
12024 case 12500: hashes_buf[0].salt->salt_len = 8;
12025 break;
12026 case 12600: hashes_buf[0].salt->salt_len = 64;
12027 break;
12028 }
12029
12030 // special esalt handling
12031
12032 switch (hash_mode)
12033 {
12034 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12035 break;
12036 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12037 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12038 break;
12039 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12040 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12041 break;
12042 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12043 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12044 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12045 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12046 break;
12047 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12048 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12049 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12050 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12051 break;
12052 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12053 break;
12054 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12055 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12056 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12057 break;
12058 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12059 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12060 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12061 break;
12062 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12063 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12064 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12065 break;
12066 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12067 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12068 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12069 break;
12070 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12071 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12072 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12073 break;
12074 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12075 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12076 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12077 break;
12078 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12079 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12080 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12081 break;
12082 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12083 break;
12084 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12085 break;
12086 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12087 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12088 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12089 break;
12090 }
12091 }
12092
12093 // set hashfile
12094
12095 switch (hash_mode)
12096 {
12097 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12098 break;
12099 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12100 break;
12101 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12102 break;
12103 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12104 break;
12105 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12106 break;
12107 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12108 break;
12109 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12110 break;
12111 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12112 break;
12113 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12114 break;
12115 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12116 break;
12117 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12118 break;
12119 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12120 break;
12121 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12122 break;
12123 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12124 break;
12125 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12126 break;
12127 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12128 break;
12129 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12130 break;
12131 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12132 break;
12133 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12134 break;
12135 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12136 break;
12137 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12138 break;
12139 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12140 break;
12141 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12142 break;
12143 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12144 break;
12145 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12146 break;
12147 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12148 break;
12149 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12150 break;
12151 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12152 break;
12153 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12154 break;
12155 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12156 break;
12157 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12158 break;
12159 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12160 break;
12161 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12162 break;
12163 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12164 break;
12165 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12166 break;
12167 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12168 break;
12169 }
12170
12171 // set default iterations
12172
12173 switch (hash_mode)
12174 {
12175 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12176 break;
12177 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12178 break;
12179 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12180 break;
12181 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12182 break;
12183 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12184 break;
12185 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12186 break;
12187 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12188 break;
12189 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12190 break;
12191 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12192 break;
12193 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12194 break;
12195 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12196 break;
12197 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12198 break;
12199 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12200 break;
12201 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12202 break;
12203 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12204 break;
12205 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12206 break;
12207 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12208 break;
12209 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12210 break;
12211 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12212 break;
12213 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12214 break;
12215 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12216 break;
12217 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12218 break;
12219 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12220 break;
12221 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12222 break;
12223 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12224 break;
12225 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12226 break;
12227 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12228 break;
12229 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12230 break;
12231 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12232 break;
12233 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12234 break;
12235 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12236 break;
12237 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12238 break;
12239 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12240 break;
12241 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12242 break;
12243 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12244 break;
12245 case 8900: hashes_buf[0].salt->salt_iter = 1;
12246 break;
12247 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12248 break;
12249 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12250 break;
12251 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12252 break;
12253 case 9300: hashes_buf[0].salt->salt_iter = 1;
12254 break;
12255 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12256 break;
12257 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12258 break;
12259 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12260 break;
12261 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12262 break;
12263 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12264 break;
12265 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12266 break;
12267 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12268 break;
12269 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12270 break;
12271 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12272 break;
12273 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12274 break;
12275 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12276 break;
12277 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12278 break;
12279 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12280 break;
12281 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12282 break;
12283 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12284 break;
12285 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12286 break;
12287 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12288 break;
12289 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12290 break;
12291 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12292 break;
12293 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12294 break;
12295 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12296 break;
12297 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12298 break;
12299 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12300 break;
12301 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12302 break;
12303 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12304 break;
12305 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12306 break;
12307 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12308 break;
12309 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12310 break;
12311 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12312 break;
12313 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12314 break;
12315 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12316 break;
12317 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12318 break;
12319 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12320 break;
12321 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12322 break;
12323 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12324 break;
12325 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12326 break;
12327 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12328 break;
12329 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12330 break;
12331 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12332 break;
12333 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12334 break;
12335 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12336 break;
12337 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12338 break;
12339 }
12340
12341 hashes_cnt = 1;
12342 }
12343
12344 if (show == 1 || left == 1)
12345 {
12346 for (uint i = 0; i < pot_cnt; i++)
12347 {
12348 pot_t *pot_ptr = &pot[i];
12349
12350 hash_t *hashes_buf = &pot_ptr->hash;
12351
12352 local_free (hashes_buf->digest);
12353
12354 if (isSalted)
12355 {
12356 local_free (hashes_buf->salt);
12357 }
12358 }
12359
12360 local_free (pot);
12361
12362 if (data.quiet == 0) log_info_nn ("");
12363
12364 return (0);
12365 }
12366
12367 if (keyspace == 0)
12368 {
12369 if (hashes_cnt == 0)
12370 {
12371 log_error ("ERROR: No hashes loaded");
12372
12373 return (-1);
12374 }
12375 }
12376
12377 /**
12378 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12379 */
12380
12381 if (data.outfile != NULL)
12382 {
12383 if (data.hashfile != NULL)
12384 {
12385 #ifdef _POSIX
12386 struct stat tmpstat_outfile;
12387 struct stat tmpstat_hashfile;
12388 #endif
12389
12390 #ifdef _WIN
12391 struct stat64 tmpstat_outfile;
12392 struct stat64 tmpstat_hashfile;
12393 #endif
12394
12395 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12396
12397 if (tmp_outfile_fp)
12398 {
12399 #ifdef _POSIX
12400 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12401 #endif
12402
12403 #ifdef _WIN
12404 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12405 #endif
12406
12407 fclose (tmp_outfile_fp);
12408 }
12409
12410 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12411
12412 if (tmp_hashfile_fp)
12413 {
12414 #ifdef _POSIX
12415 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12416 #endif
12417
12418 #ifdef _WIN
12419 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12420 #endif
12421
12422 fclose (tmp_hashfile_fp);
12423 }
12424
12425 if (tmp_outfile_fp && tmp_outfile_fp)
12426 {
12427 tmpstat_outfile.st_mode = 0;
12428 tmpstat_outfile.st_nlink = 0;
12429 tmpstat_outfile.st_uid = 0;
12430 tmpstat_outfile.st_gid = 0;
12431 tmpstat_outfile.st_rdev = 0;
12432 tmpstat_outfile.st_atime = 0;
12433
12434 tmpstat_hashfile.st_mode = 0;
12435 tmpstat_hashfile.st_nlink = 0;
12436 tmpstat_hashfile.st_uid = 0;
12437 tmpstat_hashfile.st_gid = 0;
12438 tmpstat_hashfile.st_rdev = 0;
12439 tmpstat_hashfile.st_atime = 0;
12440
12441 #ifdef _POSIX
12442 tmpstat_outfile.st_blksize = 0;
12443 tmpstat_outfile.st_blocks = 0;
12444
12445 tmpstat_hashfile.st_blksize = 0;
12446 tmpstat_hashfile.st_blocks = 0;
12447 #endif
12448
12449 #ifdef _POSIX
12450 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12451 {
12452 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12453
12454 return (-1);
12455 }
12456 #endif
12457
12458 #ifdef _WIN
12459 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 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 }
12468 }
12469
12470 /**
12471 * Remove duplicates
12472 */
12473
12474 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12475
12476 if (isSalted)
12477 {
12478 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12479 }
12480 else
12481 {
12482 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12483 }
12484
12485 uint hashes_cnt_orig = hashes_cnt;
12486
12487 hashes_cnt = 1;
12488
12489 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12490 {
12491 if (isSalted)
12492 {
12493 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12494 {
12495 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12496 }
12497 }
12498 else
12499 {
12500 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12501 }
12502
12503 if (hashes_pos > hashes_cnt)
12504 {
12505 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12506 }
12507
12508 hashes_cnt++;
12509 }
12510
12511 /**
12512 * Potfile removes
12513 */
12514
12515 uint potfile_remove_cracks = 0;
12516
12517 if (potfile_disable == 0)
12518 {
12519 hash_t hash_buf;
12520
12521 hash_buf.digest = mymalloc (dgst_size);
12522 hash_buf.salt = NULL;
12523 hash_buf.esalt = NULL;
12524 hash_buf.hash_info = NULL;
12525 hash_buf.cracked = 0;
12526
12527 if (isSalted)
12528 {
12529 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12530 }
12531
12532 if (esalt_size)
12533 {
12534 hash_buf.esalt = mymalloc (esalt_size);
12535 }
12536
12537 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12538
12539 // no solution for these special hash types (for instane because they use hashfile in output etc)
12540 if ((hash_mode != 5200) &&
12541 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12542 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12543 (hash_mode != 9000))
12544 {
12545 FILE *fp = fopen (potfile, "rb");
12546
12547 if (fp != NULL)
12548 {
12549 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12550
12551 // to be safe work with a copy (because of line_len loop, i etc)
12552 // moved up here because it's easier to handle continue case
12553 // it's just 64kb
12554
12555 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12556
12557 while (!feof (fp))
12558 {
12559 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12560
12561 if (ptr == NULL) break;
12562
12563 int line_len = strlen (line_buf);
12564
12565 if (line_len == 0) continue;
12566
12567 int iter = MAX_CUT_TRIES;
12568
12569 for (int i = line_len - 1; i && iter; i--, line_len--)
12570 {
12571 if (line_buf[i] != ':') continue;
12572
12573 if (isSalted)
12574 {
12575 memset (hash_buf.salt, 0, sizeof (salt_t));
12576 }
12577
12578 hash_t *found = NULL;
12579
12580 if (hash_mode == 6800)
12581 {
12582 if (i < 64) // 64 = 16 * uint in salt_buf[]
12583 {
12584 // manipulate salt_buf
12585 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12586
12587 hash_buf.salt->salt_len = i;
12588
12589 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12590 }
12591 }
12592 else if (hash_mode == 2500)
12593 {
12594 if (i < 64) // 64 = 16 * uint in salt_buf[]
12595 {
12596 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12597 // manipulate salt_buf
12598
12599 memcpy (line_buf_cpy, line_buf, i);
12600
12601 char *mac2_pos = strrchr (line_buf_cpy, ':');
12602
12603 if (mac2_pos == NULL) continue;
12604
12605 mac2_pos[0] = 0;
12606 mac2_pos++;
12607
12608 if (strlen (mac2_pos) != 12) continue;
12609
12610 char *mac1_pos = strrchr (line_buf_cpy, ':');
12611
12612 if (mac1_pos == NULL) continue;
12613
12614 mac1_pos[0] = 0;
12615 mac1_pos++;
12616
12617 if (strlen (mac1_pos) != 12) continue;
12618
12619 uint essid_length = mac1_pos - line_buf_cpy - 1;
12620
12621 // here we need the ESSID
12622 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12623
12624 hash_buf.salt->salt_len = essid_length;
12625
12626 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12627
12628 if (found)
12629 {
12630 wpa_t *wpa = (wpa_t *) found->esalt;
12631
12632 // compare hex string(s) vs binary MAC address(es)
12633
12634 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12635 {
12636 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12637 {
12638 found = NULL;
12639
12640 break;
12641 }
12642 }
12643
12644 // early skip ;)
12645 if (!found) continue;
12646
12647 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12648 {
12649 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12650 {
12651 found = NULL;
12652
12653 break;
12654 }
12655 }
12656 }
12657 }
12658 }
12659 else
12660 {
12661 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12662
12663 if (parser_status == PARSER_OK)
12664 {
12665 if (isSalted)
12666 {
12667 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12668 }
12669 else
12670 {
12671 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12672 }
12673 }
12674 }
12675
12676 if (found == NULL) continue;
12677
12678 if (!found->cracked) potfile_remove_cracks++;
12679
12680 found->cracked = 1;
12681
12682 if (found) break;
12683
12684 iter--;
12685 }
12686 }
12687
12688 myfree (line_buf_cpy);
12689
12690 myfree (line_buf);
12691
12692 fclose (fp);
12693 }
12694 }
12695
12696 if (esalt_size)
12697 {
12698 local_free (hash_buf.esalt);
12699 }
12700
12701 if (isSalted)
12702 {
12703 local_free (hash_buf.salt);
12704 }
12705
12706 local_free (hash_buf.digest);
12707 }
12708
12709 /**
12710 * Now generate all the buffers required for later
12711 */
12712
12713 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12714
12715 salt_t *salts_buf_new = NULL;
12716 void *esalts_buf_new = NULL;
12717
12718 if (isSalted)
12719 {
12720 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12721
12722 if (esalt_size)
12723 {
12724 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12725 }
12726 }
12727 else
12728 {
12729 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12730 }
12731
12732 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12733
12734 uint digests_cnt = hashes_cnt;
12735 uint digests_done = 0;
12736
12737 size_t size_digests = digests_cnt * dgst_size;
12738 size_t size_shown = digests_cnt * sizeof (uint);
12739
12740 uint *digests_shown = (uint *) mymalloc (size_shown);
12741 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12742
12743 uint salts_cnt = 0;
12744 uint salts_done = 0;
12745
12746 hashinfo_t **hash_info = NULL;
12747
12748 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12749 {
12750 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12751
12752 if (username && (remove || show))
12753 {
12754 uint user_pos;
12755
12756 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12757 {
12758 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12759
12760 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12761 }
12762 }
12763 }
12764
12765 uint *salts_shown = (uint *) mymalloc (size_shown);
12766
12767 salt_t *salt_buf;
12768
12769 {
12770 // copied from inner loop
12771
12772 salt_buf = &salts_buf_new[salts_cnt];
12773
12774 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12775
12776 if (esalt_size)
12777 {
12778 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12779 }
12780
12781 salt_buf->digests_cnt = 0;
12782 salt_buf->digests_done = 0;
12783 salt_buf->digests_offset = 0;
12784
12785 salts_cnt++;
12786 }
12787
12788 if (hashes_buf[0].cracked == 1)
12789 {
12790 digests_shown[0] = 1;
12791
12792 digests_done++;
12793
12794 salt_buf->digests_done++;
12795 }
12796
12797 salt_buf->digests_cnt++;
12798
12799 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12800
12801 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12802 {
12803 hash_info[0] = hashes_buf[0].hash_info;
12804 }
12805
12806 // copy from inner loop
12807
12808 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12809 {
12810 if (isSalted)
12811 {
12812 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12813 {
12814 salt_buf = &salts_buf_new[salts_cnt];
12815
12816 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12817
12818 if (esalt_size)
12819 {
12820 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12821 }
12822
12823 salt_buf->digests_cnt = 0;
12824 salt_buf->digests_done = 0;
12825 salt_buf->digests_offset = hashes_pos;
12826
12827 salts_cnt++;
12828 }
12829 }
12830
12831 if (hashes_buf[hashes_pos].cracked == 1)
12832 {
12833 digests_shown[hashes_pos] = 1;
12834
12835 digests_done++;
12836
12837 salt_buf->digests_done++;
12838 }
12839
12840 salt_buf->digests_cnt++;
12841
12842 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12843
12844 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12845 {
12846 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12847 }
12848 }
12849
12850 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12851 {
12852 salt_t *salt_buf = &salts_buf_new[salt_pos];
12853
12854 if (salt_buf->digests_done == salt_buf->digests_cnt)
12855 {
12856 salts_shown[salt_pos] = 1;
12857
12858 salts_done++;
12859 }
12860
12861 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12862 }
12863
12864 local_free (digests_buf);
12865 local_free (salts_buf);
12866 local_free (esalts_buf);
12867
12868 digests_buf = digests_buf_new;
12869 salts_buf = salts_buf_new;
12870 esalts_buf = esalts_buf_new;
12871
12872 local_free (hashes_buf);
12873
12874 /**
12875 * special modification not set from parser
12876 */
12877
12878 switch (hash_mode)
12879 {
12880 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12881 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12882 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12883 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12884 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12885 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12886 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12887 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12888 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12889 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12890 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12891 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12892 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12893 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12894 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12895 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12896 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12897 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12898 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12899 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12900 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12901 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12902 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12903 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12904 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12905 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12906 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12907 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12908 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12909 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12910 }
12911
12912 if (truecrypt_keyfiles)
12913 {
12914 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12915
12916 char *keyfiles = strdup (truecrypt_keyfiles);
12917
12918 char *keyfile = strtok (keyfiles, ",");
12919
12920 do
12921 {
12922 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12923
12924 } while ((keyfile = strtok (NULL, ",")) != NULL);
12925
12926 free (keyfiles);
12927 }
12928
12929 if (veracrypt_keyfiles)
12930 {
12931 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12932
12933 char *keyfiles = strdup (veracrypt_keyfiles);
12934
12935 char *keyfile = strtok (keyfiles, ",");
12936
12937 do
12938 {
12939 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12940
12941 } while ((keyfile = strtok (NULL, ",")) != NULL);
12942
12943 free (keyfiles);
12944 }
12945
12946 data.digests_cnt = digests_cnt;
12947 data.digests_done = digests_done;
12948 data.digests_buf = digests_buf;
12949 data.digests_shown = digests_shown;
12950 data.digests_shown_tmp = digests_shown_tmp;
12951
12952 data.salts_cnt = salts_cnt;
12953 data.salts_done = salts_done;
12954 data.salts_buf = salts_buf;
12955 data.salts_shown = salts_shown;
12956
12957 data.esalts_buf = esalts_buf;
12958 data.hash_info = hash_info;
12959
12960 /**
12961 * Automatic Optimizers
12962 */
12963
12964 if (salts_cnt == 1)
12965 opti_type |= OPTI_TYPE_SINGLE_SALT;
12966
12967 if (digests_cnt == 1)
12968 opti_type |= OPTI_TYPE_SINGLE_HASH;
12969
12970 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12971 opti_type |= OPTI_TYPE_NOT_ITERATED;
12972
12973 if (attack_mode == ATTACK_MODE_BF)
12974 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12975
12976 data.opti_type = opti_type;
12977
12978 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12979 {
12980 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12981 {
12982 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12983 {
12984 if (opts_type & OPTS_TYPE_ST_ADD80)
12985 {
12986 opts_type &= ~OPTS_TYPE_ST_ADD80;
12987 opts_type |= OPTS_TYPE_PT_ADD80;
12988 }
12989
12990 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12991 {
12992 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12993 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12994 }
12995
12996 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12997 {
12998 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12999 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13000 }
13001 }
13002 }
13003 }
13004
13005 /**
13006 * Some algorithm, like descrypt, can benefit from JIT compilation
13007 */
13008
13009 int force_jit_compilation = -1;
13010
13011 if (hash_mode == 8900)
13012 {
13013 force_jit_compilation = 8900;
13014 }
13015 else if (hash_mode == 9300)
13016 {
13017 force_jit_compilation = 8900;
13018 }
13019 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13020 {
13021 force_jit_compilation = 1500;
13022 }
13023
13024 /**
13025 * generate bitmap tables
13026 */
13027
13028 const uint bitmap_shift1 = 5;
13029 const uint bitmap_shift2 = 13;
13030
13031 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13032
13033 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13034 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13035 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13036 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13037 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13038 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13039 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13040 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13041
13042 uint bitmap_bits;
13043 uint bitmap_nums;
13044 uint bitmap_mask;
13045 uint bitmap_size;
13046
13047 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13048 {
13049 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13050
13051 bitmap_nums = 1 << bitmap_bits;
13052
13053 bitmap_mask = bitmap_nums - 1;
13054
13055 bitmap_size = bitmap_nums * sizeof (uint);
13056
13057 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13058
13059 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;
13060 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;
13061
13062 break;
13063 }
13064
13065 bitmap_nums = 1 << bitmap_bits;
13066
13067 bitmap_mask = bitmap_nums - 1;
13068
13069 bitmap_size = bitmap_nums * sizeof (uint);
13070
13071 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);
13072 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);
13073
13074 /**
13075 * prepare quick rule
13076 */
13077
13078 data.rule_buf_l = rule_buf_l;
13079 data.rule_buf_r = rule_buf_r;
13080
13081 int rule_len_l = (int) strlen (rule_buf_l);
13082 int rule_len_r = (int) strlen (rule_buf_r);
13083
13084 data.rule_len_l = rule_len_l;
13085 data.rule_len_r = rule_len_r;
13086
13087 /**
13088 * load rules
13089 */
13090
13091 uint *all_kernel_rules_cnt = NULL;
13092
13093 kernel_rule_t **all_kernel_rules_buf = NULL;
13094
13095 if (rp_files_cnt)
13096 {
13097 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13098
13099 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13100 }
13101
13102 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13103
13104 int rule_len = 0;
13105
13106 for (uint i = 0; i < rp_files_cnt; i++)
13107 {
13108 uint kernel_rules_avail = 0;
13109
13110 uint kernel_rules_cnt = 0;
13111
13112 kernel_rule_t *kernel_rules_buf = NULL;
13113
13114 char *rp_file = rp_files[i];
13115
13116 char in[BLOCK_SIZE] = { 0 };
13117 char out[BLOCK_SIZE] = { 0 };
13118
13119 FILE *fp = NULL;
13120
13121 uint rule_line = 0;
13122
13123 if ((fp = fopen (rp_file, "rb")) == NULL)
13124 {
13125 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13126
13127 return (-1);
13128 }
13129
13130 while (!feof (fp))
13131 {
13132 memset (rule_buf, 0, HCBUFSIZ);
13133
13134 rule_len = fgetl (fp, rule_buf);
13135
13136 rule_line++;
13137
13138 if (rule_len == 0) continue;
13139
13140 if (rule_buf[0] == '#') continue;
13141
13142 if (kernel_rules_avail == kernel_rules_cnt)
13143 {
13144 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13145
13146 kernel_rules_avail += INCR_RULES;
13147 }
13148
13149 memset (in, 0, BLOCK_SIZE);
13150 memset (out, 0, BLOCK_SIZE);
13151
13152 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13153
13154 if (result == -1)
13155 {
13156 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13157
13158 continue;
13159 }
13160
13161 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13162 {
13163 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13164
13165 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13166
13167 continue;
13168 }
13169
13170 /* its so slow
13171 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13172 {
13173 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13174
13175 continue;
13176 }
13177 */
13178
13179 kernel_rules_cnt++;
13180 }
13181
13182 fclose (fp);
13183
13184 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13185
13186 all_kernel_rules_buf[i] = kernel_rules_buf;
13187 }
13188
13189 /**
13190 * merge rules or automatic rule generator
13191 */
13192
13193 uint kernel_rules_cnt = 0;
13194
13195 kernel_rule_t *kernel_rules_buf = NULL;
13196
13197 if (attack_mode == ATTACK_MODE_STRAIGHT)
13198 {
13199 if (rp_files_cnt)
13200 {
13201 kernel_rules_cnt = 1;
13202
13203 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13204
13205 repeats[0] = kernel_rules_cnt;
13206
13207 for (uint i = 0; i < rp_files_cnt; i++)
13208 {
13209 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13210
13211 repeats[i + 1] = kernel_rules_cnt;
13212 }
13213
13214 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13215
13216 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13217
13218 for (uint i = 0; i < kernel_rules_cnt; i++)
13219 {
13220 uint out_pos = 0;
13221
13222 kernel_rule_t *out = &kernel_rules_buf[i];
13223
13224 for (uint j = 0; j < rp_files_cnt; j++)
13225 {
13226 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13227 uint in_pos;
13228
13229 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13230
13231 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13232 {
13233 if (out_pos == RULES_MAX - 1)
13234 {
13235 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13236
13237 break;
13238 }
13239
13240 out->cmds[out_pos] = in->cmds[in_pos];
13241 }
13242 }
13243 }
13244
13245 local_free (repeats);
13246 }
13247 else if (rp_gen)
13248 {
13249 uint kernel_rules_avail = 0;
13250
13251 while (kernel_rules_cnt < rp_gen)
13252 {
13253 if (kernel_rules_avail == kernel_rules_cnt)
13254 {
13255 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13256
13257 kernel_rules_avail += INCR_RULES;
13258 }
13259
13260 memset (rule_buf, 0, HCBUFSIZ);
13261
13262 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13263
13264 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13265
13266 kernel_rules_cnt++;
13267 }
13268 }
13269 }
13270
13271 myfree (rule_buf);
13272
13273 /**
13274 * generate NOP rules
13275 */
13276
13277 if (kernel_rules_cnt == 0)
13278 {
13279 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13280
13281 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13282
13283 kernel_rules_cnt++;
13284 }
13285
13286 data.kernel_rules_cnt = kernel_rules_cnt;
13287 data.kernel_rules_buf = kernel_rules_buf;
13288
13289 /**
13290 * OpenCL platforms: detect
13291 */
13292
13293 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13294 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13295
13296 cl_uint platforms_cnt = 0;
13297 cl_uint platform_devices_cnt = 0;
13298
13299 if (keyspace == 0)
13300 {
13301 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13302
13303 if (platforms_cnt == 0)
13304 {
13305 log_info ("");
13306 log_info ("ATTENTION! No OpenCL compatible platform found");
13307 log_info ("");
13308 log_info ("You're probably missing the OpenCL runtime installation");
13309 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13310 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13311 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13312 log_info ("");
13313
13314 return (-1);
13315 }
13316
13317 if (opencl_platforms_filter != (uint) -1)
13318 {
13319 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13320
13321 if (opencl_platforms_filter > platform_cnt_mask)
13322 {
13323 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13324
13325 return (-1);
13326 }
13327 }
13328 }
13329
13330 /**
13331 * OpenCL device types:
13332 * 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.
13333 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13334 */
13335
13336 if (opencl_device_types == NULL)
13337 {
13338 cl_device_type device_types_all = 0;
13339
13340 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13341 {
13342 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13343
13344 cl_platform_id platform = platforms[platform_id];
13345
13346 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13347
13348 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13349 {
13350 cl_device_id device = platform_devices[platform_devices_id];
13351
13352 cl_device_type device_type;
13353
13354 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13355
13356 device_types_all |= device_type;
13357 }
13358 }
13359
13360 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13361 {
13362 device_types_filter |= CL_DEVICE_TYPE_CPU;
13363 }
13364 }
13365
13366 /**
13367 * OpenCL devices: simply push all devices from all platforms into the same device array
13368 */
13369
13370 int need_adl = 0;
13371 int need_nvapi = 0;
13372 int need_nvml = 0;
13373
13374 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13375
13376 data.devices_param = devices_param;
13377
13378 uint devices_cnt = 0;
13379
13380 uint devices_active = 0;
13381
13382 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13383 {
13384 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13385
13386 cl_platform_id platform = platforms[platform_id];
13387
13388 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13389
13390 char platform_vendor[INFOSZ] = { 0 };
13391
13392 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13393
13394 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13395 // this causes trouble with vendor id based macros
13396 // we'll assign generic to those without special optimization available
13397
13398 cl_uint platform_vendor_id = 0;
13399
13400 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13401 {
13402 platform_vendor_id = VENDOR_ID_AMD;
13403 }
13404 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13405 {
13406 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13407 }
13408 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13409 {
13410 platform_vendor_id = VENDOR_ID_APPLE;
13411 }
13412 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13413 {
13414 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13415 }
13416 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13417 {
13418 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13419 }
13420 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13421 {
13422 platform_vendor_id = VENDOR_ID_MESA;
13423 }
13424 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13425 {
13426 platform_vendor_id = VENDOR_ID_NV;
13427 }
13428 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13429 {
13430 platform_vendor_id = VENDOR_ID_POCL;
13431 }
13432 else
13433 {
13434 platform_vendor_id = VENDOR_ID_GENERIC;
13435 }
13436
13437 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13438 {
13439 size_t param_value_size = 0;
13440
13441 const uint device_id = devices_cnt;
13442
13443 hc_device_param_t *device_param = &data.devices_param[device_id];
13444
13445 device_param->platform_vendor_id = platform_vendor_id;
13446
13447 device_param->device = platform_devices[platform_devices_id];
13448
13449 device_param->device_id = device_id;
13450
13451 device_param->platform_devices_id = platform_devices_id;
13452
13453 // device_type
13454
13455 cl_device_type device_type;
13456
13457 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13458
13459 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13460
13461 device_param->device_type = device_type;
13462
13463 // device_name
13464
13465 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13466
13467 char *device_name = (char *) mymalloc (param_value_size);
13468
13469 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13470
13471 device_param->device_name = device_name;
13472
13473 // device_vendor
13474
13475 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13476
13477 char *device_vendor = (char *) mymalloc (param_value_size);
13478
13479 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13480
13481 device_param->device_vendor = device_vendor;
13482
13483 cl_uint device_vendor_id = 0;
13484
13485 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13486 {
13487 device_vendor_id = VENDOR_ID_AMD;
13488 }
13489 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13490 {
13491 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13492 }
13493 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13494 {
13495 device_vendor_id = VENDOR_ID_APPLE;
13496 }
13497 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13498 {
13499 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13500 }
13501 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13502 {
13503 device_vendor_id = VENDOR_ID_INTEL_SDK;
13504 }
13505 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13506 {
13507 device_vendor_id = VENDOR_ID_MESA;
13508 }
13509 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13510 {
13511 device_vendor_id = VENDOR_ID_NV;
13512 }
13513 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13514 {
13515 device_vendor_id = VENDOR_ID_POCL;
13516 }
13517 else
13518 {
13519 device_vendor_id = VENDOR_ID_GENERIC;
13520 }
13521
13522 device_param->device_vendor_id = device_vendor_id;
13523
13524 // tuning db
13525
13526 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13527
13528 // device_version
13529
13530 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13531
13532 char *device_version = (char *) mymalloc (param_value_size);
13533
13534 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13535
13536 device_param->device_version = device_version;
13537
13538 // device_opencl_version
13539
13540 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13541
13542 char *device_opencl_version = (char *) mymalloc (param_value_size);
13543
13544 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13545
13546 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13547
13548 myfree (device_opencl_version);
13549
13550 // vector_width
13551
13552 cl_uint vector_width;
13553
13554 if (opencl_vector_width_chgd == 0)
13555 {
13556 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13557 {
13558 if (opti_type & OPTI_TYPE_USES_BITS_64)
13559 {
13560 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13561 }
13562 else
13563 {
13564 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13565 }
13566 }
13567 else
13568 {
13569 vector_width = (cl_uint) tuningdb_entry->vector_width;
13570 }
13571 }
13572 else
13573 {
13574 vector_width = opencl_vector_width;
13575 }
13576
13577 if (vector_width > 16) vector_width = 16;
13578
13579 device_param->vector_width = vector_width;
13580
13581 // max_compute_units
13582
13583 cl_uint device_processors;
13584
13585 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13586
13587 device_param->device_processors = device_processors;
13588
13589 // device_maxmem_alloc
13590 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13591
13592 cl_ulong device_maxmem_alloc;
13593
13594 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13595
13596 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13597
13598 // device_global_mem
13599
13600 cl_ulong device_global_mem;
13601
13602 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13603
13604 device_param->device_global_mem = device_global_mem;
13605
13606 // max_work_group_size
13607
13608 size_t device_maxworkgroup_size;
13609
13610 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13611
13612 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13613
13614 // max_clock_frequency
13615
13616 cl_uint device_maxclock_frequency;
13617
13618 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13619
13620 device_param->device_maxclock_frequency = device_maxclock_frequency;
13621
13622 // device_endian_little
13623
13624 cl_bool device_endian_little;
13625
13626 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13627
13628 if (device_endian_little == CL_FALSE)
13629 {
13630 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13631
13632 device_param->skipped = 1;
13633 }
13634
13635 // device_available
13636
13637 cl_bool device_available;
13638
13639 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13640
13641 if (device_available == CL_FALSE)
13642 {
13643 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13644
13645 device_param->skipped = 1;
13646 }
13647
13648 // device_compiler_available
13649
13650 cl_bool device_compiler_available;
13651
13652 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13653
13654 if (device_compiler_available == CL_FALSE)
13655 {
13656 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13657
13658 device_param->skipped = 1;
13659 }
13660
13661 // device_execution_capabilities
13662
13663 cl_device_exec_capabilities device_execution_capabilities;
13664
13665 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13666
13667 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13668 {
13669 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13670
13671 device_param->skipped = 1;
13672 }
13673
13674 // device_extensions
13675
13676 size_t device_extensions_size;
13677
13678 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13679
13680 char *device_extensions = mymalloc (device_extensions_size + 1);
13681
13682 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13683
13684 if (strstr (device_extensions, "base_atomics") == 0)
13685 {
13686 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13687
13688 device_param->skipped = 1;
13689 }
13690
13691 if (strstr (device_extensions, "byte_addressable_store") == 0)
13692 {
13693 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13694
13695 device_param->skipped = 1;
13696 }
13697
13698 myfree (device_extensions);
13699
13700 // device_local_mem_size
13701
13702 cl_ulong device_local_mem_size;
13703
13704 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13705
13706 if (device_local_mem_size < 32768)
13707 {
13708 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13709
13710 device_param->skipped = 1;
13711 }
13712
13713 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13714 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13715 // This results in both utilizing it for 50%
13716 // However, Intel has much better SIMD control over their own hardware
13717 // It makes sense to give them full control over their own hardware
13718
13719 if (device_type & CL_DEVICE_TYPE_CPU)
13720 {
13721 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13722 {
13723 if (data.force == 0)
13724 {
13725 if (algorithm_pos == 0)
13726 {
13727 log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
13728 log_info (" You can use --force to override this but do not post error reports if you do so");
13729 }
13730
13731 device_param->skipped = 1;
13732 }
13733 }
13734 }
13735
13736 // skipped
13737
13738 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13739 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13740
13741 // driver_version
13742
13743 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13744
13745 char *driver_version = (char *) mymalloc (param_value_size);
13746
13747 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13748
13749 device_param->driver_version = driver_version;
13750
13751 // device_name_chksum
13752
13753 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13754
13755 #if __x86_64__
13756 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);
13757 #else
13758 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);
13759 #endif
13760
13761 uint device_name_digest[4] = { 0 };
13762
13763 md5_64 ((uint *) device_name_chksum, device_name_digest);
13764
13765 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13766
13767 device_param->device_name_chksum = device_name_chksum;
13768
13769 // device_processor_cores
13770
13771 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
13772 {
13773 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
13774 {
13775 need_adl = 1;
13776 }
13777
13778 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
13779 {
13780 need_nvml = 1;
13781
13782 #ifdef _WIN
13783 need_nvapi = 1;
13784 #endif
13785 }
13786 }
13787
13788 // device_processor_cores
13789
13790 if (device_type & CL_DEVICE_TYPE_CPU)
13791 {
13792 cl_uint device_processor_cores = 1;
13793
13794 device_param->device_processor_cores = device_processor_cores;
13795 }
13796
13797 if (device_type & CL_DEVICE_TYPE_GPU)
13798 {
13799 if (device_vendor_id == VENDOR_ID_AMD)
13800 {
13801 cl_uint device_processor_cores = 0;
13802
13803 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13804
13805 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13806
13807 device_param->device_processor_cores = device_processor_cores;
13808 }
13809 else if (device_vendor_id == VENDOR_ID_NV)
13810 {
13811 cl_uint kernel_exec_timeout = 0;
13812
13813 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13814
13815 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13816
13817 device_param->kernel_exec_timeout = kernel_exec_timeout;
13818
13819 cl_uint device_processor_cores = 0;
13820
13821 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13822
13823 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13824
13825 device_param->device_processor_cores = device_processor_cores;
13826
13827 cl_uint sm_minor = 0;
13828 cl_uint sm_major = 0;
13829
13830 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13831 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13832
13833 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13834 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13835
13836 device_param->sm_minor = sm_minor;
13837 device_param->sm_major = sm_major;
13838 }
13839 else
13840 {
13841 cl_uint device_processor_cores = 1;
13842
13843 device_param->device_processor_cores = device_processor_cores;
13844 }
13845 }
13846
13847 // display results
13848
13849 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13850 {
13851 if (machine_readable == 0)
13852 {
13853 if (device_param->skipped == 0)
13854 {
13855 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13856 device_id + 1,
13857 device_name,
13858 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13859 (unsigned int) (device_global_mem / 1024 / 1024),
13860 (unsigned int) device_processors);
13861 }
13862 else
13863 {
13864 log_info ("Device #%u: %s, skipped",
13865 device_id + 1,
13866 device_name);
13867 }
13868 }
13869 }
13870
13871 // common driver check
13872
13873 if (device_param->skipped == 0)
13874 {
13875 if (device_type & CL_DEVICE_TYPE_GPU)
13876 {
13877 if (platform_vendor_id == VENDOR_ID_AMD)
13878 {
13879 int catalyst_check = (force == 1) ? 0 : 1;
13880
13881 int catalyst_warn = 0;
13882
13883 int catalyst_broken = 0;
13884
13885 if (catalyst_check == 1)
13886 {
13887 catalyst_warn = 1;
13888
13889 // v14.9 and higher
13890 if (atoi (device_param->driver_version) >= 1573)
13891 {
13892 catalyst_warn = 0;
13893 }
13894
13895 catalyst_check = 0;
13896 }
13897
13898 if (catalyst_broken == 1)
13899 {
13900 log_info ("");
13901 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13902 log_info ("It will pass over cracked hashes and does not report them as cracked");
13903 log_info ("You are STRONGLY encouraged not to use it");
13904 log_info ("You can use --force to override this but do not post error reports if you do so");
13905 log_info ("");
13906
13907 return (-1);
13908 }
13909
13910 if (catalyst_warn == 1)
13911 {
13912 log_info ("");
13913 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13914 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13915 log_info ("See hashcat's homepage for official supported catalyst drivers");
13916 #ifdef _WIN
13917 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13918 #endif
13919 log_info ("You can use --force to override this but do not post error reports if you do so");
13920 log_info ("");
13921
13922 return (-1);
13923 }
13924 }
13925 else if (platform_vendor_id == VENDOR_ID_NV)
13926 {
13927 if (device_param->kernel_exec_timeout != 0)
13928 {
13929 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);
13930 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13931 }
13932 }
13933 }
13934
13935 /* turns out pocl still creates segfaults (because of llvm)
13936 if (device_type & CL_DEVICE_TYPE_CPU)
13937 {
13938 if (platform_vendor_id == VENDOR_ID_AMD)
13939 {
13940 if (force == 0)
13941 {
13942 log_info ("");
13943 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13944 log_info ("You are STRONGLY encouraged not to use it");
13945 log_info ("You can use --force to override this but do not post error reports if you do so");
13946 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13947 log_info ("");
13948
13949 return (-1);
13950 }
13951 }
13952 }
13953 */
13954
13955 /**
13956 * kernel accel and loops tuning db adjustment
13957 */
13958
13959 device_param->kernel_accel_min = 1;
13960 device_param->kernel_accel_max = 1024;
13961
13962 device_param->kernel_loops_min = 1;
13963 device_param->kernel_loops_max = 1024;
13964
13965 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13966
13967 if (tuningdb_entry)
13968 {
13969 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13970 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13971
13972 if (_kernel_accel)
13973 {
13974 device_param->kernel_accel_min = _kernel_accel;
13975 device_param->kernel_accel_max = _kernel_accel;
13976 }
13977
13978 if (_kernel_loops)
13979 {
13980 if (workload_profile == 1)
13981 {
13982 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13983 }
13984 else if (workload_profile == 2)
13985 {
13986 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13987 }
13988
13989 device_param->kernel_loops_min = _kernel_loops;
13990 device_param->kernel_loops_max = _kernel_loops;
13991 }
13992 }
13993
13994 // commandline parameters overwrite tuningdb entries
13995
13996 if (kernel_accel)
13997 {
13998 device_param->kernel_accel_min = kernel_accel;
13999 device_param->kernel_accel_max = kernel_accel;
14000 }
14001
14002 if (kernel_loops)
14003 {
14004 device_param->kernel_loops_min = kernel_loops;
14005 device_param->kernel_loops_max = kernel_loops;
14006 }
14007
14008 /**
14009 * activate device
14010 */
14011
14012 devices_active++;
14013 }
14014
14015 // next please
14016
14017 devices_cnt++;
14018 }
14019 }
14020
14021 if (keyspace == 0 && devices_active == 0)
14022 {
14023 log_error ("ERROR: No devices found/left");
14024
14025 return (-1);
14026 }
14027
14028 // 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)
14029
14030 if (devices_filter != (uint) -1)
14031 {
14032 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14033
14034 if (devices_filter > devices_cnt_mask)
14035 {
14036 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14037
14038 return (-1);
14039 }
14040 }
14041
14042 data.devices_cnt = devices_cnt;
14043
14044 data.devices_active = devices_active;
14045
14046 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14047 {
14048 if (machine_readable == 0)
14049 {
14050 log_info ("");
14051 }
14052 }
14053
14054 /**
14055 * HM devices: init
14056 */
14057
14058 #ifdef HAVE_HWMON
14059 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14060 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14061 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14062
14063 if (gpu_temp_disable == 0)
14064 {
14065 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14066 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14067 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14068
14069 data.hm_adl = NULL;
14070 data.hm_nvapi = NULL;
14071 data.hm_nvml = NULL;
14072
14073 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14074 {
14075 data.hm_nvml = nvml;
14076 }
14077
14078 if (data.hm_nvml)
14079 {
14080 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14081 {
14082 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14083
14084 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14085
14086 int tmp_out = 0;
14087
14088 for (int i = 0; i < tmp_in; i++)
14089 {
14090 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14091 }
14092
14093 for (int i = 0; i < tmp_out; i++)
14094 {
14095 unsigned int speed;
14096
14097 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14098
14099 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14100
14101 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14102 }
14103 }
14104 }
14105
14106 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14107 {
14108 data.hm_nvapi = nvapi;
14109 }
14110
14111 if (data.hm_nvapi)
14112 {
14113 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14114 {
14115 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14116
14117 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14118
14119 int tmp_out = 0;
14120
14121 for (int i = 0; i < tmp_in; i++)
14122 {
14123 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14124 }
14125 }
14126 }
14127
14128 if ((need_adl == 1) && (adl_init (adl) == 0))
14129 {
14130 data.hm_adl = adl;
14131 }
14132
14133 if (data.hm_adl)
14134 {
14135 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14136 {
14137 // total number of adapters
14138
14139 int hm_adapters_num;
14140
14141 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14142
14143 // adapter info
14144
14145 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14146
14147 if (lpAdapterInfo == NULL) return (-1);
14148
14149 // get a list (of ids of) valid/usable adapters
14150
14151 int num_adl_adapters = 0;
14152
14153 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14154
14155 if (num_adl_adapters > 0)
14156 {
14157 hc_thread_mutex_lock (mux_adl);
14158
14159 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14160
14161 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14162
14163 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14164 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14165
14166 hc_thread_mutex_unlock (mux_adl);
14167 }
14168
14169 myfree (valid_adl_device_list);
14170 myfree (lpAdapterInfo);
14171 }
14172 }
14173
14174 if (data.hm_adl == NULL && data.hm_nvml == NULL)
14175 {
14176 gpu_temp_disable = 1;
14177 }
14178 }
14179
14180 /**
14181 * OpenCL devices: allocate buffer for device specific information
14182 */
14183
14184 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14185 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14186
14187 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14188
14189 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14190
14191 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14192
14193 /**
14194 * User-defined GPU temp handling
14195 */
14196
14197 if (gpu_temp_disable == 1)
14198 {
14199 gpu_temp_abort = 0;
14200 gpu_temp_retain = 0;
14201 }
14202
14203 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14204 {
14205 if (gpu_temp_abort < gpu_temp_retain)
14206 {
14207 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14208
14209 return (-1);
14210 }
14211 }
14212
14213 data.gpu_temp_disable = gpu_temp_disable;
14214 data.gpu_temp_abort = gpu_temp_abort;
14215 data.gpu_temp_retain = gpu_temp_retain;
14216 #endif
14217
14218 /**
14219 * enable custom signal handler(s)
14220 */
14221
14222 if (benchmark == 0)
14223 {
14224 hc_signal (sigHandler_default);
14225 }
14226 else
14227 {
14228 hc_signal (sigHandler_benchmark);
14229 }
14230
14231 /**
14232 * inform the user
14233 */
14234
14235 if (data.quiet == 0)
14236 {
14237 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14238
14239 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);
14240
14241 if (attack_mode == ATTACK_MODE_STRAIGHT)
14242 {
14243 log_info ("Rules: %u", kernel_rules_cnt);
14244 }
14245
14246 if (opti_type)
14247 {
14248 log_info ("Applicable Optimizers:");
14249
14250 for (uint i = 0; i < 32; i++)
14251 {
14252 const uint opti_bit = 1u << i;
14253
14254 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14255 }
14256 }
14257
14258 /**
14259 * Watchdog and Temperature balance
14260 */
14261
14262 #ifdef HAVE_HWMON
14263 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL)
14264 {
14265 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14266 }
14267
14268 if (gpu_temp_abort == 0)
14269 {
14270 log_info ("Watchdog: Temperature abort trigger disabled");
14271 }
14272 else
14273 {
14274 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14275 }
14276
14277 if (gpu_temp_retain == 0)
14278 {
14279 log_info ("Watchdog: Temperature retain trigger disabled");
14280 }
14281 else
14282 {
14283 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14284 }
14285
14286 if (data.quiet == 0) log_info ("");
14287 #endif
14288 }
14289
14290 #ifdef HAVE_HWMON
14291
14292 /**
14293 * HM devices: copy
14294 */
14295
14296 if (gpu_temp_disable == 0)
14297 {
14298 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14299 {
14300 hc_device_param_t *device_param = &data.devices_param[device_id];
14301
14302 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14303
14304 if (device_param->skipped) continue;
14305
14306 const uint platform_devices_id = device_param->platform_devices_id;
14307
14308 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14309 {
14310 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14311 data.hm_device[device_id].nvapi = 0;
14312 data.hm_device[device_id].nvml = 0;
14313 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14314 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14315 data.hm_device[device_id].fan_set_supported = hm_adapters_adl[platform_devices_id].fan_set_supported;
14316 }
14317
14318 if (device_param->device_vendor_id == VENDOR_ID_NV)
14319 {
14320 data.hm_device[device_id].adl = 0;
14321 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14322 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14323 data.hm_device[device_id].od_version = 0;
14324 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14325 data.hm_device[device_id].fan_set_supported = 0;
14326 }
14327 }
14328 }
14329
14330 /**
14331 * powertune on user request
14332 */
14333
14334 if (powertune_enable == 1)
14335 {
14336 hc_thread_mutex_lock (mux_adl);
14337
14338 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14339 {
14340 hc_device_param_t *device_param = &data.devices_param[device_id];
14341
14342 if (device_param->skipped) continue;
14343
14344 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14345 {
14346 /**
14347 * Temporary fix:
14348 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14349 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14350 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14351 * Driver / ADL bug?
14352 */
14353
14354 if (data.hm_device[device_id].od_version == 6)
14355 {
14356 int ADL_rc;
14357
14358 // check powertune capabilities first, if not available then skip device
14359
14360 int powertune_supported = 0;
14361
14362 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14363 {
14364 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14365
14366 return (-1);
14367 }
14368
14369 // first backup current value, we will restore it later
14370
14371 if (powertune_supported != 0)
14372 {
14373 // powercontrol settings
14374
14375 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14376
14377 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14378 {
14379 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14380 }
14381
14382 if (ADL_rc != ADL_OK)
14383 {
14384 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14385
14386 return (-1);
14387 }
14388
14389 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14390 {
14391 log_error ("ERROR: Failed to set new ADL PowerControl values");
14392
14393 return (-1);
14394 }
14395
14396 // clocks
14397
14398 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14399
14400 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14401
14402 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)
14403 {
14404 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14405
14406 return (-1);
14407 }
14408
14409 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14410
14411 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14412
14413 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14414 {
14415 log_error ("ERROR: Failed to get ADL device capabilities");
14416
14417 return (-1);
14418 }
14419
14420 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14421 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14422
14423 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14424 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14425
14426 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14427 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14428
14429 // warning if profile has too low max values
14430
14431 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14432 {
14433 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14434 }
14435
14436 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14437 {
14438 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14439 }
14440
14441 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14442
14443 performance_state->iNumberOfPerformanceLevels = 2;
14444
14445 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14446 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14447 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14448 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14449
14450 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)
14451 {
14452 log_info ("ERROR: Failed to set ADL performance state");
14453
14454 return (-1);
14455 }
14456
14457 local_free (performance_state);
14458 }
14459
14460 // set powertune value only
14461
14462 if (powertune_supported != 0)
14463 {
14464 // powertune set
14465 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14466
14467 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14468 {
14469 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14470
14471 return (-1);
14472 }
14473
14474 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14475 {
14476 log_error ("ERROR: Failed to set new ADL PowerControl values");
14477
14478 return (-1);
14479 }
14480 }
14481 }
14482 }
14483
14484 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14485 {
14486 // first backup current value, we will restore it later
14487
14488 unsigned int limit;
14489
14490 int powertune_supported = 0;
14491
14492 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14493 {
14494 powertune_supported = 1;
14495 }
14496
14497 // if backup worked, activate the maximum allowed
14498
14499 if (powertune_supported != 0)
14500 {
14501 unsigned int minLimit;
14502 unsigned int maxLimit;
14503
14504 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14505 {
14506 if (maxLimit > 0)
14507 {
14508 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14509 {
14510 // now we can be sure we need to reset later
14511
14512 nvml_power_limit[device_id] = limit;
14513 }
14514 }
14515 }
14516 }
14517 }
14518 }
14519
14520 hc_thread_mutex_unlock (mux_adl);
14521 }
14522
14523 #endif // HAVE_HWMON
14524
14525 #ifdef DEBUG
14526 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14527 #endif
14528
14529 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14530
14531 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14532 {
14533 /**
14534 * host buffer
14535 */
14536
14537 hc_device_param_t *device_param = &data.devices_param[device_id];
14538
14539 if (device_param->skipped) continue;
14540
14541 /**
14542 * device properties
14543 */
14544
14545 const char *device_name_chksum = device_param->device_name_chksum;
14546 const u32 device_processors = device_param->device_processors;
14547 const u32 device_processor_cores = device_param->device_processor_cores;
14548
14549 /**
14550 * create context for each device
14551 */
14552
14553 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14554
14555 /**
14556 * create command-queue
14557 */
14558
14559 // not supported with NV
14560 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14561
14562 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14563
14564 /**
14565 * kernel threads: some algorithms need a fixed kernel-threads count
14566 * because of shared memory usage or bitslice
14567 * there needs to be some upper limit, otherwise there's too much overhead
14568 */
14569
14570 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14571
14572 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14573 {
14574 kernel_threads = KERNEL_THREADS_MAX_CPU;
14575 }
14576
14577 if (hash_mode == 1500) kernel_threads = 64; // DES
14578 if (hash_mode == 3000) kernel_threads = 64; // DES
14579 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14580 if (hash_mode == 7500) kernel_threads = 64; // RC4
14581 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14582 if (hash_mode == 9700) kernel_threads = 64; // RC4
14583 if (hash_mode == 9710) kernel_threads = 64; // RC4
14584 if (hash_mode == 9800) kernel_threads = 64; // RC4
14585 if (hash_mode == 9810) kernel_threads = 64; // RC4
14586 if (hash_mode == 10400) kernel_threads = 64; // RC4
14587 if (hash_mode == 10410) kernel_threads = 64; // RC4
14588 if (hash_mode == 10500) kernel_threads = 64; // RC4
14589 if (hash_mode == 13100) kernel_threads = 64; // RC4
14590
14591 device_param->kernel_threads = kernel_threads;
14592
14593 device_param->hardware_power = device_processors * kernel_threads;
14594
14595 /**
14596 * create input buffers on device : calculate size of fixed memory buffers
14597 */
14598
14599 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14600 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14601
14602 device_param->size_root_css = size_root_css;
14603 device_param->size_markov_css = size_markov_css;
14604
14605 size_t size_results = sizeof (uint);
14606
14607 device_param->size_results = size_results;
14608
14609 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14610 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14611
14612 size_t size_plains = digests_cnt * sizeof (plain_t);
14613 size_t size_salts = salts_cnt * sizeof (salt_t);
14614 size_t size_esalts = salts_cnt * esalt_size;
14615
14616 device_param->size_plains = size_plains;
14617 device_param->size_digests = size_digests;
14618 device_param->size_shown = size_shown;
14619 device_param->size_salts = size_salts;
14620
14621 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14622 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14623 size_t size_tm = 32 * sizeof (bs_word_t);
14624
14625 // scryptV stuff
14626
14627 size_t size_scryptV = 1;
14628
14629 if ((hash_mode == 8900) || (hash_mode == 9300))
14630 {
14631 uint tmto_start = 0;
14632 uint tmto_stop = 10;
14633
14634 if (scrypt_tmto)
14635 {
14636 tmto_start = scrypt_tmto;
14637 }
14638 else
14639 {
14640 // in case the user did not specify the tmto manually
14641 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14642 // but set the lower end only in case the user has a device with too less memory
14643
14644 if (hash_mode == 8900)
14645 {
14646 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14647 {
14648 tmto_start = 1;
14649 }
14650 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14651 {
14652 tmto_start = 2;
14653 }
14654 }
14655 else if (hash_mode == 9300)
14656 {
14657 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14658 {
14659 tmto_start = 2;
14660 }
14661 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14662 {
14663 tmto_start = 2;
14664 }
14665 }
14666 }
14667
14668 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14669 {
14670 // TODO: in theory the following calculation needs to be done per salt, not global
14671 // we assume all hashes have the same scrypt settings
14672
14673 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14674
14675 size_scryptV /= 1 << tmto;
14676
14677 size_scryptV *= device_processors * device_processor_cores;
14678
14679 if (size_scryptV > device_param->device_maxmem_alloc)
14680 {
14681 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14682
14683 continue;
14684 }
14685
14686 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14687 {
14688 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14689 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14690 }
14691
14692 break;
14693 }
14694
14695 if (data.salts_buf[0].scrypt_phy == 0)
14696 {
14697 log_error ("ERROR: can't allocate enough device memory");
14698
14699 return -1;
14700 }
14701
14702 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14703 }
14704
14705 /**
14706 * some algorithms need a fixed kernel-loops count
14707 */
14708
14709 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
14710 {
14711 const u32 kernel_loops_fixed = 1024;
14712
14713 device_param->kernel_loops_min = kernel_loops_fixed;
14714 device_param->kernel_loops_max = kernel_loops_fixed;
14715 }
14716
14717 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
14718 {
14719 const u32 kernel_loops_fixed = 1024;
14720
14721 device_param->kernel_loops_min = kernel_loops_fixed;
14722 device_param->kernel_loops_max = kernel_loops_fixed;
14723 }
14724
14725 if (hash_mode == 8900)
14726 {
14727 const u32 kernel_loops_fixed = 1;
14728
14729 device_param->kernel_loops_min = kernel_loops_fixed;
14730 device_param->kernel_loops_max = kernel_loops_fixed;
14731 }
14732
14733 if (hash_mode == 9300)
14734 {
14735 const u32 kernel_loops_fixed = 1;
14736
14737 device_param->kernel_loops_min = kernel_loops_fixed;
14738 device_param->kernel_loops_max = kernel_loops_fixed;
14739 }
14740
14741 if (hash_mode == 12500)
14742 {
14743 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14744
14745 device_param->kernel_loops_min = kernel_loops_fixed;
14746 device_param->kernel_loops_max = kernel_loops_fixed;
14747 }
14748
14749 /**
14750 * some algorithms have a maximum kernel-loops count
14751 */
14752
14753 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14754 {
14755 u32 innerloop_cnt = 0;
14756
14757 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14758 {
14759 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14760 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14761 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14762 }
14763 else
14764 {
14765 innerloop_cnt = data.salts_buf[0].salt_iter;
14766 }
14767
14768 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14769 (innerloop_cnt <= device_param->kernel_loops_max))
14770 {
14771 device_param->kernel_loops_max = innerloop_cnt;
14772 }
14773 }
14774
14775 u32 kernel_accel_min = device_param->kernel_accel_min;
14776 u32 kernel_accel_max = device_param->kernel_accel_max;
14777
14778 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14779
14780 size_t size_pws = 4;
14781 size_t size_tmps = 4;
14782 size_t size_hooks = 4;
14783
14784 while (kernel_accel_max >= kernel_accel_min)
14785 {
14786 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14787
14788 // size_pws
14789
14790 size_pws = kernel_power_max * sizeof (pw_t);
14791
14792 // size_tmps
14793
14794 switch (hash_mode)
14795 {
14796 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14797 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14798 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14799 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14800 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14801 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14802 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14803 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14804 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14805 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14806 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14807 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14808 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14809 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14810 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14811 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14812 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14813 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14814 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14815 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14816 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14817 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14818 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14819 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14820 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14821 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14822 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14823 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14824 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14825 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14826 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14827 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14828 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14829 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14830 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14831 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14832 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14833 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14834 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14835 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14836 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14837 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14838 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14839 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14840 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14841 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14842 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14843 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14844 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14845 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14846 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14847 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14848 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14849 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14850 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14851 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14852 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14853 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14854 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14855 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14856 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14857 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14858 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14859 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14860 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14861 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14862 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14863 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14864 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14865 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14866 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14867 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14868 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14869 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14870 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14871 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14872 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14873 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14874 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14875 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14876 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14877 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14878 };
14879
14880 // size_hooks
14881
14882 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14883 {
14884 // none yet
14885 }
14886
14887 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14888 // if not, decrease amplifier and try again
14889
14890 int skip = 0;
14891
14892 const u64 size_total
14893 = bitmap_size
14894 + bitmap_size
14895 + bitmap_size
14896 + bitmap_size
14897 + bitmap_size
14898 + bitmap_size
14899 + bitmap_size
14900 + bitmap_size
14901 + size_bfs
14902 + size_combs
14903 + size_digests
14904 + size_esalts
14905 + size_hooks
14906 + size_markov_css
14907 + size_plains
14908 + size_pws
14909 + size_pws // not a bug
14910 + size_results
14911 + size_root_css
14912 + size_rules
14913 + size_rules_c
14914 + size_salts
14915 + size_scryptV
14916 + size_shown
14917 + size_tm
14918 + size_tmps;
14919
14920 // Don't ask me, ask AMD!
14921
14922 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14923 if (size_total > device_param->device_global_mem) skip = 1;
14924
14925 if (skip == 1)
14926 {
14927 kernel_accel_max--;
14928
14929 continue;
14930 }
14931
14932 break;
14933 }
14934
14935 /*
14936 if (kernel_accel_max == 0)
14937 {
14938 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14939
14940 return -1;
14941 }
14942 */
14943
14944 device_param->kernel_accel_min = kernel_accel_min;
14945 device_param->kernel_accel_max = kernel_accel_max;
14946
14947 /*
14948 if (kernel_accel_max < kernel_accel)
14949 {
14950 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14951
14952 device_param->kernel_accel = kernel_accel_max;
14953 }
14954 */
14955
14956 device_param->size_bfs = size_bfs;
14957 device_param->size_combs = size_combs;
14958 device_param->size_rules = size_rules;
14959 device_param->size_rules_c = size_rules_c;
14960 device_param->size_pws = size_pws;
14961 device_param->size_tmps = size_tmps;
14962 device_param->size_hooks = size_hooks;
14963
14964 /**
14965 * default building options
14966 */
14967
14968 char build_opts[1024] = { 0 };
14969
14970 // we don't have sm_* on vendors not NV but it doesn't matter
14971
14972 #if _WIN
14973 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);
14974 #else
14975 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s/OpenCL/\" -I '%s/OpenCL/' -I %s/OpenCL/ -I\"%s/OpenCL/\" -I'%s/OpenCL/' -I%s/OpenCL/", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
14976 #endif
14977
14978 char build_opts_new[1024] = { 0 };
14979
14980 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);
14981
14982 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14983
14984 /*
14985 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14986 {
14987 // we do vectorizing much better than the auto-vectorizer
14988
14989 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14990
14991 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14992 }
14993 */
14994
14995 #ifdef DEBUG
14996 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14997 #endif
14998
14999 /**
15000 * main kernel
15001 */
15002
15003 {
15004 /**
15005 * kernel source filename
15006 */
15007
15008 char source_file[256] = { 0 };
15009
15010 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15011
15012 struct stat sst;
15013
15014 if (stat (source_file, &sst) == -1)
15015 {
15016 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15017
15018 return -1;
15019 }
15020
15021 /**
15022 * kernel cached filename
15023 */
15024
15025 char cached_file[256] = { 0 };
15026
15027 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15028
15029 int cached = 1;
15030
15031 struct stat cst;
15032
15033 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15034 {
15035 cached = 0;
15036 }
15037
15038 /**
15039 * kernel compile or load
15040 */
15041
15042 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15043
15044 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15045
15046 if (force_jit_compilation == -1)
15047 {
15048 if (cached == 0)
15049 {
15050 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15051
15052 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15053
15054 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15055
15056 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15057
15058 #ifdef DEBUG
15059 size_t build_log_size = 0;
15060
15061 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15062
15063 if (build_log_size > 1)
15064 {
15065 char *build_log = (char *) malloc (build_log_size + 1);
15066
15067 memset (build_log, 0, build_log_size + 1);
15068
15069 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15070
15071 puts (build_log);
15072
15073 free (build_log);
15074 }
15075 #endif
15076
15077 if (rc != 0)
15078 {
15079 device_param->skipped = true;
15080
15081 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15082
15083 continue;
15084 }
15085
15086 size_t binary_size;
15087
15088 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15089
15090 u8 *binary = (u8 *) mymalloc (binary_size);
15091
15092 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15093
15094 writeProgramBin (cached_file, binary, binary_size);
15095
15096 local_free (binary);
15097 }
15098 else
15099 {
15100 #ifdef DEBUG
15101 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15102 #endif
15103
15104 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15105
15106 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15107
15108 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15109 }
15110 }
15111 else
15112 {
15113 #ifdef DEBUG
15114 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15115 #endif
15116
15117 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15118
15119 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15120
15121 char build_opts_update[1024] = { 0 };
15122
15123 if (force_jit_compilation == 1500)
15124 {
15125 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15126 }
15127 else if (force_jit_compilation == 8900)
15128 {
15129 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);
15130 }
15131 else
15132 {
15133 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15134 }
15135
15136 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15137
15138 #ifdef DEBUG
15139 size_t build_log_size = 0;
15140
15141 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15142
15143 if (build_log_size > 1)
15144 {
15145 char *build_log = (char *) malloc (build_log_size + 1);
15146
15147 memset (build_log, 0, build_log_size + 1);
15148
15149 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15150
15151 puts (build_log);
15152
15153 free (build_log);
15154 }
15155 #endif
15156
15157 if (rc != 0)
15158 {
15159 device_param->skipped = true;
15160
15161 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15162 }
15163 }
15164
15165 local_free (kernel_lengths);
15166 local_free (kernel_sources[0]);
15167 local_free (kernel_sources);
15168 }
15169
15170 /**
15171 * word generator kernel
15172 */
15173
15174 if (attack_mode != ATTACK_MODE_STRAIGHT)
15175 {
15176 /**
15177 * kernel mp source filename
15178 */
15179
15180 char source_file[256] = { 0 };
15181
15182 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15183
15184 struct stat sst;
15185
15186 if (stat (source_file, &sst) == -1)
15187 {
15188 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15189
15190 return -1;
15191 }
15192
15193 /**
15194 * kernel mp cached filename
15195 */
15196
15197 char cached_file[256] = { 0 };
15198
15199 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15200
15201 int cached = 1;
15202
15203 struct stat cst;
15204
15205 if (stat (cached_file, &cst) == -1)
15206 {
15207 cached = 0;
15208 }
15209
15210 /**
15211 * kernel compile or load
15212 */
15213
15214 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15215
15216 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15217
15218 if (cached == 0)
15219 {
15220 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15221 if (quiet == 0) log_info ("");
15222
15223 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15224
15225 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15226
15227 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15228
15229 if (rc != 0)
15230 {
15231 device_param->skipped = true;
15232
15233 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15234
15235 continue;
15236 }
15237
15238 size_t binary_size;
15239
15240 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15241
15242 u8 *binary = (u8 *) mymalloc (binary_size);
15243
15244 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15245
15246 writeProgramBin (cached_file, binary, binary_size);
15247
15248 local_free (binary);
15249 }
15250 else
15251 {
15252 #ifdef DEBUG
15253 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15254 #endif
15255
15256 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15257
15258 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15259
15260 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15261 }
15262
15263 local_free (kernel_lengths);
15264 local_free (kernel_sources[0]);
15265 local_free (kernel_sources);
15266 }
15267
15268 /**
15269 * amplifier kernel
15270 */
15271
15272 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15273 {
15274
15275 }
15276 else
15277 {
15278 /**
15279 * kernel amp source filename
15280 */
15281
15282 char source_file[256] = { 0 };
15283
15284 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15285
15286 struct stat sst;
15287
15288 if (stat (source_file, &sst) == -1)
15289 {
15290 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15291
15292 return -1;
15293 }
15294
15295 /**
15296 * kernel amp cached filename
15297 */
15298
15299 char cached_file[256] = { 0 };
15300
15301 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15302
15303 int cached = 1;
15304
15305 struct stat cst;
15306
15307 if (stat (cached_file, &cst) == -1)
15308 {
15309 cached = 0;
15310 }
15311
15312 /**
15313 * kernel compile or load
15314 */
15315
15316 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15317
15318 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15319
15320 if (cached == 0)
15321 {
15322 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15323 if (quiet == 0) log_info ("");
15324
15325 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15326
15327 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15328
15329 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15330
15331 if (rc != 0)
15332 {
15333 device_param->skipped = true;
15334
15335 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15336
15337 continue;
15338 }
15339
15340 size_t binary_size;
15341
15342 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15343
15344 u8 *binary = (u8 *) mymalloc (binary_size);
15345
15346 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15347
15348 writeProgramBin (cached_file, binary, binary_size);
15349
15350 local_free (binary);
15351 }
15352 else
15353 {
15354 #ifdef DEBUG
15355 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15356 #endif
15357
15358 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15359
15360 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15361
15362 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15363 }
15364
15365 local_free (kernel_lengths);
15366 local_free (kernel_sources[0]);
15367 local_free (kernel_sources);
15368 }
15369
15370 // some algorithm collide too fast, make that impossible
15371
15372 if (benchmark == 1)
15373 {
15374 ((uint *) digests_buf)[0] = -1;
15375 ((uint *) digests_buf)[1] = -1;
15376 ((uint *) digests_buf)[2] = -1;
15377 ((uint *) digests_buf)[3] = -1;
15378 }
15379
15380 /**
15381 * global buffers
15382 */
15383
15384 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15385 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15386 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15387 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15388 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15389 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15390 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15391 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15392 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15393 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15394 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15395 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15396 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15397 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15398 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15399 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15400 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15401 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15402
15403 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);
15404 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);
15405 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);
15406 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);
15407 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);
15408 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);
15409 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);
15410 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);
15411 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15412 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15413 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15414
15415 /**
15416 * special buffers
15417 */
15418
15419 if (attack_kern == ATTACK_KERN_STRAIGHT)
15420 {
15421 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15422 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15423
15424 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15425 }
15426 else if (attack_kern == ATTACK_KERN_COMBI)
15427 {
15428 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15429 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15430 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15431 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15432 }
15433 else if (attack_kern == ATTACK_KERN_BF)
15434 {
15435 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15436 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15437 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15438 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15439 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15440 }
15441
15442 if (size_esalts)
15443 {
15444 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15445
15446 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15447 }
15448
15449 /**
15450 * main host data
15451 */
15452
15453 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15454
15455 device_param->pws_buf = pws_buf;
15456
15457 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15458
15459 device_param->combs_buf = combs_buf;
15460
15461 void *hooks_buf = mymalloc (size_hooks);
15462
15463 device_param->hooks_buf = hooks_buf;
15464
15465 /**
15466 * kernel args
15467 */
15468
15469 device_param->kernel_params_buf32[21] = bitmap_mask;
15470 device_param->kernel_params_buf32[22] = bitmap_shift1;
15471 device_param->kernel_params_buf32[23] = bitmap_shift2;
15472 device_param->kernel_params_buf32[24] = 0; // salt_pos
15473 device_param->kernel_params_buf32[25] = 0; // loop_pos
15474 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15475 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15476 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15477 device_param->kernel_params_buf32[29] = 0; // digests_offset
15478 device_param->kernel_params_buf32[30] = 0; // combs_mode
15479 device_param->kernel_params_buf32[31] = 0; // gid_max
15480
15481 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15482 ? &device_param->d_pws_buf
15483 : &device_param->d_pws_amp_buf;
15484 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15485 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15486 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15487 device_param->kernel_params[ 4] = &device_param->d_tmps;
15488 device_param->kernel_params[ 5] = &device_param->d_hooks;
15489 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15490 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15491 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15492 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15493 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15494 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15495 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15496 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15497 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15498 device_param->kernel_params[15] = &device_param->d_digests_buf;
15499 device_param->kernel_params[16] = &device_param->d_digests_shown;
15500 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15501 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15502 device_param->kernel_params[19] = &device_param->d_result;
15503 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15504 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15505 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15506 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15507 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15508 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15509 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15510 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15511 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15512 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15513 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15514 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15515
15516 device_param->kernel_params_mp_buf64[3] = 0;
15517 device_param->kernel_params_mp_buf32[4] = 0;
15518 device_param->kernel_params_mp_buf32[5] = 0;
15519 device_param->kernel_params_mp_buf32[6] = 0;
15520 device_param->kernel_params_mp_buf32[7] = 0;
15521 device_param->kernel_params_mp_buf32[8] = 0;
15522
15523 device_param->kernel_params_mp[0] = NULL;
15524 device_param->kernel_params_mp[1] = NULL;
15525 device_param->kernel_params_mp[2] = NULL;
15526 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15527 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15528 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15529 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15530 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15531 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15532
15533 device_param->kernel_params_mp_l_buf64[3] = 0;
15534 device_param->kernel_params_mp_l_buf32[4] = 0;
15535 device_param->kernel_params_mp_l_buf32[5] = 0;
15536 device_param->kernel_params_mp_l_buf32[6] = 0;
15537 device_param->kernel_params_mp_l_buf32[7] = 0;
15538 device_param->kernel_params_mp_l_buf32[8] = 0;
15539 device_param->kernel_params_mp_l_buf32[9] = 0;
15540
15541 device_param->kernel_params_mp_l[0] = NULL;
15542 device_param->kernel_params_mp_l[1] = NULL;
15543 device_param->kernel_params_mp_l[2] = NULL;
15544 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15545 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15546 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15547 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15548 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15549 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15550 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15551
15552 device_param->kernel_params_mp_r_buf64[3] = 0;
15553 device_param->kernel_params_mp_r_buf32[4] = 0;
15554 device_param->kernel_params_mp_r_buf32[5] = 0;
15555 device_param->kernel_params_mp_r_buf32[6] = 0;
15556 device_param->kernel_params_mp_r_buf32[7] = 0;
15557 device_param->kernel_params_mp_r_buf32[8] = 0;
15558
15559 device_param->kernel_params_mp_r[0] = NULL;
15560 device_param->kernel_params_mp_r[1] = NULL;
15561 device_param->kernel_params_mp_r[2] = NULL;
15562 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15563 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15564 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15565 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15566 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15567 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15568
15569 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15570 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15571
15572 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15573 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15574 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15575 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15576 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15577 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15578 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15579
15580 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15581 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15582
15583 device_param->kernel_params_memset_buf32[1] = 0; // value
15584 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15585
15586 device_param->kernel_params_memset[0] = NULL;
15587 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15588 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15589
15590 /**
15591 * kernel name
15592 */
15593
15594 size_t kernel_wgs_tmp;
15595
15596 char kernel_name[64] = { 0 };
15597
15598 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15599 {
15600 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15601 {
15602 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15603
15604 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15605
15606 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15607
15608 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15609
15610 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15611
15612 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15613 }
15614 else
15615 {
15616 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15617
15618 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15619
15620 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15621
15622 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15623
15624 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15625
15626 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15627 }
15628
15629 if (data.attack_mode == ATTACK_MODE_BF)
15630 {
15631 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15632 {
15633 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15634
15635 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15636
15637 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);
15638 }
15639 }
15640 }
15641 else
15642 {
15643 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15644
15645 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15646
15647 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15648
15649 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15650
15651 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15652
15653 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15654
15655 if (opts_type & OPTS_TYPE_HOOK12)
15656 {
15657 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15658
15659 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15660
15661 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);
15662 }
15663
15664 if (opts_type & OPTS_TYPE_HOOK23)
15665 {
15666 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15667
15668 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15669
15670 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);
15671 }
15672 }
15673
15674 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);
15675 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);
15676 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);
15677
15678 for (uint i = 0; i <= 20; i++)
15679 {
15680 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15681 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15682 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15683
15684 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15685 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15686 }
15687
15688 for (uint i = 21; i <= 31; i++)
15689 {
15690 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15691 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15692 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15693
15694 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15695 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15696 }
15697
15698 // GPU memset
15699
15700 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15701
15702 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);
15703
15704 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15705 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15706 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15707
15708 // MP start
15709
15710 if (attack_mode == ATTACK_MODE_BF)
15711 {
15712 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15713 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15714
15715 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);
15716 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);
15717
15718 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15719 {
15720 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15721 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15722 }
15723 }
15724 else if (attack_mode == ATTACK_MODE_HYBRID1)
15725 {
15726 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15727
15728 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);
15729 }
15730 else if (attack_mode == ATTACK_MODE_HYBRID2)
15731 {
15732 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15733
15734 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);
15735 }
15736
15737 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15738 {
15739 // nothing to do
15740 }
15741 else
15742 {
15743 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15744
15745 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);
15746 }
15747
15748 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15749 {
15750 // nothing to do
15751 }
15752 else
15753 {
15754 for (uint i = 0; i < 5; i++)
15755 {
15756 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15757 }
15758
15759 for (uint i = 5; i < 7; i++)
15760 {
15761 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15762 }
15763 }
15764
15765 // maybe this has been updated by clGetKernelWorkGroupInfo()
15766 // value can only be decreased, so we don't need to reallocate buffers
15767
15768 device_param->kernel_threads = kernel_threads;
15769
15770 // zero some data buffers
15771
15772 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15773 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15774 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15775 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15776 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15777 run_kernel_bzero (device_param, device_param->d_result, size_results);
15778
15779 /**
15780 * special buffers
15781 */
15782
15783 if (attack_kern == ATTACK_KERN_STRAIGHT)
15784 {
15785 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15786 }
15787 else if (attack_kern == ATTACK_KERN_COMBI)
15788 {
15789 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15790 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15791 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15792 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15793 }
15794 else if (attack_kern == ATTACK_KERN_BF)
15795 {
15796 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15797 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15798 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15799 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15800 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15801 }
15802
15803 #if defined(HAVE_HWMON)
15804
15805 /**
15806 * Store initial fanspeed if gpu_temp_retain is enabled
15807 */
15808
15809 if (gpu_temp_disable == 0)
15810 {
15811 if (gpu_temp_retain != 0)
15812 {
15813 hc_thread_mutex_lock (mux_adl);
15814
15815 if (data.hm_device[device_id].fan_get_supported == 1)
15816 {
15817 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
15818 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
15819
15820 temp_retain_fanspeed_value[device_id] = fanspeed;
15821 temp_retain_fanpolicy_value[device_id] = fanpolicy;
15822
15823 // we also set it to tell the OS we take control over the fan and it's automatic controller
15824 // if it was set to automatic. we do not control user-defined fanspeeds.
15825
15826 if (fanpolicy == 1)
15827 {
15828 data.hm_device[device_id].fan_set_supported = 1;
15829
15830 int rc = -1;
15831
15832 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15833 {
15834 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
15835 }
15836 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15837 {
15838
15839 }
15840
15841 if (rc == 0)
15842 {
15843 data.hm_device[device_id].fan_set_supported = 1;
15844 }
15845 else
15846 {
15847 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
15848
15849 data.hm_device[device_id].fan_set_supported = 0;
15850 }
15851 }
15852 else
15853 {
15854 data.hm_device[device_id].fan_set_supported = 0;
15855 }
15856 }
15857
15858 hc_thread_mutex_unlock (mux_adl);
15859 }
15860 }
15861
15862 #endif // HAVE_HWMON
15863 }
15864
15865 if (data.quiet == 0) log_info_nn ("");
15866
15867 /**
15868 * In benchmark-mode, inform user which algorithm is checked
15869 */
15870
15871 if (benchmark == 1)
15872 {
15873 if (machine_readable == 0)
15874 {
15875 quiet = 0;
15876
15877 data.quiet = quiet;
15878
15879 char *hash_type = strhashtype (data.hash_mode); // not a bug
15880
15881 log_info ("Hashtype: %s", hash_type);
15882 log_info ("");
15883 }
15884 }
15885
15886 /**
15887 * keep track of the progress
15888 */
15889
15890 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15891 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15892 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15893
15894 /**
15895 * open filehandles
15896 */
15897
15898 #if _WIN
15899 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15900 {
15901 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15902
15903 return (-1);
15904 }
15905
15906 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15907 {
15908 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15909
15910 return (-1);
15911 }
15912
15913 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15914 {
15915 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15916
15917 return (-1);
15918 }
15919 #endif
15920
15921 /**
15922 * dictionary pad
15923 */
15924
15925 segment_size *= (1024 * 1024);
15926
15927 data.segment_size = segment_size;
15928
15929 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15930
15931 wl_data->buf = (char *) mymalloc (segment_size);
15932 wl_data->avail = segment_size;
15933 wl_data->incr = segment_size;
15934 wl_data->cnt = 0;
15935 wl_data->pos = 0;
15936
15937 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15938
15939 data.wordlist_mode = wordlist_mode;
15940
15941 cs_t *css_buf = NULL;
15942 uint css_cnt = 0;
15943 uint dictcnt = 0;
15944 uint maskcnt = 1;
15945 char **masks = NULL;
15946 char **dictfiles = NULL;
15947
15948 uint mask_from_file = 0;
15949
15950 if (attack_mode == ATTACK_MODE_STRAIGHT)
15951 {
15952 if (wordlist_mode == WL_MODE_FILE)
15953 {
15954 int wls_left = myargc - (optind + 1);
15955
15956 for (int i = 0; i < wls_left; i++)
15957 {
15958 char *l0_filename = myargv[optind + 1 + i];
15959
15960 struct stat l0_stat;
15961
15962 if (stat (l0_filename, &l0_stat) == -1)
15963 {
15964 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15965
15966 return (-1);
15967 }
15968
15969 uint is_dir = S_ISDIR (l0_stat.st_mode);
15970
15971 if (is_dir == 0)
15972 {
15973 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15974
15975 dictcnt++;
15976
15977 dictfiles[dictcnt - 1] = l0_filename;
15978 }
15979 else
15980 {
15981 // do not allow --keyspace w/ a directory
15982
15983 if (keyspace == 1)
15984 {
15985 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15986
15987 return (-1);
15988 }
15989
15990 char **dictionary_files = NULL;
15991
15992 dictionary_files = scan_directory (l0_filename);
15993
15994 if (dictionary_files != NULL)
15995 {
15996 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15997
15998 for (int d = 0; dictionary_files[d] != NULL; d++)
15999 {
16000 char *l1_filename = dictionary_files[d];
16001
16002 struct stat l1_stat;
16003
16004 if (stat (l1_filename, &l1_stat) == -1)
16005 {
16006 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16007
16008 return (-1);
16009 }
16010
16011 if (S_ISREG (l1_stat.st_mode))
16012 {
16013 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16014
16015 dictcnt++;
16016
16017 dictfiles[dictcnt - 1] = strdup (l1_filename);
16018 }
16019 }
16020 }
16021
16022 local_free (dictionary_files);
16023 }
16024 }
16025
16026 if (dictcnt < 1)
16027 {
16028 log_error ("ERROR: No usable dictionary file found.");
16029
16030 return (-1);
16031 }
16032 }
16033 else if (wordlist_mode == WL_MODE_STDIN)
16034 {
16035 dictcnt = 1;
16036 }
16037 }
16038 else if (attack_mode == ATTACK_MODE_COMBI)
16039 {
16040 // display
16041
16042 char *dictfile1 = myargv[optind + 1 + 0];
16043 char *dictfile2 = myargv[optind + 1 + 1];
16044
16045 // find the bigger dictionary and use as base
16046
16047 FILE *fp1 = NULL;
16048 FILE *fp2 = NULL;
16049
16050 struct stat tmp_stat;
16051
16052 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16053 {
16054 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16055
16056 return (-1);
16057 }
16058
16059 if (stat (dictfile1, &tmp_stat) == -1)
16060 {
16061 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16062
16063 fclose (fp1);
16064
16065 return (-1);
16066 }
16067
16068 if (S_ISDIR (tmp_stat.st_mode))
16069 {
16070 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16071
16072 fclose (fp1);
16073
16074 return (-1);
16075 }
16076
16077 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16078 {
16079 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16080
16081 fclose (fp1);
16082
16083 return (-1);
16084 }
16085
16086 if (stat (dictfile2, &tmp_stat) == -1)
16087 {
16088 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16089
16090 fclose (fp1);
16091 fclose (fp2);
16092
16093 return (-1);
16094 }
16095
16096 if (S_ISDIR (tmp_stat.st_mode))
16097 {
16098 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16099
16100 fclose (fp1);
16101 fclose (fp2);
16102
16103 return (-1);
16104 }
16105
16106 data.combs_cnt = 1;
16107
16108 data.quiet = 1;
16109
16110 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16111
16112 data.quiet = quiet;
16113
16114 if (words1_cnt == 0)
16115 {
16116 log_error ("ERROR: %s: empty file", dictfile1);
16117
16118 fclose (fp1);
16119 fclose (fp2);
16120
16121 return (-1);
16122 }
16123
16124 data.combs_cnt = 1;
16125
16126 data.quiet = 1;
16127
16128 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16129
16130 data.quiet = quiet;
16131
16132 if (words2_cnt == 0)
16133 {
16134 log_error ("ERROR: %s: empty file", dictfile2);
16135
16136 fclose (fp1);
16137 fclose (fp2);
16138
16139 return (-1);
16140 }
16141
16142 fclose (fp1);
16143 fclose (fp2);
16144
16145 data.dictfile = dictfile1;
16146 data.dictfile2 = dictfile2;
16147
16148 if (words1_cnt >= words2_cnt)
16149 {
16150 data.combs_cnt = words2_cnt;
16151 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16152
16153 dictfiles = &data.dictfile;
16154
16155 dictcnt = 1;
16156 }
16157 else
16158 {
16159 data.combs_cnt = words1_cnt;
16160 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16161
16162 dictfiles = &data.dictfile2;
16163
16164 dictcnt = 1;
16165
16166 // we also have to switch wordlist related rules!
16167
16168 char *tmpc = data.rule_buf_l;
16169
16170 data.rule_buf_l = data.rule_buf_r;
16171 data.rule_buf_r = tmpc;
16172
16173 int tmpi = data.rule_len_l;
16174
16175 data.rule_len_l = data.rule_len_r;
16176 data.rule_len_r = tmpi;
16177 }
16178 }
16179 else if (attack_mode == ATTACK_MODE_BF)
16180 {
16181 char *mask = NULL;
16182
16183 maskcnt = 0;
16184
16185 if (benchmark == 0)
16186 {
16187 mask = myargv[optind + 1];
16188
16189 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16190
16191 if ((optind + 2) <= myargc)
16192 {
16193 struct stat file_stat;
16194
16195 if (stat (mask, &file_stat) == -1)
16196 {
16197 maskcnt = 1;
16198
16199 masks[maskcnt - 1] = mystrdup (mask);
16200 }
16201 else
16202 {
16203 int wls_left = myargc - (optind + 1);
16204
16205 uint masks_avail = INCR_MASKS;
16206
16207 for (int i = 0; i < wls_left; i++)
16208 {
16209 if (i != 0)
16210 {
16211 mask = myargv[optind + 1 + i];
16212
16213 if (stat (mask, &file_stat) == -1)
16214 {
16215 log_error ("ERROR: %s: %s", mask, strerror (errno));
16216
16217 return (-1);
16218 }
16219 }
16220
16221 uint is_file = S_ISREG (file_stat.st_mode);
16222
16223 if (is_file == 1)
16224 {
16225 FILE *mask_fp;
16226
16227 if ((mask_fp = fopen (mask, "r")) == NULL)
16228 {
16229 log_error ("ERROR: %s: %s", mask, strerror (errno));
16230
16231 return (-1);
16232 }
16233
16234 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16235
16236 while (!feof (mask_fp))
16237 {
16238 memset (line_buf, 0, HCBUFSIZ);
16239
16240 int line_len = fgetl (mask_fp, line_buf);
16241
16242 if (line_len == 0) continue;
16243
16244 if (line_buf[0] == '#') continue;
16245
16246 if (masks_avail == maskcnt)
16247 {
16248 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16249
16250 masks_avail += INCR_MASKS;
16251 }
16252
16253 masks[maskcnt] = mystrdup (line_buf);
16254
16255 maskcnt++;
16256 }
16257
16258 myfree (line_buf);
16259
16260 fclose (mask_fp);
16261 }
16262 else
16263 {
16264 log_error ("ERROR: %s: unsupported file-type", mask);
16265
16266 return (-1);
16267 }
16268 }
16269
16270 mask_from_file = 1;
16271 }
16272 }
16273 else
16274 {
16275 custom_charset_1 = (char *) "?l?d?u";
16276 custom_charset_2 = (char *) "?l?d";
16277 custom_charset_3 = (char *) "?l?d*!$@_";
16278
16279 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16280 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16281 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16282
16283 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16284
16285 wordlist_mode = WL_MODE_MASK;
16286
16287 data.wordlist_mode = wordlist_mode;
16288
16289 increment = 1;
16290
16291 maskcnt = 1;
16292 }
16293 }
16294 else
16295 {
16296 /**
16297 * generate full masks and charsets
16298 */
16299
16300 masks = (char **) mymalloc (sizeof (char *));
16301
16302 switch (hash_mode)
16303 {
16304 case 1731: pw_min = 5;
16305 pw_max = 5;
16306 mask = mystrdup ("?b?b?b?b?b");
16307 break;
16308 case 12500: pw_min = 5;
16309 pw_max = 5;
16310 mask = mystrdup ("?b?b?b?b?b");
16311 break;
16312 default: pw_min = 7;
16313 pw_max = 7;
16314 mask = mystrdup ("?b?b?b?b?b?b?b");
16315 break;
16316 }
16317
16318 maskcnt = 1;
16319
16320 masks[maskcnt - 1] = mystrdup (mask);
16321
16322 wordlist_mode = WL_MODE_MASK;
16323
16324 data.wordlist_mode = wordlist_mode;
16325
16326 increment = 1;
16327 }
16328
16329 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16330
16331 if (increment)
16332 {
16333 if (increment_min > pw_min) pw_min = increment_min;
16334
16335 if (increment_max < pw_max) pw_max = increment_max;
16336 }
16337 }
16338 else if (attack_mode == ATTACK_MODE_HYBRID1)
16339 {
16340 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16341
16342 // display
16343
16344 char *mask = myargv[myargc - 1];
16345
16346 maskcnt = 0;
16347
16348 masks = (char **) mymalloc (1 * sizeof (char *));
16349
16350 // mod
16351
16352 struct stat file_stat;
16353
16354 if (stat (mask, &file_stat) == -1)
16355 {
16356 maskcnt = 1;
16357
16358 masks[maskcnt - 1] = mystrdup (mask);
16359 }
16360 else
16361 {
16362 uint is_file = S_ISREG (file_stat.st_mode);
16363
16364 if (is_file == 1)
16365 {
16366 FILE *mask_fp;
16367
16368 if ((mask_fp = fopen (mask, "r")) == NULL)
16369 {
16370 log_error ("ERROR: %s: %s", mask, strerror (errno));
16371
16372 return (-1);
16373 }
16374
16375 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16376
16377 uint masks_avail = 1;
16378
16379 while (!feof (mask_fp))
16380 {
16381 memset (line_buf, 0, HCBUFSIZ);
16382
16383 int line_len = fgetl (mask_fp, line_buf);
16384
16385 if (line_len == 0) continue;
16386
16387 if (line_buf[0] == '#') continue;
16388
16389 if (masks_avail == maskcnt)
16390 {
16391 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16392
16393 masks_avail += INCR_MASKS;
16394 }
16395
16396 masks[maskcnt] = mystrdup (line_buf);
16397
16398 maskcnt++;
16399 }
16400
16401 myfree (line_buf);
16402
16403 fclose (mask_fp);
16404
16405 mask_from_file = 1;
16406 }
16407 else
16408 {
16409 maskcnt = 1;
16410
16411 masks[maskcnt - 1] = mystrdup (mask);
16412 }
16413 }
16414
16415 // base
16416
16417 int wls_left = myargc - (optind + 2);
16418
16419 for (int i = 0; i < wls_left; i++)
16420 {
16421 char *filename = myargv[optind + 1 + i];
16422
16423 struct stat file_stat;
16424
16425 if (stat (filename, &file_stat) == -1)
16426 {
16427 log_error ("ERROR: %s: %s", filename, strerror (errno));
16428
16429 return (-1);
16430 }
16431
16432 uint is_dir = S_ISDIR (file_stat.st_mode);
16433
16434 if (is_dir == 0)
16435 {
16436 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16437
16438 dictcnt++;
16439
16440 dictfiles[dictcnt - 1] = filename;
16441 }
16442 else
16443 {
16444 // do not allow --keyspace w/ a directory
16445
16446 if (keyspace == 1)
16447 {
16448 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16449
16450 return (-1);
16451 }
16452
16453 char **dictionary_files = NULL;
16454
16455 dictionary_files = scan_directory (filename);
16456
16457 if (dictionary_files != NULL)
16458 {
16459 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16460
16461 for (int d = 0; dictionary_files[d] != NULL; d++)
16462 {
16463 char *l1_filename = dictionary_files[d];
16464
16465 struct stat l1_stat;
16466
16467 if (stat (l1_filename, &l1_stat) == -1)
16468 {
16469 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16470
16471 return (-1);
16472 }
16473
16474 if (S_ISREG (l1_stat.st_mode))
16475 {
16476 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16477
16478 dictcnt++;
16479
16480 dictfiles[dictcnt - 1] = strdup (l1_filename);
16481 }
16482 }
16483 }
16484
16485 local_free (dictionary_files);
16486 }
16487 }
16488
16489 if (dictcnt < 1)
16490 {
16491 log_error ("ERROR: No usable dictionary file found.");
16492
16493 return (-1);
16494 }
16495
16496 if (increment)
16497 {
16498 maskcnt = 0;
16499
16500 uint mask_min = increment_min; // we can't reject smaller masks here
16501 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16502
16503 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16504 {
16505 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16506
16507 if (cur_mask == NULL) break;
16508
16509 masks[maskcnt] = cur_mask;
16510
16511 maskcnt++;
16512
16513 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16514 }
16515 }
16516 }
16517 else if (attack_mode == ATTACK_MODE_HYBRID2)
16518 {
16519 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16520
16521 // display
16522
16523 char *mask = myargv[optind + 1 + 0];
16524
16525 maskcnt = 0;
16526
16527 masks = (char **) mymalloc (1 * sizeof (char *));
16528
16529 // mod
16530
16531 struct stat file_stat;
16532
16533 if (stat (mask, &file_stat) == -1)
16534 {
16535 maskcnt = 1;
16536
16537 masks[maskcnt - 1] = mystrdup (mask);
16538 }
16539 else
16540 {
16541 uint is_file = S_ISREG (file_stat.st_mode);
16542
16543 if (is_file == 1)
16544 {
16545 FILE *mask_fp;
16546
16547 if ((mask_fp = fopen (mask, "r")) == NULL)
16548 {
16549 log_error ("ERROR: %s: %s", mask, strerror (errno));
16550
16551 return (-1);
16552 }
16553
16554 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16555
16556 uint masks_avail = 1;
16557
16558 while (!feof (mask_fp))
16559 {
16560 memset (line_buf, 0, HCBUFSIZ);
16561
16562 int line_len = fgetl (mask_fp, line_buf);
16563
16564 if (line_len == 0) continue;
16565
16566 if (line_buf[0] == '#') continue;
16567
16568 if (masks_avail == maskcnt)
16569 {
16570 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16571
16572 masks_avail += INCR_MASKS;
16573 }
16574
16575 masks[maskcnt] = mystrdup (line_buf);
16576
16577 maskcnt++;
16578 }
16579
16580 myfree (line_buf);
16581
16582 fclose (mask_fp);
16583
16584 mask_from_file = 1;
16585 }
16586 else
16587 {
16588 maskcnt = 1;
16589
16590 masks[maskcnt - 1] = mystrdup (mask);
16591 }
16592 }
16593
16594 // base
16595
16596 int wls_left = myargc - (optind + 2);
16597
16598 for (int i = 0; i < wls_left; i++)
16599 {
16600 char *filename = myargv[optind + 2 + i];
16601
16602 struct stat file_stat;
16603
16604 if (stat (filename, &file_stat) == -1)
16605 {
16606 log_error ("ERROR: %s: %s", filename, strerror (errno));
16607
16608 return (-1);
16609 }
16610
16611 uint is_dir = S_ISDIR (file_stat.st_mode);
16612
16613 if (is_dir == 0)
16614 {
16615 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16616
16617 dictcnt++;
16618
16619 dictfiles[dictcnt - 1] = filename;
16620 }
16621 else
16622 {
16623 // do not allow --keyspace w/ a directory
16624
16625 if (keyspace == 1)
16626 {
16627 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16628
16629 return (-1);
16630 }
16631
16632 char **dictionary_files = NULL;
16633
16634 dictionary_files = scan_directory (filename);
16635
16636 if (dictionary_files != NULL)
16637 {
16638 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16639
16640 for (int d = 0; dictionary_files[d] != NULL; d++)
16641 {
16642 char *l1_filename = dictionary_files[d];
16643
16644 struct stat l1_stat;
16645
16646 if (stat (l1_filename, &l1_stat) == -1)
16647 {
16648 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16649
16650 return (-1);
16651 }
16652
16653 if (S_ISREG (l1_stat.st_mode))
16654 {
16655 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16656
16657 dictcnt++;
16658
16659 dictfiles[dictcnt - 1] = strdup (l1_filename);
16660 }
16661 }
16662 }
16663
16664 local_free (dictionary_files);
16665 }
16666 }
16667
16668 if (dictcnt < 1)
16669 {
16670 log_error ("ERROR: No usable dictionary file found.");
16671
16672 return (-1);
16673 }
16674
16675 if (increment)
16676 {
16677 maskcnt = 0;
16678
16679 uint mask_min = increment_min; // we can't reject smaller masks here
16680 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16681
16682 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16683 {
16684 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16685
16686 if (cur_mask == NULL) break;
16687
16688 masks[maskcnt] = cur_mask;
16689
16690 maskcnt++;
16691
16692 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16693 }
16694 }
16695 }
16696
16697 data.pw_min = pw_min;
16698 data.pw_max = pw_max;
16699
16700 /**
16701 * weak hash check
16702 */
16703
16704 if (weak_hash_threshold >= salts_cnt)
16705 {
16706 hc_device_param_t *device_param = NULL;
16707
16708 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16709 {
16710 device_param = &data.devices_param[device_id];
16711
16712 if (device_param->skipped) continue;
16713
16714 break;
16715 }
16716
16717 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16718
16719 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16720 {
16721 weak_hash_check (device_param, salt_pos);
16722 }
16723
16724 // Display hack, guarantee that there is at least one \r before real start
16725
16726 //if (data.quiet == 0) log_info ("");
16727 }
16728
16729 /**
16730 * status and monitor threads
16731 */
16732
16733 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16734
16735 hc_thread_t i_thread = 0;
16736
16737 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16738 {
16739 hc_thread_create (i_thread, thread_keypress, &benchmark);
16740 }
16741
16742 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16743
16744 uint ni_threads_cnt = 0;
16745
16746 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16747
16748 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16749
16750 ni_threads_cnt++;
16751
16752 /**
16753 * Outfile remove
16754 */
16755
16756 if (keyspace == 0)
16757 {
16758 if (outfile_check_timer != 0)
16759 {
16760 if (data.outfile_check_directory != NULL)
16761 {
16762 if ((hash_mode != 5200) &&
16763 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16764 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16765 (hash_mode != 9000))
16766 {
16767 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16768
16769 ni_threads_cnt++;
16770 }
16771 else
16772 {
16773 outfile_check_timer = 0;
16774 }
16775 }
16776 else
16777 {
16778 outfile_check_timer = 0;
16779 }
16780 }
16781 }
16782
16783 /**
16784 * Inform the user if we got some hashes remove because of the pot file remove feature
16785 */
16786
16787 if (data.quiet == 0)
16788 {
16789 if (potfile_remove_cracks > 0)
16790 {
16791 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16792 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16793 }
16794 }
16795
16796 data.outfile_check_timer = outfile_check_timer;
16797
16798 /**
16799 * main loop
16800 */
16801
16802 char **induction_dictionaries = NULL;
16803
16804 int induction_dictionaries_cnt = 0;
16805
16806 hcstat_table_t *root_table_buf = NULL;
16807 hcstat_table_t *markov_table_buf = NULL;
16808
16809 uint initial_restore_done = 0;
16810
16811 data.maskcnt = maskcnt;
16812
16813 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16814 {
16815 if (data.devices_status == STATUS_CRACKED) break;
16816
16817 data.devices_status = STATUS_INIT;
16818
16819 if (maskpos > rd->maskpos)
16820 {
16821 rd->dictpos = 0;
16822 }
16823
16824 rd->maskpos = maskpos;
16825 data.maskpos = maskpos;
16826
16827 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16828 {
16829 char *mask = masks[maskpos];
16830
16831 if (mask_from_file == 1)
16832 {
16833 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16834
16835 char *str_ptr;
16836 uint str_pos;
16837
16838 uint mask_offset = 0;
16839
16840 uint separator_cnt;
16841
16842 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16843 {
16844 str_ptr = strstr (mask + mask_offset, ",");
16845
16846 if (str_ptr == NULL) break;
16847
16848 str_pos = str_ptr - mask;
16849
16850 // escaped separator, i.e. "\,"
16851
16852 if (str_pos > 0)
16853 {
16854 if (mask[str_pos - 1] == '\\')
16855 {
16856 separator_cnt --;
16857
16858 mask_offset = str_pos + 1;
16859
16860 continue;
16861 }
16862 }
16863
16864 // reset the offset
16865
16866 mask_offset = 0;
16867
16868 mask[str_pos] = '\0';
16869
16870 switch (separator_cnt)
16871 {
16872 case 0:
16873 mp_reset_usr (mp_usr, 0);
16874
16875 custom_charset_1 = mask;
16876 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16877 break;
16878
16879 case 1:
16880 mp_reset_usr (mp_usr, 1);
16881
16882 custom_charset_2 = mask;
16883 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16884 break;
16885
16886 case 2:
16887 mp_reset_usr (mp_usr, 2);
16888
16889 custom_charset_3 = mask;
16890 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16891 break;
16892
16893 case 3:
16894 mp_reset_usr (mp_usr, 3);
16895
16896 custom_charset_4 = mask;
16897 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16898 break;
16899 }
16900
16901 mask = mask + str_pos + 1;
16902 }
16903 }
16904
16905 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16906 {
16907 if (maskpos > 0)
16908 {
16909 local_free (css_buf);
16910 local_free (data.root_css_buf);
16911 local_free (data.markov_css_buf);
16912
16913 local_free (masks[maskpos - 1]);
16914 }
16915
16916 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16917
16918 data.mask = mask;
16919 data.css_cnt = css_cnt;
16920 data.css_buf = css_buf;
16921
16922 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16923
16924 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16925
16926 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16927 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16928
16929 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16930
16931 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16932
16933 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16934 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16935
16936 data.root_css_buf = root_css_buf;
16937 data.markov_css_buf = markov_css_buf;
16938
16939 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16940
16941 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16942
16943 local_free (root_table_buf);
16944 local_free (markov_table_buf);
16945
16946 // args
16947
16948 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16949 {
16950 hc_device_param_t *device_param = &data.devices_param[device_id];
16951
16952 if (device_param->skipped) continue;
16953
16954 device_param->kernel_params_mp[0] = &device_param->d_combs;
16955 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16956 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16957
16958 device_param->kernel_params_mp_buf64[3] = 0;
16959 device_param->kernel_params_mp_buf32[4] = css_cnt;
16960 device_param->kernel_params_mp_buf32[5] = 0;
16961 device_param->kernel_params_mp_buf32[6] = 0;
16962 device_param->kernel_params_mp_buf32[7] = 0;
16963
16964 if (attack_mode == ATTACK_MODE_HYBRID1)
16965 {
16966 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16967 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16968 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16969 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16970 }
16971 else if (attack_mode == ATTACK_MODE_HYBRID2)
16972 {
16973 device_param->kernel_params_mp_buf32[5] = 0;
16974 device_param->kernel_params_mp_buf32[6] = 0;
16975 device_param->kernel_params_mp_buf32[7] = 0;
16976 }
16977
16978 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]);
16979 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]);
16980 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]);
16981
16982 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);
16983 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);
16984 }
16985 }
16986 else if (attack_mode == ATTACK_MODE_BF)
16987 {
16988 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16989
16990 if (increment)
16991 {
16992 for (uint i = 0; i < dictcnt; i++)
16993 {
16994 local_free (dictfiles[i]);
16995 }
16996
16997 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16998 {
16999 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17000
17001 if (l1_filename == NULL) break;
17002
17003 dictcnt++;
17004
17005 dictfiles[dictcnt - 1] = l1_filename;
17006 }
17007 }
17008 else
17009 {
17010 dictcnt++;
17011
17012 dictfiles[dictcnt - 1] = mask;
17013 }
17014
17015 if (dictcnt == 0)
17016 {
17017 log_error ("ERROR: Mask is too small");
17018
17019 return (-1);
17020 }
17021 }
17022 }
17023
17024 free (induction_dictionaries);
17025
17026 // induction_dictionaries_cnt = 0; // implied
17027
17028 if (attack_mode != ATTACK_MODE_BF)
17029 {
17030 if (keyspace == 0)
17031 {
17032 induction_dictionaries = scan_directory (induction_directory);
17033
17034 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17035 }
17036 }
17037
17038 if (induction_dictionaries_cnt)
17039 {
17040 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17041 }
17042
17043 /**
17044 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17045 */
17046 if (keyspace == 1)
17047 {
17048 if ((maskcnt > 1) || (dictcnt > 1))
17049 {
17050 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17051
17052 return (-1);
17053 }
17054 }
17055
17056 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17057 {
17058 char *subid = logfile_generate_subid ();
17059
17060 data.subid = subid;
17061
17062 logfile_sub_msg ("START");
17063
17064 data.devices_status = STATUS_INIT;
17065
17066 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17067 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17068 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17069
17070 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17071
17072 data.cpt_pos = 0;
17073
17074 data.cpt_start = time (NULL);
17075
17076 data.cpt_total = 0;
17077
17078 if (data.restore == 0)
17079 {
17080 rd->words_cur = skip;
17081
17082 skip = 0;
17083
17084 data.skip = 0;
17085 }
17086
17087 data.ms_paused = 0;
17088
17089 data.kernel_power_final = 0;
17090
17091 data.words_cur = rd->words_cur;
17092
17093 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17094 {
17095 hc_device_param_t *device_param = &data.devices_param[device_id];
17096
17097 if (device_param->skipped) continue;
17098
17099 device_param->speed_pos = 0;
17100
17101 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17102 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17103
17104 device_param->exec_pos = 0;
17105
17106 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17107
17108 device_param->outerloop_pos = 0;
17109 device_param->outerloop_left = 0;
17110 device_param->innerloop_pos = 0;
17111 device_param->innerloop_left = 0;
17112
17113 // some more resets:
17114
17115 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17116
17117 device_param->pws_cnt = 0;
17118
17119 device_param->words_off = 0;
17120 device_param->words_done = 0;
17121 }
17122
17123 // figure out some workload
17124
17125 if (attack_mode == ATTACK_MODE_STRAIGHT)
17126 {
17127 if (data.wordlist_mode == WL_MODE_FILE)
17128 {
17129 char *dictfile = NULL;
17130
17131 if (induction_dictionaries_cnt)
17132 {
17133 dictfile = induction_dictionaries[0];
17134 }
17135 else
17136 {
17137 dictfile = dictfiles[dictpos];
17138 }
17139
17140 data.dictfile = dictfile;
17141
17142 logfile_sub_string (dictfile);
17143
17144 for (uint i = 0; i < rp_files_cnt; i++)
17145 {
17146 logfile_sub_var_string ("rulefile", rp_files[i]);
17147 }
17148
17149 FILE *fd2 = fopen (dictfile, "rb");
17150
17151 if (fd2 == NULL)
17152 {
17153 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17154
17155 return (-1);
17156 }
17157
17158 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17159
17160 fclose (fd2);
17161
17162 if (data.words_cnt == 0)
17163 {
17164 if (data.devices_status == STATUS_CRACKED) break;
17165 if (data.devices_status == STATUS_ABORTED) break;
17166
17167 dictpos++;
17168
17169 continue;
17170 }
17171 }
17172 }
17173 else if (attack_mode == ATTACK_MODE_COMBI)
17174 {
17175 char *dictfile = data.dictfile;
17176 char *dictfile2 = data.dictfile2;
17177
17178 logfile_sub_string (dictfile);
17179 logfile_sub_string (dictfile2);
17180
17181 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17182 {
17183 FILE *fd2 = fopen (dictfile, "rb");
17184
17185 if (fd2 == NULL)
17186 {
17187 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17188
17189 return (-1);
17190 }
17191
17192 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17193
17194 fclose (fd2);
17195 }
17196 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17197 {
17198 FILE *fd2 = fopen (dictfile2, "rb");
17199
17200 if (fd2 == NULL)
17201 {
17202 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17203
17204 return (-1);
17205 }
17206
17207 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17208
17209 fclose (fd2);
17210 }
17211
17212 if (data.words_cnt == 0)
17213 {
17214 if (data.devices_status == STATUS_CRACKED) break;
17215 if (data.devices_status == STATUS_ABORTED) break;
17216
17217 dictpos++;
17218
17219 continue;
17220 }
17221 }
17222 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17223 {
17224 char *dictfile = NULL;
17225
17226 if (induction_dictionaries_cnt)
17227 {
17228 dictfile = induction_dictionaries[0];
17229 }
17230 else
17231 {
17232 dictfile = dictfiles[dictpos];
17233 }
17234
17235 data.dictfile = dictfile;
17236
17237 char *mask = data.mask;
17238
17239 logfile_sub_string (dictfile);
17240 logfile_sub_string (mask);
17241
17242 FILE *fd2 = fopen (dictfile, "rb");
17243
17244 if (fd2 == NULL)
17245 {
17246 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17247
17248 return (-1);
17249 }
17250
17251 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17252
17253 fclose (fd2);
17254
17255 if (data.words_cnt == 0)
17256 {
17257 if (data.devices_status == STATUS_CRACKED) break;
17258 if (data.devices_status == STATUS_ABORTED) break;
17259
17260 dictpos++;
17261
17262 continue;
17263 }
17264 }
17265 else if (attack_mode == ATTACK_MODE_BF)
17266 {
17267 local_free (css_buf);
17268 local_free (data.root_css_buf);
17269 local_free (data.markov_css_buf);
17270
17271 char *mask = dictfiles[dictpos];
17272
17273 logfile_sub_string (mask);
17274
17275 // base
17276
17277 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17278
17279 if (opts_type & OPTS_TYPE_PT_UNICODE)
17280 {
17281 uint css_cnt_unicode = css_cnt * 2;
17282
17283 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17284
17285 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17286 {
17287 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17288
17289 css_buf_unicode[j + 1].cs_buf[0] = 0;
17290 css_buf_unicode[j + 1].cs_len = 1;
17291 }
17292
17293 free (css_buf);
17294
17295 css_buf = css_buf_unicode;
17296 css_cnt = css_cnt_unicode;
17297 }
17298
17299 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17300
17301 uint mask_min = pw_min;
17302 uint mask_max = pw_max;
17303
17304 if (opts_type & OPTS_TYPE_PT_UNICODE)
17305 {
17306 mask_min *= 2;
17307 mask_max *= 2;
17308 }
17309
17310 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17311 {
17312 if (css_cnt < mask_min)
17313 {
17314 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17315 }
17316
17317 if (css_cnt > mask_max)
17318 {
17319 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17320 }
17321
17322 // skip to next mask
17323
17324 dictpos++;
17325
17326 rd->dictpos = dictpos;
17327
17328 logfile_sub_msg ("STOP");
17329
17330 continue;
17331 }
17332
17333 uint save_css_cnt = css_cnt;
17334
17335 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17336 {
17337 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17338 {
17339 uint salt_len = (uint) data.salts_buf[0].salt_len;
17340 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17341
17342 uint css_cnt_salt = css_cnt + salt_len;
17343
17344 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17345
17346 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17347
17348 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17349 {
17350 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17351 css_buf_salt[j].cs_len = 1;
17352 }
17353
17354 free (css_buf);
17355
17356 css_buf = css_buf_salt;
17357 css_cnt = css_cnt_salt;
17358 }
17359 }
17360
17361 data.mask = mask;
17362 data.css_cnt = css_cnt;
17363 data.css_buf = css_buf;
17364
17365 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17366
17367 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17368
17369 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17370
17371 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17372 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17373
17374 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17375
17376 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17377
17378 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17379 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17380
17381 data.root_css_buf = root_css_buf;
17382 data.markov_css_buf = markov_css_buf;
17383
17384 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17385
17386 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17387
17388 local_free (root_table_buf);
17389 local_free (markov_table_buf);
17390
17391 // copy + args
17392
17393 uint css_cnt_l = css_cnt;
17394 uint css_cnt_r;
17395
17396 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17397 {
17398 if (save_css_cnt < 6)
17399 {
17400 css_cnt_r = 1;
17401 }
17402 else if (save_css_cnt == 6)
17403 {
17404 css_cnt_r = 2;
17405 }
17406 else
17407 {
17408 if (opts_type & OPTS_TYPE_PT_UNICODE)
17409 {
17410 if (save_css_cnt == 8 || save_css_cnt == 10)
17411 {
17412 css_cnt_r = 2;
17413 }
17414 else
17415 {
17416 css_cnt_r = 4;
17417 }
17418 }
17419 else
17420 {
17421 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17422 {
17423 css_cnt_r = 3;
17424 }
17425 else
17426 {
17427 css_cnt_r = 4;
17428 }
17429 }
17430 }
17431 }
17432 else
17433 {
17434 css_cnt_r = 1;
17435
17436 /* unfinished code?
17437 int sum = css_buf[css_cnt_r - 1].cs_len;
17438
17439 for (uint i = 1; i < 4 && i < css_cnt; i++)
17440 {
17441 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17442
17443 css_cnt_r++;
17444
17445 sum *= css_buf[css_cnt_r - 1].cs_len;
17446 }
17447 */
17448 }
17449
17450 css_cnt_l -= css_cnt_r;
17451
17452 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17453
17454 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17455 {
17456 hc_device_param_t *device_param = &data.devices_param[device_id];
17457
17458 if (device_param->skipped) continue;
17459
17460 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17461 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17462 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17463
17464 device_param->kernel_params_mp_l_buf64[3] = 0;
17465 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17466 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17467 device_param->kernel_params_mp_l_buf32[6] = 0;
17468 device_param->kernel_params_mp_l_buf32[7] = 0;
17469 device_param->kernel_params_mp_l_buf32[8] = 0;
17470
17471 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17472 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17473 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17474 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17475
17476 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17477 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17478 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17479
17480 device_param->kernel_params_mp_r_buf64[3] = 0;
17481 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17482 device_param->kernel_params_mp_r_buf32[5] = 0;
17483 device_param->kernel_params_mp_r_buf32[6] = 0;
17484 device_param->kernel_params_mp_r_buf32[7] = 0;
17485
17486 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]);
17487 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]);
17488 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]);
17489
17490 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]);
17491 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]);
17492 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]);
17493
17494 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);
17495 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);
17496 }
17497 }
17498
17499 u64 words_base = data.words_cnt;
17500
17501 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17502 {
17503 if (data.kernel_rules_cnt)
17504 {
17505 words_base /= data.kernel_rules_cnt;
17506 }
17507 }
17508 else if (data.attack_kern == ATTACK_KERN_COMBI)
17509 {
17510 if (data.combs_cnt)
17511 {
17512 words_base /= data.combs_cnt;
17513 }
17514 }
17515 else if (data.attack_kern == ATTACK_KERN_BF)
17516 {
17517 if (data.bfs_cnt)
17518 {
17519 words_base /= data.bfs_cnt;
17520 }
17521 }
17522
17523 data.words_base = words_base;
17524
17525 if (keyspace == 1)
17526 {
17527 log_info ("%llu", (unsigned long long int) words_base);
17528
17529 return (0);
17530 }
17531
17532 if (data.words_cur > data.words_base)
17533 {
17534 log_error ("ERROR: restore value greater keyspace");
17535
17536 return (-1);
17537 }
17538
17539 if (data.words_cur)
17540 {
17541 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17542 {
17543 for (uint i = 0; i < data.salts_cnt; i++)
17544 {
17545 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17546 }
17547 }
17548 else if (data.attack_kern == ATTACK_KERN_COMBI)
17549 {
17550 for (uint i = 0; i < data.salts_cnt; i++)
17551 {
17552 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17553 }
17554 }
17555 else if (data.attack_kern == ATTACK_KERN_BF)
17556 {
17557 for (uint i = 0; i < data.salts_cnt; i++)
17558 {
17559 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17560 }
17561 }
17562 }
17563
17564 /*
17565 * Update loopback file
17566 */
17567
17568 if (loopback == 1)
17569 {
17570 time_t now;
17571
17572 time (&now);
17573
17574 uint random_num = get_random_num (0, 9999);
17575
17576 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17577
17578 data.loopback_file = loopback_file;
17579 }
17580
17581 /*
17582 * Update dictionary statistic
17583 */
17584
17585 if (keyspace == 0)
17586 {
17587 dictstat_fp = fopen (dictstat, "wb");
17588
17589 if (dictstat_fp)
17590 {
17591 lock_file (dictstat_fp);
17592
17593 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17594
17595 fclose (dictstat_fp);
17596 }
17597 }
17598
17599 /**
17600 * create autotune threads
17601 */
17602
17603 data.devices_status = STATUS_AUTOTUNE;
17604
17605 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17606
17607 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17608 {
17609 hc_device_param_t *device_param = &devices_param[device_id];
17610
17611 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
17612 }
17613
17614 hc_thread_wait (data.devices_cnt, c_threads);
17615
17616 /*
17617 * Inform user about possible slow speeds
17618 */
17619
17620 uint hardware_power_all = 0;
17621
17622 uint kernel_power_all = 0;
17623
17624 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17625 {
17626 hc_device_param_t *device_param = &devices_param[device_id];
17627
17628 hardware_power_all += device_param->hardware_power;
17629
17630 kernel_power_all += device_param->kernel_power;
17631 }
17632
17633 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
17634
17635 data.kernel_power_all = kernel_power_all;
17636
17637 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17638 {
17639 if (data.words_base < kernel_power_all)
17640 {
17641 if (quiet == 0)
17642 {
17643 log_info ("ATTENTION!");
17644 log_info (" The wordlist or mask you are using is too small.");
17645 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17646 log_info (" The cracking speed will drop.");
17647 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17648 log_info ("");
17649 }
17650 }
17651 }
17652
17653 /**
17654 * create cracker threads
17655 */
17656
17657 data.devices_status = STATUS_RUNNING;
17658
17659 if (initial_restore_done == 0)
17660 {
17661 if (data.restore_disable == 0) cycle_restore ();
17662
17663 initial_restore_done = 1;
17664 }
17665
17666 hc_timer_set (&data.timer_running);
17667
17668 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17669 {
17670 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17671 {
17672 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17673 if (quiet == 0) fflush (stdout);
17674 }
17675 }
17676 else if (wordlist_mode == WL_MODE_STDIN)
17677 {
17678 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17679 if (data.quiet == 0) log_info ("");
17680 }
17681
17682 time_t runtime_start;
17683
17684 time (&runtime_start);
17685
17686 data.runtime_start = runtime_start;
17687
17688 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17689 {
17690 hc_device_param_t *device_param = &devices_param[device_id];
17691
17692 if (wordlist_mode == WL_MODE_STDIN)
17693 {
17694 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17695 }
17696 else
17697 {
17698 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17699 }
17700 }
17701
17702 hc_thread_wait (data.devices_cnt, c_threads);
17703
17704 local_free (c_threads);
17705
17706 data.restore = 0;
17707
17708 // finalize task
17709
17710 logfile_sub_var_uint ("status-after-work", data.devices_status);
17711
17712 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17713
17714 if (data.devices_status == STATUS_CRACKED) break;
17715 if (data.devices_status == STATUS_ABORTED) break;
17716
17717 if (data.devices_status == STATUS_BYPASS)
17718 {
17719 data.devices_status = STATUS_RUNNING;
17720 }
17721
17722 if (induction_dictionaries_cnt)
17723 {
17724 unlink (induction_dictionaries[0]);
17725 }
17726
17727 free (induction_dictionaries);
17728
17729 if (attack_mode != ATTACK_MODE_BF)
17730 {
17731 induction_dictionaries = scan_directory (induction_directory);
17732
17733 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17734 }
17735
17736 if (benchmark == 0)
17737 {
17738 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17739 {
17740 if (quiet == 0) clear_prompt ();
17741
17742 if (quiet == 0) log_info ("");
17743
17744 if (status == 1)
17745 {
17746 status_display ();
17747 }
17748 else
17749 {
17750 if (quiet == 0) status_display ();
17751 }
17752
17753 if (quiet == 0) log_info ("");
17754 }
17755 }
17756
17757 if (attack_mode == ATTACK_MODE_BF)
17758 {
17759 dictpos++;
17760
17761 rd->dictpos = dictpos;
17762 }
17763 else
17764 {
17765 if (induction_dictionaries_cnt)
17766 {
17767 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17768 }
17769 else
17770 {
17771 dictpos++;
17772
17773 rd->dictpos = dictpos;
17774 }
17775 }
17776
17777 time_t runtime_stop;
17778
17779 time (&runtime_stop);
17780
17781 data.runtime_stop = runtime_stop;
17782
17783 logfile_sub_uint (runtime_start);
17784 logfile_sub_uint (runtime_stop);
17785
17786 logfile_sub_msg ("STOP");
17787
17788 global_free (subid);
17789 }
17790
17791 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17792
17793 if (data.devices_status == STATUS_CRACKED) break;
17794 if (data.devices_status == STATUS_ABORTED) break;
17795 if (data.devices_status == STATUS_QUIT) break;
17796
17797 if (data.devices_status == STATUS_BYPASS)
17798 {
17799 data.devices_status = STATUS_RUNNING;
17800 }
17801 }
17802
17803 // 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
17804
17805 if (attack_mode == ATTACK_MODE_STRAIGHT)
17806 {
17807 if (data.wordlist_mode == WL_MODE_FILE)
17808 {
17809 if (data.dictfile == NULL)
17810 {
17811 if (dictfiles != NULL)
17812 {
17813 data.dictfile = dictfiles[0];
17814
17815 hc_timer_set (&data.timer_running);
17816 }
17817 }
17818 }
17819 }
17820 // NOTE: combi is okay because it is already set beforehand
17821 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17822 {
17823 if (data.dictfile == NULL)
17824 {
17825 if (dictfiles != NULL)
17826 {
17827 hc_timer_set (&data.timer_running);
17828
17829 data.dictfile = dictfiles[0];
17830 }
17831 }
17832 }
17833 else if (attack_mode == ATTACK_MODE_BF)
17834 {
17835 if (data.mask == NULL)
17836 {
17837 hc_timer_set (&data.timer_running);
17838
17839 data.mask = masks[0];
17840 }
17841 }
17842
17843 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17844 {
17845 data.devices_status = STATUS_EXHAUSTED;
17846 }
17847
17848 // if cracked / aborted remove last induction dictionary
17849
17850 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17851 {
17852 struct stat induct_stat;
17853
17854 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17855 {
17856 unlink (induction_dictionaries[file_pos]);
17857 }
17858 }
17859
17860 // wait for non-interactive threads
17861
17862 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17863 {
17864 hc_thread_wait (1, &ni_threads[thread_idx]);
17865 }
17866
17867 local_free (ni_threads);
17868
17869 // wait for interactive threads
17870
17871 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17872 {
17873 hc_thread_wait (1, &i_thread);
17874 }
17875
17876 // we dont need restore file anymore
17877 if (data.restore_disable == 0)
17878 {
17879 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17880 {
17881 unlink (eff_restore_file);
17882 unlink (new_restore_file);
17883 }
17884 else
17885 {
17886 cycle_restore ();
17887 }
17888 }
17889
17890 // finally save left hashes
17891
17892 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17893 {
17894 save_hash ();
17895 }
17896
17897 /**
17898 * Clean up
17899 */
17900
17901 if (benchmark == 1)
17902 {
17903 status_benchmark ();
17904
17905 if (machine_readable == 0)
17906 {
17907 log_info ("");
17908 }
17909 }
17910 else
17911 {
17912 if (quiet == 0) clear_prompt ();
17913
17914 if (quiet == 0) log_info ("");
17915
17916 if (status == 1)
17917 {
17918 status_display ();
17919 }
17920 else
17921 {
17922 if (quiet == 0) status_display ();
17923 }
17924
17925 if (quiet == 0) log_info ("");
17926 }
17927
17928 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17929 {
17930 hc_device_param_t *device_param = &data.devices_param[device_id];
17931
17932 if (device_param->skipped) continue;
17933
17934 local_free (device_param->combs_buf);
17935
17936 local_free (device_param->hooks_buf);
17937
17938 local_free (device_param->device_name);
17939
17940 local_free (device_param->device_name_chksum);
17941
17942 local_free (device_param->device_version);
17943
17944 local_free (device_param->driver_version);
17945
17946 if (device_param->pws_buf) myfree (device_param->pws_buf);
17947 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17948 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17949 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17950 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17951 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17952 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17953 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17954 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17955 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17956 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17957 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17958 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17959 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17960 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17961 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17962 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17963 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17964 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17965 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17966 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17967 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17968 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17969 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17970 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17971 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17972 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17973 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17974 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17975
17976 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17977 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17978 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17979 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17980 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17981 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17982 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17983 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17984 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17985 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17986 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17987
17988 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17989 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17990 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17991
17992 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17993 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17994 }
17995
17996 // reset default fan speed
17997
17998 #ifdef HAVE_HWMON
17999 if (gpu_temp_disable == 0)
18000 {
18001 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
18002 {
18003 hc_thread_mutex_lock (mux_adl);
18004
18005 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18006 {
18007 hc_device_param_t *device_param = &data.devices_param[device_id];
18008
18009 if (device_param->skipped) continue;
18010
18011 if (data.hm_device[device_id].fan_set_supported == 1)
18012 {
18013 int fanspeed = temp_retain_fanspeed_value[device_id];
18014 int fanpolicy = temp_retain_fanpolicy_value[device_id];
18015
18016 if (fanpolicy == 1)
18017 {
18018 int rc = -1;
18019
18020 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18021 {
18022 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
18023 }
18024 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18025 {
18026
18027 }
18028
18029 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18030 }
18031 }
18032 }
18033
18034 hc_thread_mutex_unlock (mux_adl);
18035 }
18036 }
18037
18038 // reset power tuning
18039
18040 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18041 {
18042 hc_thread_mutex_lock (mux_adl);
18043
18044 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18045 {
18046 hc_device_param_t *device_param = &data.devices_param[device_id];
18047
18048 if (device_param->skipped) continue;
18049
18050 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18051 {
18052 if (data.hm_device[device_id].od_version == 6)
18053 {
18054 // check powertune capabilities first, if not available then skip device
18055
18056 int powertune_supported = 0;
18057
18058 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18059 {
18060 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18061
18062 return (-1);
18063 }
18064
18065 if (powertune_supported != 0)
18066 {
18067 // powercontrol settings
18068
18069 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18070 {
18071 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18072
18073 return (-1);
18074 }
18075
18076 // clocks
18077
18078 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18079
18080 performance_state->iNumberOfPerformanceLevels = 2;
18081
18082 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18083 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18084 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18085 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18086
18087 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18088 {
18089 log_info ("ERROR: Failed to restore ADL performance state");
18090
18091 return (-1);
18092 }
18093
18094 local_free (performance_state);
18095 }
18096 }
18097 }
18098
18099 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18100 {
18101 unsigned int limit = nvml_power_limit[device_id];
18102
18103 if (limit > 0)
18104 {
18105 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18106 }
18107 }
18108 }
18109
18110 hc_thread_mutex_unlock (mux_adl);
18111 }
18112
18113 if (gpu_temp_disable == 0)
18114 {
18115 if (data.hm_nvml)
18116 {
18117 hm_NVML_nvmlShutdown (data.hm_nvml);
18118
18119 nvml_close (data.hm_nvml);
18120
18121 data.hm_nvml = NULL;
18122 }
18123
18124 if (data.hm_adl)
18125 {
18126 hm_ADL_Main_Control_Destroy (data.hm_adl);
18127
18128 adl_close (data.hm_adl);
18129
18130 data.hm_adl = NULL;
18131 }
18132 }
18133 #endif // HAVE_HWMON
18134
18135 // free memory
18136
18137 local_free (masks);
18138
18139 local_free (dictstat_base);
18140
18141 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18142 {
18143 pot_t *pot_ptr = &pot[pot_pos];
18144
18145 hash_t *hash = &pot_ptr->hash;
18146
18147 local_free (hash->digest);
18148
18149 if (isSalted)
18150 {
18151 local_free (hash->salt);
18152 }
18153 }
18154
18155 local_free (pot);
18156
18157 local_free (all_kernel_rules_cnt);
18158 local_free (all_kernel_rules_buf);
18159
18160 local_free (wl_data->buf);
18161 local_free (wl_data);
18162
18163 local_free (bitmap_s1_a);
18164 local_free (bitmap_s1_b);
18165 local_free (bitmap_s1_c);
18166 local_free (bitmap_s1_d);
18167 local_free (bitmap_s2_a);
18168 local_free (bitmap_s2_b);
18169 local_free (bitmap_s2_c);
18170 local_free (bitmap_s2_d);
18171
18172 #ifdef HAVE_HWMON
18173 local_free (temp_retain_fanspeed_value);
18174 local_free (od_clock_mem_status);
18175 local_free (od_power_control_status);
18176 local_free (nvml_power_limit);
18177 #endif
18178
18179 global_free (devices_param);
18180
18181 global_free (kernel_rules_buf);
18182
18183 global_free (root_css_buf);
18184 global_free (markov_css_buf);
18185
18186 global_free (digests_buf);
18187 global_free (digests_shown);
18188 global_free (digests_shown_tmp);
18189
18190 global_free (salts_buf);
18191 global_free (salts_shown);
18192
18193 global_free (esalts_buf);
18194
18195 global_free (words_progress_done);
18196 global_free (words_progress_rejected);
18197 global_free (words_progress_restored);
18198
18199 if (pot_fp) fclose (pot_fp);
18200
18201 if (data.devices_status == STATUS_QUIT) break;
18202 }
18203
18204 // destroy others mutex
18205
18206 hc_thread_mutex_delete (mux_dispatcher);
18207 hc_thread_mutex_delete (mux_counter);
18208 hc_thread_mutex_delete (mux_display);
18209 hc_thread_mutex_delete (mux_adl);
18210
18211 // free memory
18212
18213 local_free (eff_restore_file);
18214 local_free (new_restore_file);
18215
18216 local_free (rd);
18217
18218 // tuning db
18219
18220 tuning_db_destroy (tuning_db);
18221
18222 // loopback
18223
18224 local_free (loopback_file);
18225
18226 if (loopback == 1) unlink (loopback_file);
18227
18228 // induction directory
18229
18230 if (induction_dir == NULL)
18231 {
18232 if (attack_mode != ATTACK_MODE_BF)
18233 {
18234 if (rmdir (induction_directory) == -1)
18235 {
18236 if (errno == ENOENT)
18237 {
18238 // good, we can ignore
18239 }
18240 else if (errno == ENOTEMPTY)
18241 {
18242 // good, we can ignore
18243 }
18244 else
18245 {
18246 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18247
18248 return (-1);
18249 }
18250 }
18251
18252 local_free (induction_directory);
18253 }
18254 }
18255
18256 // outfile-check directory
18257
18258 if (outfile_check_dir == NULL)
18259 {
18260 if (rmdir (outfile_check_directory) == -1)
18261 {
18262 if (errno == ENOENT)
18263 {
18264 // good, we can ignore
18265 }
18266 else if (errno == ENOTEMPTY)
18267 {
18268 // good, we can ignore
18269 }
18270 else
18271 {
18272 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18273
18274 return (-1);
18275 }
18276 }
18277
18278 local_free (outfile_check_directory);
18279 }
18280
18281 time_t proc_stop;
18282
18283 time (&proc_stop);
18284
18285 logfile_top_uint (proc_start);
18286 logfile_top_uint (proc_stop);
18287
18288 logfile_top_msg ("STOP");
18289
18290 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18291 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18292
18293 if (data.ocl) ocl_close (data.ocl);
18294
18295 if (data.devices_status == STATUS_ABORTED) return 2;
18296 if (data.devices_status == STATUS_QUIT) return 2;
18297 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18298 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18299 if (data.devices_status == STATUS_CRACKED) return 0;
18300
18301 return -1;
18302 }
Hashcat additions to support pwdhash