projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Here it is: --powertune-enable for nvidia -- Works on both linux and windows
[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 global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 13711,
283 13721,
284 13731,
285 13741,
286 13751,
287 13761,
288 8800,
289 12900,
290 12200,
291 9700,
292 9710,
293 9800,
294 9810,
295 9400,
296 9500,
297 9600,
298 10400,
299 10410,
300 10500,
301 10600,
302 10700,
303 9000,
304 5200,
305 6800,
306 6600,
307 8200,
308 11300,
309 12700,
310 13400,
311 125
312 };
313
314 /**
315 * types
316 */
317
318 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
319
320 /**
321 * globals
322 */
323
324 static unsigned int full01 = 0x01010101;
325 static unsigned int full80 = 0x80808080;
326
327 int SUPPRESS_OUTPUT = 0;
328
329 hc_thread_mutex_t mux_adl;
330 hc_thread_mutex_t mux_counter;
331 hc_thread_mutex_t mux_dispatcher;
332 hc_thread_mutex_t mux_display;
333
334 hc_global_data_t data;
335
336 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
337
338 const char *USAGE_MINI[] =
339 {
340 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
341 "",
342 "Try --help for more help.",
343 NULL
344 };
345
346 const char *USAGE_BIG[] =
347 {
348 "%s, advanced password recovery",
349 "",
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "- [ Options ] -",
353 "",
354 " Options Short / Long | Type | Description | Example",
355 "===============================|======|======================================================|=======================",
356 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
357 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
358 " -V, --version | | Print version |",
359 " -h, --help | | Print help |",
360 " --quiet | | Suppress output |",
361 " --hex-charset | | Assume charset is given in hex |",
362 " --hex-salt | | Assume salt is given in hex |",
363 " --hex-wordlist | | Assume words in wordlist is given in hex |",
364 " --force | | Ignore warnings |",
365 " --status | | Enable automatic update of the status-screen |",
366 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
367 " --machine-readable | | Display the status view in a machine readable format |",
368 " --loopback | | Add new plains to induct directory |",
369 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
370 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
371 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
372 " --markov-classic | | Enables classic markov-chains, no per-position |",
373 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
374 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
375 " --session | Str | Define specific session name | --session=mysession",
376 " --restore | | Restore session from --session |",
377 " --restore-disable | | Do not write restore file |",
378 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
379 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
380 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
381 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
382 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
383 " --show | | Show cracked passwords only |",
384 " --left | | Show un-cracked passwords only |",
385 " --username | | Enable ignoring of usernames in hashfile |",
386 " --remove | | Enable remove of hash once it is cracked |",
387 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
388 " --potfile-disable | | Do not write potfile |",
389 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
390 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
391 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
392 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
393 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
394 " --logfile-disable | | Disable the logfile |",
395 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
396 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
397 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
398 " -b, --benchmark | | Run benchmark |",
399 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
400 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
401 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
402 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
403 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
404 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
405 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
406 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
407 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
408 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
409 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
410 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
411 #ifdef HAVE_HWMON
412 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
413 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
414 " --powertune-enable | | Enable power tuning, restores settings when finished |",
415 #endif
416 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
417 " -s, --skip | Num | Skip X words from the start | -s 1000000",
418 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
419 " --keyspace | | Show keyspace base:mod values and quit |",
420 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
421 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
422 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
423 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
424 " --generate-rules-func-min | Num | Force min X funcs per rule |",
425 " --generate-rules-func-max | Num | Force max X funcs per rule |",
426 " --generate-rules-seed | Num | Force RNG seed set to X |",
427 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
428 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
429 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
430 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
431 " -i, --increment | | Enable mask increment mode |",
432 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
433 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
434 "",
435 "- [ Hash modes ] -",
436 "",
437 " # | Name | Category",
438 " ======+==================================================+======================================",
439 " 900 | MD4 | Raw Hash",
440 " 0 | MD5 | Raw Hash",
441 " 5100 | Half MD5 | Raw Hash",
442 " 100 | SHA1 | Raw Hash",
443 " 10800 | SHA-384 | Raw Hash",
444 " 1400 | SHA-256 | Raw Hash",
445 " 1700 | SHA-512 | Raw Hash",
446 " 5000 | SHA-3(Keccak) | Raw Hash",
447 " 10100 | SipHash | Raw Hash",
448 " 6000 | RipeMD160 | Raw Hash",
449 " 6100 | Whirlpool | Raw Hash",
450 " 6900 | GOST R 34.11-94 | Raw Hash",
451 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
452 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
453 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
454 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
455 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
456 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
457 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
458 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
459 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
460 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
461 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
462 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
463 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
464 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
465 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
466 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
467 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
468 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
469 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
470 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
471 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
472 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
473 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
474 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
475 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
476 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
477 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
478 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
479 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
480 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
481 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
482 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
483 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
484 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
485 " 400 | phpass | Generic KDF",
486 " 8900 | scrypt | Generic KDF",
487 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
488 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
489 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
490 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
491 " 23 | Skype | Network protocols",
492 " 2500 | WPA/WPA2 | Network protocols",
493 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
494 " 5300 | IKE-PSK MD5 | Network protocols",
495 " 5400 | IKE-PSK SHA1 | Network protocols",
496 " 5500 | NetNTLMv1 | Network protocols",
497 " 5500 | NetNTLMv1 + ESS | Network protocols",
498 " 5600 | NetNTLMv2 | Network protocols",
499 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
500 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
501 " 8300 | DNSSEC (NSEC3) | Network protocols",
502 " 10200 | Cram MD5 | Network protocols",
503 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
504 " 11200 | MySQL CRAM (SHA1) | Network protocols",
505 " 11400 | SIP digest authentication (MD5) | Network protocols",
506 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
507 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
508 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
509 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
510 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
511 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
512 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
513 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
514 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
515 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
516 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
517 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
518 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
519 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
520 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
521 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
522 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
523 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
524 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
525 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
526 " 12 | PostgreSQL | Database Server",
527 " 131 | MSSQL(2000) | Database Server",
528 " 132 | MSSQL(2005) | Database Server",
529 " 1731 | MSSQL(2012) | Database Server",
530 " 1731 | MSSQL(2014) | Database Server",
531 " 200 | MySQL323 | Database Server",
532 " 300 | MySQL4.1/MySQL5 | Database Server",
533 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
534 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
535 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
536 " 8000 | Sybase ASE | Database Server",
537 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
538 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
539 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
540 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
541 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
542 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
543 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
544 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
545 " 11500 | CRC32 | Checksums",
546 " 3000 | LM | Operating-Systems",
547 " 1000 | NTLM | Operating-Systems",
548 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
549 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
550 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
551 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
552 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
553 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
554 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
555 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
556 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
557 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
558 " 1722 | OSX v10.7 | Operating-Systems",
559 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
560 " 6300 | AIX {smd5} | Operating-Systems",
561 " 6700 | AIX {ssha1} | Operating-Systems",
562 " 6400 | AIX {ssha256} | Operating-Systems",
563 " 6500 | AIX {ssha512} | Operating-Systems",
564 " 2400 | Cisco-PIX | Operating-Systems",
565 " 2410 | Cisco-ASA | Operating-Systems",
566 " 500 | Cisco-IOS $1$ | Operating-Systems",
567 " 5700 | Cisco-IOS $4$ | Operating-Systems",
568 " 9200 | Cisco-IOS $8$ | Operating-Systems",
569 " 9300 | Cisco-IOS $9$ | Operating-Systems",
570 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
571 " 501 | Juniper IVE | Operating-Systems",
572 " 5800 | Android PIN | Operating-Systems",
573 " 8100 | Citrix Netscaler | Operating-Systems",
574 " 8500 | RACF | Operating-Systems",
575 " 7200 | GRUB 2 | Operating-Systems",
576 " 9900 | Radmin2 | Operating-Systems",
577 " 125 | ArubaOS | Operating-Systems",
578 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
579 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
580 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
581 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
582 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
583 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
584 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
585 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
586 " 11600 | 7-Zip | Archives",
587 " 12500 | RAR3-hp | Archives",
588 " 13000 | RAR5 | Archives",
589 " 13200 | AxCrypt | Archives",
590 " 13300 | AxCrypt in memory SHA1 | Archives",
591 " 13600 | WinZip | Archives",
592 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
593 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
594 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
595 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
596 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
597 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
598 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
599 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
600 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
601 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
602 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
603 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
604 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
605 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
606 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
607 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
608 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
609 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
610 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
611 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
612 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
613 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
614 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
615 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
616 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
617 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
618 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
619 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
620 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
621 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
622 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
623 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
624 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
625 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
626 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
627 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
628 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
629 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
630 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
631 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
632 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
633 " 9400 | MS Office 2007 | Documents",
634 " 9500 | MS Office 2010 | Documents",
635 " 9600 | MS Office 2013 | Documents",
636 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
637 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
638 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
639 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
640 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
641 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
642 " 9000 | Password Safe v2 | Password Managers",
643 " 5200 | Password Safe v3 | Password Managers",
644 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
645 " 6600 | 1Password, agilekeychain | Password Managers",
646 " 8200 | 1Password, cloudkeychain | Password Managers",
647 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
648 " 12700 | Blockchain, My Wallet | Password Managers",
649 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
650 "",
651 "- [ Outfile Formats ] -",
652 "",
653 " # | Format",
654 " ===+========",
655 " 1 | hash[:salt]",
656 " 2 | plain",
657 " 3 | hash[:salt]:plain",
658 " 4 | hex_plain",
659 " 5 | hash[:salt]:hex_plain",
660 " 6 | plain:hex_plain",
661 " 7 | hash[:salt]:plain:hex_plain",
662 " 8 | crackpos",
663 " 9 | hash[:salt]:crack_pos",
664 " 10 | plain:crack_pos",
665 " 11 | hash[:salt]:plain:crack_pos",
666 " 12 | hex_plain:crack_pos",
667 " 13 | hash[:salt]:hex_plain:crack_pos",
668 " 14 | plain:hex_plain:crack_pos",
669 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
670 "",
671 "- [ Rule Debugging Modes ] -",
672 "",
673 " # | Format",
674 " ===+========",
675 " 1 | Finding-Rule",
676 " 2 | Original-Word",
677 " 3 | Original-Word:Finding-Rule",
678 " 4 | Original-Word:Finding-Rule:Processed-Word",
679 "",
680 "- [ Attack Modes ] -",
681 "",
682 " # | Mode",
683 " ===+======",
684 " 0 | Straight",
685 " 1 | Combination",
686 " 3 | Brute-force",
687 " 6 | Hybrid Wordlist + Mask",
688 " 7 | Hybrid Mask + Wordlist",
689 "",
690 "- [ Built-in Charsets ] -",
691 "",
692 " ? | Charset",
693 " ===+=========",
694 " l | abcdefghijklmnopqrstuvwxyz",
695 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
696 " d | 0123456789",
697 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
698 " a | ?l?u?d?s",
699 " b | 0x00 - 0xff",
700 "",
701 "- [ OpenCL Device Types ] -",
702 "",
703 " # | Device Type",
704 " ===+=============",
705 " 1 | CPU",
706 " 2 | GPU",
707 " 3 | FPGA, DSP, Co-Processor",
708 "",
709 "- [ Workload Profiles ] -",
710 "",
711 " # | Performance | Runtime | Power Consumption | Desktop Impact",
712 " ===+=============+=========+===================+=================",
713 " 1 | Low | 2 ms | Low | Minimal",
714 " 2 | Default | 12 ms | Economic | Noticeable",
715 " 3 | High | 96 ms | High | Unresponsive",
716 " 4 | Nightmare | 480 ms | Insane | Headless",
717 "",
718 "If you have no idea what just happened then visit the following pages:",
719 "",
720 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
721 "* https://hashcat.net/wiki/#frequently_asked_questions",
722 "",
723 NULL
724 };
725
726 /**
727 * hashcat specific functions
728 */
729
730 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
731 {
732 int exec_pos = (int) device_param->exec_pos - last_num_entries;
733
734 if (exec_pos < 0) exec_pos += EXEC_CACHE;
735
736 double exec_ms_sum = 0;
737
738 int exec_ms_cnt = 0;
739
740 for (int i = 0; i < last_num_entries; i++)
741 {
742 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
743
744 if (exec_ms)
745 {
746 exec_ms_sum += exec_ms;
747
748 exec_ms_cnt++;
749 }
750 }
751
752 if (exec_ms_cnt == 0) return 0;
753
754 return exec_ms_sum / exec_ms_cnt;
755 }
756
757 void status_display_machine_readable ()
758 {
759 FILE *out = stdout;
760
761 fprintf (out, "STATUS\t%u\t", data.devices_status);
762
763 /**
764 * speed new
765 */
766
767 fprintf (out, "SPEED\t");
768
769 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
770 {
771 hc_device_param_t *device_param = &data.devices_param[device_id];
772
773 if (device_param->skipped) continue;
774
775 u64 speed_cnt = 0;
776 double speed_ms = 0;
777
778 for (int i = 0; i < SPEED_CACHE; i++)
779 {
780 speed_cnt += device_param->speed_cnt[i];
781 speed_ms += device_param->speed_ms[i];
782 }
783
784 speed_cnt /= SPEED_CACHE;
785 speed_ms /= SPEED_CACHE;
786
787 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
788 }
789
790 /**
791 * exec time
792 */
793
794 fprintf (out, "EXEC_RUNTIME\t");
795
796 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
797 {
798 hc_device_param_t *device_param = &data.devices_param[device_id];
799
800 if (device_param->skipped) continue;
801
802 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
803
804 fprintf (out, "%f\t", exec_ms_avg);
805 }
806
807 /**
808 * words_cur
809 */
810
811 u64 words_cur = get_lowest_words_done ();
812
813 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
814
815 /**
816 * counter
817 */
818
819 u64 progress_total = data.words_cnt * data.salts_cnt;
820
821 u64 all_done = 0;
822 u64 all_rejected = 0;
823 u64 all_restored = 0;
824
825 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
826 {
827 all_done += data.words_progress_done[salt_pos];
828 all_rejected += data.words_progress_rejected[salt_pos];
829 all_restored += data.words_progress_restored[salt_pos];
830 }
831
832 u64 progress_cur = all_restored + all_done + all_rejected;
833 u64 progress_end = progress_total;
834
835 u64 progress_skip = 0;
836
837 if (data.skip)
838 {
839 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
840
841 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
842 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
843 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
844 }
845
846 if (data.limit)
847 {
848 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
849
850 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
851 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
852 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
853 }
854
855 u64 progress_cur_relative_skip = progress_cur - progress_skip;
856 u64 progress_end_relative_skip = progress_end - progress_skip;
857
858 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
859
860 /**
861 * cracks
862 */
863
864 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
865 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
866
867 /**
868 * temperature
869 */
870
871 #ifdef HAVE_HWMON
872 if (data.gpu_temp_disable == 0)
873 {
874 fprintf (out, "TEMP\t");
875
876 hc_thread_mutex_lock (mux_adl);
877
878 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
879 {
880 hc_device_param_t *device_param = &data.devices_param[device_id];
881
882 if (device_param->skipped) continue;
883
884 int temp = hm_get_temperature_with_device_id (device_id);
885
886 fprintf (out, "%d\t", temp);
887 }
888
889 hc_thread_mutex_unlock (mux_adl);
890 }
891 #endif // HAVE_HWMON
892
893 /**
894 * flush
895 */
896
897 #ifdef _WIN
898 fputc ('\r', out);
899 fputc ('\n', out);
900 #endif
901
902 #ifdef _POSIX
903 fputc ('\n', out);
904 #endif
905
906 fflush (out);
907 }
908
909 void status_display ()
910 {
911 if (data.devices_status == STATUS_INIT) return;
912 if (data.devices_status == STATUS_STARTING) return;
913 if (data.devices_status == STATUS_BYPASS) return;
914
915 if (data.machine_readable == 1)
916 {
917 status_display_machine_readable ();
918
919 return;
920 }
921
922 char tmp_buf[1000] = { 0 };
923
924 uint tmp_len = 0;
925
926 log_info ("Session.Name...: %s", data.session);
927
928 char *status_type = strstatus (data.devices_status);
929
930 uint hash_mode = data.hash_mode;
931
932 char *hash_type = strhashtype (hash_mode); // not a bug
933
934 log_info ("Status.........: %s", status_type);
935
936 /**
937 * show rules
938 */
939
940 if (data.rp_files_cnt)
941 {
942 uint i;
943
944 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
945 {
946 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
947 }
948
949 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
950
951 log_info ("Rules.Type.....: %s", tmp_buf);
952
953 tmp_len = 0;
954 }
955
956 if (data.rp_gen)
957 {
958 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
959
960 if (data.rp_gen_seed)
961 {
962 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
963 }
964 }
965
966 /**
967 * show input
968 */
969
970 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
971 {
972 if (data.wordlist_mode == WL_MODE_FILE)
973 {
974 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
975 }
976 else if (data.wordlist_mode == WL_MODE_STDIN)
977 {
978 log_info ("Input.Mode.....: Pipe");
979 }
980 }
981 else if (data.attack_mode == ATTACK_MODE_COMBI)
982 {
983 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
984 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
985 }
986 else if (data.attack_mode == ATTACK_MODE_BF)
987 {
988 char *mask = data.mask;
989
990 if (mask != NULL)
991 {
992 uint mask_len = data.css_cnt;
993
994 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
995
996 if (mask_len > 0)
997 {
998 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
999 {
1000 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1001 {
1002 mask_len -= data.salts_buf[0].salt_len;
1003 }
1004 }
1005
1006 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1007
1008 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1009 }
1010
1011 if (data.maskcnt > 1)
1012 {
1013 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1014
1015 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1016 }
1017
1018 log_info ("Input.Mode.....: %s", tmp_buf);
1019 }
1020
1021 tmp_len = 0;
1022 }
1023 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1024 {
1025 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1026 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1027 }
1028 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1029 {
1030 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1031 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1032 }
1033
1034 if (data.digests_cnt == 1)
1035 {
1036 if (data.hash_mode == 2500)
1037 {
1038 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1039
1040 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1041 (char *) data.salts_buf[0].salt_buf,
1042 wpa->orig_mac1[0],
1043 wpa->orig_mac1[1],
1044 wpa->orig_mac1[2],
1045 wpa->orig_mac1[3],
1046 wpa->orig_mac1[4],
1047 wpa->orig_mac1[5],
1048 wpa->orig_mac2[0],
1049 wpa->orig_mac2[1],
1050 wpa->orig_mac2[2],
1051 wpa->orig_mac2[3],
1052 wpa->orig_mac2[4],
1053 wpa->orig_mac2[5]);
1054 }
1055 else if (data.hash_mode == 5200)
1056 {
1057 log_info ("Hash.Target....: File (%s)", data.hashfile);
1058 }
1059 else if (data.hash_mode == 9000)
1060 {
1061 log_info ("Hash.Target....: File (%s)", data.hashfile);
1062 }
1063 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1064 {
1065 log_info ("Hash.Target....: File (%s)", data.hashfile);
1066 }
1067 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1068 {
1069 log_info ("Hash.Target....: File (%s)", data.hashfile);
1070 }
1071 else
1072 {
1073 char out_buf[HCBUFSIZ] = { 0 };
1074
1075 ascii_digest (out_buf, 0, 0);
1076
1077 // limit length
1078 if (strlen (out_buf) > 40)
1079 {
1080 out_buf[41] = '.';
1081 out_buf[42] = '.';
1082 out_buf[43] = '.';
1083 out_buf[44] = 0;
1084 }
1085
1086 log_info ("Hash.Target....: %s", out_buf);
1087 }
1088 }
1089 else
1090 {
1091 if (data.hash_mode == 3000)
1092 {
1093 char out_buf1[32] = { 0 };
1094 char out_buf2[32] = { 0 };
1095
1096 ascii_digest (out_buf1, 0, 0);
1097 ascii_digest (out_buf2, 0, 1);
1098
1099 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1100 }
1101 else
1102 {
1103 log_info ("Hash.Target....: File (%s)", data.hashfile);
1104 }
1105 }
1106
1107 log_info ("Hash.Type......: %s", hash_type);
1108
1109 /**
1110 * speed new
1111 */
1112
1113 u64 speed_cnt[DEVICES_MAX] = { 0 };
1114 double speed_ms[DEVICES_MAX] = { 0 };
1115
1116 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1117 {
1118 hc_device_param_t *device_param = &data.devices_param[device_id];
1119
1120 if (device_param->skipped) continue;
1121
1122 speed_cnt[device_id] = 0;
1123 speed_ms[device_id] = 0;
1124
1125 for (int i = 0; i < SPEED_CACHE; i++)
1126 {
1127 speed_cnt[device_id] += device_param->speed_cnt[i];
1128 speed_ms[device_id] += device_param->speed_ms[i];
1129 }
1130
1131 speed_cnt[device_id] /= SPEED_CACHE;
1132 speed_ms[device_id] /= SPEED_CACHE;
1133 }
1134
1135 double hashes_all_ms = 0;
1136
1137 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1138
1139 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1140 {
1141 hc_device_param_t *device_param = &data.devices_param[device_id];
1142
1143 if (device_param->skipped) continue;
1144
1145 hashes_dev_ms[device_id] = 0;
1146
1147 if (speed_ms[device_id])
1148 {
1149 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1150
1151 hashes_all_ms += hashes_dev_ms[device_id];
1152 }
1153 }
1154
1155 /**
1156 * exec time
1157 */
1158
1159 double exec_all_ms[DEVICES_MAX] = { 0 };
1160
1161 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1162 {
1163 hc_device_param_t *device_param = &data.devices_param[device_id];
1164
1165 if (device_param->skipped) continue;
1166
1167 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1168
1169 exec_all_ms[device_id] = exec_ms_avg;
1170 }
1171
1172 /**
1173 * timers
1174 */
1175
1176 double ms_running = 0;
1177
1178 hc_timer_get (data.timer_running, ms_running);
1179
1180 double ms_paused = data.ms_paused;
1181
1182 if (data.devices_status == STATUS_PAUSED)
1183 {
1184 double ms_paused_tmp = 0;
1185
1186 hc_timer_get (data.timer_paused, ms_paused_tmp);
1187
1188 ms_paused += ms_paused_tmp;
1189 }
1190
1191 #ifdef WIN
1192
1193 __time64_t sec_run = ms_running / 1000;
1194
1195 #else
1196
1197 time_t sec_run = ms_running / 1000;
1198
1199 #endif
1200
1201 if (sec_run)
1202 {
1203 char display_run[32] = { 0 };
1204
1205 struct tm tm_run;
1206
1207 struct tm *tmp = NULL;
1208
1209 #ifdef WIN
1210
1211 tmp = _gmtime64 (&sec_run);
1212
1213 #else
1214
1215 tmp = gmtime (&sec_run);
1216
1217 #endif
1218
1219 if (tmp != NULL)
1220 {
1221 memset (&tm_run, 0, sizeof (tm_run));
1222
1223 memcpy (&tm_run, tmp, sizeof (tm_run));
1224
1225 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1226
1227 char *start = ctime (&data.proc_start);
1228
1229 size_t start_len = strlen (start);
1230
1231 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1232 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1233
1234 log_info ("Time.Started...: %s (%s)", start, display_run);
1235 }
1236 }
1237 else
1238 {
1239 log_info ("Time.Started...: 0 secs");
1240 }
1241
1242 /**
1243 * counters
1244 */
1245
1246 u64 progress_total = data.words_cnt * data.salts_cnt;
1247
1248 u64 all_done = 0;
1249 u64 all_rejected = 0;
1250 u64 all_restored = 0;
1251
1252 u64 progress_noneed = 0;
1253
1254 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1255 {
1256 all_done += data.words_progress_done[salt_pos];
1257 all_rejected += data.words_progress_rejected[salt_pos];
1258 all_restored += data.words_progress_restored[salt_pos];
1259
1260 // Important for ETA only
1261
1262 if (data.salts_shown[salt_pos] == 1)
1263 {
1264 const u64 all = data.words_progress_done[salt_pos]
1265 + data.words_progress_rejected[salt_pos]
1266 + data.words_progress_restored[salt_pos];
1267
1268 const u64 left = data.words_cnt - all;
1269
1270 progress_noneed += left;
1271 }
1272 }
1273
1274 u64 progress_cur = all_restored + all_done + all_rejected;
1275 u64 progress_end = progress_total;
1276
1277 u64 progress_skip = 0;
1278
1279 if (data.skip)
1280 {
1281 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1282
1283 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1284 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1285 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1286 }
1287
1288 if (data.limit)
1289 {
1290 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1291
1292 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1293 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1294 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1295 }
1296
1297 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1298 u64 progress_end_relative_skip = progress_end - progress_skip;
1299
1300 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1301 {
1302 if (data.devices_status != STATUS_CRACKED)
1303 {
1304 #ifdef WIN
1305 __time64_t sec_etc = 0;
1306 #else
1307 time_t sec_etc = 0;
1308 #endif
1309
1310 if (hashes_all_ms)
1311 {
1312 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1313
1314 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1315
1316 sec_etc = ms_left / 1000;
1317 }
1318
1319 if (sec_etc == 0)
1320 {
1321 //log_info ("Time.Estimated.: 0 secs");
1322 }
1323 else if ((u64) sec_etc > ETC_MAX)
1324 {
1325 log_info ("Time.Estimated.: > 10 Years");
1326 }
1327 else
1328 {
1329 char display_etc[32] = { 0 };
1330
1331 struct tm tm_etc;
1332
1333 struct tm *tmp = NULL;
1334
1335 #ifdef WIN
1336
1337 tmp = _gmtime64 (&sec_etc);
1338
1339 #else
1340
1341 tmp = gmtime (&sec_etc);
1342
1343 #endif
1344
1345 if (tmp != NULL)
1346 {
1347 memset (&tm_etc, 0, sizeof (tm_etc));
1348
1349 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1350
1351 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1352
1353 time_t now;
1354
1355 time (&now);
1356
1357 now += sec_etc;
1358
1359 char *etc = ctime (&now);
1360
1361 size_t etc_len = strlen (etc);
1362
1363 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1364 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1365
1366 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1367 }
1368 }
1369 }
1370 }
1371
1372 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1373 {
1374 hc_device_param_t *device_param = &data.devices_param[device_id];
1375
1376 if (device_param->skipped) continue;
1377
1378 char display_dev_cur[16] = { 0 };
1379
1380 strncpy (display_dev_cur, "0.00", 4);
1381
1382 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1383
1384 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1385 }
1386
1387 char display_all_cur[16] = { 0 };
1388
1389 strncpy (display_all_cur, "0.00", 4);
1390
1391 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1392
1393 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1394
1395 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1396 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1397
1398 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);
1399
1400 // crack-per-time
1401
1402 if (data.digests_cnt > 100)
1403 {
1404 time_t now = time (NULL);
1405
1406 int cpt_cur_min = 0;
1407 int cpt_cur_hour = 0;
1408 int cpt_cur_day = 0;
1409
1410 for (int i = 0; i < CPT_BUF; i++)
1411 {
1412 const uint cracked = data.cpt_buf[i].cracked;
1413 const time_t timestamp = data.cpt_buf[i].timestamp;
1414
1415 if ((timestamp + 60) > now)
1416 {
1417 cpt_cur_min += cracked;
1418 }
1419
1420 if ((timestamp + 3600) > now)
1421 {
1422 cpt_cur_hour += cracked;
1423 }
1424
1425 if ((timestamp + 86400) > now)
1426 {
1427 cpt_cur_day += cracked;
1428 }
1429 }
1430
1431 double ms_real = ms_running - ms_paused;
1432
1433 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1434 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1435 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1436
1437 if ((data.cpt_start + 86400) < now)
1438 {
1439 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1440 cpt_cur_min,
1441 cpt_cur_hour,
1442 cpt_cur_day,
1443 cpt_avg_min,
1444 cpt_avg_hour,
1445 cpt_avg_day);
1446 }
1447 else if ((data.cpt_start + 3600) < now)
1448 {
1449 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1450 cpt_cur_min,
1451 cpt_cur_hour,
1452 cpt_avg_min,
1453 cpt_avg_hour,
1454 cpt_avg_day);
1455 }
1456 else if ((data.cpt_start + 60) < now)
1457 {
1458 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1459 cpt_cur_min,
1460 cpt_avg_min,
1461 cpt_avg_hour,
1462 cpt_avg_day);
1463 }
1464 else
1465 {
1466 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1467 cpt_avg_min,
1468 cpt_avg_hour,
1469 cpt_avg_day);
1470 }
1471 }
1472
1473 // Restore point
1474
1475 u64 restore_point = get_lowest_words_done ();
1476
1477 u64 restore_total = data.words_base;
1478
1479 float percent_restore = 0;
1480
1481 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1482
1483 if (progress_end_relative_skip)
1484 {
1485 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1486 {
1487 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1488 float percent_rejected = 0.0;
1489
1490 if (progress_cur)
1491 {
1492 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1493 }
1494
1495 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);
1496 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1497
1498 if (data.restore_disable == 0)
1499 {
1500 if (percent_finished != 1)
1501 {
1502 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1503 }
1504 }
1505 }
1506 }
1507 else
1508 {
1509 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1510 {
1511 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1512 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1513
1514 if (data.restore_disable == 0)
1515 {
1516 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1517 }
1518 }
1519 else
1520 {
1521 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1522 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1523
1524 // --restore not allowed if stdin is used -- really? why?
1525
1526 //if (data.restore_disable == 0)
1527 //{
1528 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1529 //}
1530 }
1531 }
1532
1533 #ifdef HAVE_HWMON
1534 if (data.gpu_temp_disable == 0)
1535 {
1536 hc_thread_mutex_lock (mux_adl);
1537
1538 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1539 {
1540 hc_device_param_t *device_param = &data.devices_param[device_id];
1541
1542 if (device_param->skipped) continue;
1543
1544 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1545 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1546 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1547 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1548 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1549 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1550 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1551
1552 char output_buf[256] = { 0 };
1553
1554 int output_len = 0;
1555
1556 if (num_temperature >= 0)
1557 {
1558 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1559
1560 output_len = strlen (output_buf);
1561 }
1562
1563 if (num_fanspeed >= 0)
1564 {
1565 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1566
1567 output_len = strlen (output_buf);
1568 }
1569
1570 if (num_utilization >= 0)
1571 {
1572 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1573
1574 output_len = strlen (output_buf);
1575 }
1576
1577 if (num_corespeed >= 0)
1578 {
1579 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1580
1581 output_len = strlen (output_buf);
1582 }
1583
1584 if (num_memoryspeed >= 0)
1585 {
1586 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1587
1588 output_len = strlen (output_buf);
1589 }
1590
1591 if (num_buslanes >= 0)
1592 {
1593 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1594
1595 output_len = strlen (output_buf);
1596 }
1597
1598 if (num_throttle == 1)
1599 {
1600 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1601
1602 output_len = strlen (output_buf);
1603 }
1604
1605 if (output_len == 0)
1606 {
1607 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1608
1609 output_len = strlen (output_buf);
1610 }
1611
1612 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1613 }
1614
1615 hc_thread_mutex_unlock (mux_adl);
1616 }
1617 #endif // HAVE_HWMON
1618 }
1619
1620 static void status_benchmark_automate ()
1621 {
1622 u64 speed_cnt[DEVICES_MAX] = { 0 };
1623 double speed_ms[DEVICES_MAX] = { 0 };
1624
1625 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1626 {
1627 hc_device_param_t *device_param = &data.devices_param[device_id];
1628
1629 if (device_param->skipped) continue;
1630
1631 speed_cnt[device_id] = device_param->speed_cnt[0];
1632 speed_ms[device_id] = device_param->speed_ms[0];
1633 }
1634
1635 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1636
1637 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1638 {
1639 hc_device_param_t *device_param = &data.devices_param[device_id];
1640
1641 if (device_param->skipped) continue;
1642
1643 hashes_dev_ms[device_id] = 0;
1644
1645 if (speed_ms[device_id])
1646 {
1647 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1648 }
1649 }
1650
1651 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1652 {
1653 hc_device_param_t *device_param = &data.devices_param[device_id];
1654
1655 if (device_param->skipped) continue;
1656
1657 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1658 }
1659 }
1660
1661 static void status_benchmark ()
1662 {
1663 if (data.devices_status == STATUS_INIT) return;
1664 if (data.devices_status == STATUS_STARTING) return;
1665 if (data.devices_status == STATUS_BYPASS) return;
1666
1667 if (data.machine_readable == 1)
1668 {
1669 status_benchmark_automate ();
1670
1671 return;
1672 }
1673
1674 u64 speed_cnt[DEVICES_MAX] = { 0 };
1675 double speed_ms[DEVICES_MAX] = { 0 };
1676
1677 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1678 {
1679 hc_device_param_t *device_param = &data.devices_param[device_id];
1680
1681 if (device_param->skipped) continue;
1682
1683 speed_cnt[device_id] = device_param->speed_cnt[0];
1684 speed_ms[device_id] = device_param->speed_ms[0];
1685 }
1686
1687 double hashes_all_ms = 0;
1688
1689 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1690
1691 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1692 {
1693 hc_device_param_t *device_param = &data.devices_param[device_id];
1694
1695 if (device_param->skipped) continue;
1696
1697 hashes_dev_ms[device_id] = 0;
1698
1699 if (speed_ms[device_id])
1700 {
1701 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1702
1703 hashes_all_ms += hashes_dev_ms[device_id];
1704 }
1705 }
1706
1707 /**
1708 * exec time
1709 */
1710
1711 double exec_all_ms[DEVICES_MAX] = { 0 };
1712
1713 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1714 {
1715 hc_device_param_t *device_param = &data.devices_param[device_id];
1716
1717 if (device_param->skipped) continue;
1718
1719 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1720
1721 exec_all_ms[device_id] = exec_ms_avg;
1722 }
1723
1724 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1725 {
1726 hc_device_param_t *device_param = &data.devices_param[device_id];
1727
1728 if (device_param->skipped) continue;
1729
1730 char display_dev_cur[16] = { 0 };
1731
1732 strncpy (display_dev_cur, "0.00", 4);
1733
1734 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1735
1736 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1737 }
1738
1739 char display_all_cur[16] = { 0 };
1740
1741 strncpy (display_all_cur, "0.00", 4);
1742
1743 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1744
1745 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1746 }
1747
1748 /**
1749 * hashcat -only- functions
1750 */
1751
1752 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1753 {
1754 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1755 {
1756 if (attack_kern == ATTACK_KERN_STRAIGHT)
1757 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1758 else if (attack_kern == ATTACK_KERN_COMBI)
1759 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1760 else if (attack_kern == ATTACK_KERN_BF)
1761 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1762 }
1763 else
1764 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1765 }
1766
1767 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)
1768 {
1769 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1770 {
1771 if (attack_kern == ATTACK_KERN_STRAIGHT)
1772 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1773 else if (attack_kern == ATTACK_KERN_COMBI)
1774 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1775 else if (attack_kern == ATTACK_KERN_BF)
1776 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1777 }
1778 else
1779 {
1780 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1781 }
1782 }
1783
1784 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1785 {
1786 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1787 {
1788 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1789 }
1790 else
1791 {
1792 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1793 }
1794 }
1795
1796 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)
1797 {
1798 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1799 {
1800 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1801 }
1802 else
1803 {
1804 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1805 }
1806 }
1807
1808 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1809 {
1810 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1811 }
1812
1813 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1814 {
1815 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1816 }
1817
1818 static uint convert_from_hex (char *line_buf, const uint line_len)
1819 {
1820 if (line_len & 1) return (line_len); // not in hex
1821
1822 if (data.hex_wordlist == 1)
1823 {
1824 uint i;
1825 uint j;
1826
1827 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1828 {
1829 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1830 }
1831
1832 memset (line_buf + i, 0, line_len - i);
1833
1834 return (i);
1835 }
1836 else if (line_len >= 6) // $HEX[] = 6
1837 {
1838 if (line_buf[0] != '$') return (line_len);
1839 if (line_buf[1] != 'H') return (line_len);
1840 if (line_buf[2] != 'E') return (line_len);
1841 if (line_buf[3] != 'X') return (line_len);
1842 if (line_buf[4] != '[') return (line_len);
1843 if (line_buf[line_len - 1] != ']') return (line_len);
1844
1845 uint i;
1846 uint j;
1847
1848 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1849 {
1850 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1851 }
1852
1853 memset (line_buf + i, 0, line_len - i);
1854
1855 return (i);
1856 }
1857
1858 return (line_len);
1859 }
1860
1861 static void clear_prompt ()
1862 {
1863 fputc ('\r', stdout);
1864
1865 for (size_t i = 0; i < strlen (PROMPT); i++)
1866 {
1867 fputc (' ', stdout);
1868 }
1869
1870 fputc ('\r', stdout);
1871
1872 fflush (stdout);
1873 }
1874
1875 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1876 {
1877 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);
1878 }
1879
1880 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1881 {
1882 char *outfile = data.outfile;
1883 uint quiet = data.quiet;
1884 FILE *pot_fp = data.pot_fp;
1885 uint loopback = data.loopback;
1886 uint debug_mode = data.debug_mode;
1887 char *debug_file = data.debug_file;
1888
1889 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1890 int debug_rule_len = 0; // -1 error
1891 uint debug_plain_len = 0;
1892
1893 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1894
1895 // hash
1896
1897 char out_buf[HCBUFSIZ] = { 0 };
1898
1899 const u32 salt_pos = plain->salt_pos;
1900 const u32 digest_pos = plain->digest_pos; // relative
1901 const u32 gidvid = plain->gidvid;
1902 const u32 il_pos = plain->il_pos;
1903
1904 ascii_digest (out_buf, salt_pos, digest_pos);
1905
1906 // plain
1907
1908 u64 crackpos = device_param->words_off;
1909
1910 uint plain_buf[16] = { 0 };
1911
1912 u8 *plain_ptr = (u8 *) plain_buf;
1913
1914 unsigned int plain_len = 0;
1915
1916 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1917 {
1918 pw_t pw;
1919
1920 gidd_to_pw_t (device_param, gidvid, &pw);
1921
1922 for (int i = 0; i < 16; i++)
1923 {
1924 plain_buf[i] = pw.i[i];
1925 }
1926
1927 plain_len = pw.pw_len;
1928
1929 const uint off = device_param->innerloop_pos + il_pos;
1930
1931 if (debug_mode > 0)
1932 {
1933 debug_rule_len = 0;
1934
1935 // save rule
1936 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1937 {
1938 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1939
1940 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1941 }
1942
1943 // save plain
1944 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1945 {
1946 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1947
1948 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1949
1950 debug_plain_len = plain_len;
1951 }
1952 }
1953
1954 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1955
1956 crackpos += gidvid;
1957 crackpos *= data.kernel_rules_cnt;
1958 crackpos += device_param->innerloop_pos + il_pos;
1959
1960 if (plain_len > data.pw_max) plain_len = data.pw_max;
1961 }
1962 else if (data.attack_mode == ATTACK_MODE_COMBI)
1963 {
1964 pw_t pw;
1965
1966 gidd_to_pw_t (device_param, gidvid, &pw);
1967
1968 for (int i = 0; i < 16; i++)
1969 {
1970 plain_buf[i] = pw.i[i];
1971 }
1972
1973 plain_len = pw.pw_len;
1974
1975 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1976 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1977
1978 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1979 {
1980 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1981 }
1982 else
1983 {
1984 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1985
1986 memcpy (plain_ptr, comb_buf, comb_len);
1987 }
1988
1989 plain_len += comb_len;
1990
1991 crackpos += gidvid;
1992 crackpos *= data.combs_cnt;
1993 crackpos += device_param->innerloop_pos + il_pos;
1994
1995 if (data.pw_max != PW_DICTMAX1)
1996 {
1997 if (plain_len > data.pw_max) plain_len = data.pw_max;
1998 }
1999 }
2000 else if (data.attack_mode == ATTACK_MODE_BF)
2001 {
2002 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2003 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2004
2005 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2006 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2007
2008 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2009 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2010
2011 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2012 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2013
2014 plain_len = data.css_cnt;
2015
2016 crackpos += gidvid;
2017 crackpos *= data.bfs_cnt;
2018 crackpos += device_param->innerloop_pos + il_pos;
2019 }
2020 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2021 {
2022 pw_t pw;
2023
2024 gidd_to_pw_t (device_param, gidvid, &pw);
2025
2026 for (int i = 0; i < 16; i++)
2027 {
2028 plain_buf[i] = pw.i[i];
2029 }
2030
2031 plain_len = pw.pw_len;
2032
2033 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2034
2035 uint start = 0;
2036 uint stop = device_param->kernel_params_mp_buf32[4];
2037
2038 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2039
2040 plain_len += start + stop;
2041
2042 crackpos += gidvid;
2043 crackpos *= data.combs_cnt;
2044 crackpos += device_param->innerloop_pos + il_pos;
2045
2046 if (data.pw_max != PW_DICTMAX1)
2047 {
2048 if (plain_len > data.pw_max) plain_len = data.pw_max;
2049 }
2050 }
2051 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2052 {
2053 pw_t pw;
2054
2055 gidd_to_pw_t (device_param, gidvid, &pw);
2056
2057 for (int i = 0; i < 16; i++)
2058 {
2059 plain_buf[i] = pw.i[i];
2060 }
2061
2062 plain_len = pw.pw_len;
2063
2064 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2065
2066 uint start = 0;
2067 uint stop = device_param->kernel_params_mp_buf32[4];
2068
2069 memmove (plain_ptr + stop, plain_ptr, plain_len);
2070
2071 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2072
2073 plain_len += start + stop;
2074
2075 crackpos += gidvid;
2076 crackpos *= data.combs_cnt;
2077 crackpos += device_param->innerloop_pos + il_pos;
2078
2079 if (data.pw_max != PW_DICTMAX1)
2080 {
2081 if (plain_len > data.pw_max) plain_len = data.pw_max;
2082 }
2083 }
2084
2085 if (data.attack_mode == ATTACK_MODE_BF)
2086 {
2087 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2088 {
2089 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2090 {
2091 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2092 {
2093 plain_len = plain_len - data.salts_buf[0].salt_len;
2094 }
2095 }
2096
2097 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2098 {
2099 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2100 {
2101 plain_ptr[j] = plain_ptr[i];
2102 }
2103
2104 plain_len = plain_len / 2;
2105 }
2106 }
2107 }
2108
2109 // if enabled, update also the potfile
2110
2111 if (pot_fp)
2112 {
2113 lock_file (pot_fp);
2114
2115 fprintf (pot_fp, "%s:", out_buf);
2116
2117 format_plain (pot_fp, plain_ptr, plain_len, 1);
2118
2119 fputc ('\n', pot_fp);
2120
2121 fflush (pot_fp);
2122
2123 unlock_file (pot_fp);
2124 }
2125
2126 // outfile
2127
2128 FILE *out_fp = NULL;
2129
2130 if (outfile != NULL)
2131 {
2132 if ((out_fp = fopen (outfile, "ab")) == NULL)
2133 {
2134 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2135
2136 out_fp = stdout;
2137 }
2138
2139 lock_file (out_fp);
2140 }
2141 else
2142 {
2143 out_fp = stdout;
2144
2145 if (quiet == 0) clear_prompt ();
2146 }
2147
2148 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2149
2150 if (outfile != NULL)
2151 {
2152 if (out_fp != stdout)
2153 {
2154 fclose (out_fp);
2155 }
2156 }
2157 else
2158 {
2159 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2160 {
2161 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2162 {
2163 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2164 if (quiet == 0) fflush (stdout);
2165 }
2166 }
2167 }
2168
2169 // loopback
2170
2171 if (loopback)
2172 {
2173 char *loopback_file = data.loopback_file;
2174
2175 FILE *fb_fp = NULL;
2176
2177 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2178 {
2179 lock_file (fb_fp);
2180
2181 format_plain (fb_fp, plain_ptr, plain_len, 1);
2182
2183 fputc ('\n', fb_fp);
2184
2185 fclose (fb_fp);
2186 }
2187 }
2188
2189 // (rule) debug mode
2190
2191 // the next check implies that:
2192 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2193 // - debug_mode > 0
2194
2195 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2196 {
2197 if (debug_rule_len < 0) debug_rule_len = 0;
2198
2199 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2200
2201 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2202
2203 if ((quiet == 0) && (debug_file == NULL))
2204 {
2205 fprintf (stdout, "%s", PROMPT);
2206
2207 fflush (stdout);
2208 }
2209 }
2210 }
2211
2212 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2213 {
2214 salt_t *salt_buf = &data.salts_buf[salt_pos];
2215
2216 u32 num_cracked;
2217
2218 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2219
2220 if (num_cracked)
2221 {
2222 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2223
2224 log_info_nn ("");
2225
2226 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2227
2228 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);
2229
2230 uint cpt_cracked = 0;
2231
2232 for (uint i = 0; i < num_cracked; i++)
2233 {
2234 const uint hash_pos = cracked[i].hash_pos;
2235
2236 if (data.digests_shown[hash_pos] == 1) continue;
2237
2238 hc_thread_mutex_lock (mux_display);
2239
2240 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2241 {
2242 data.digests_shown[hash_pos] = 1;
2243
2244 data.digests_done++;
2245
2246 cpt_cracked++;
2247
2248 salt_buf->digests_done++;
2249
2250 if (salt_buf->digests_done == salt_buf->digests_cnt)
2251 {
2252 data.salts_shown[salt_pos] = 1;
2253
2254 data.salts_done++;
2255 }
2256 }
2257
2258 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2259
2260 hc_thread_mutex_unlock (mux_display);
2261
2262 check_hash (device_param, &cracked[i]);
2263 }
2264
2265 myfree (cracked);
2266
2267 if (cpt_cracked > 0)
2268 {
2269 hc_thread_mutex_lock (mux_display);
2270
2271 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2272 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2273
2274 data.cpt_pos++;
2275
2276 data.cpt_total += cpt_cracked;
2277
2278 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2279
2280 hc_thread_mutex_unlock (mux_display);
2281 }
2282
2283 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2284 {
2285 // we need to reset cracked state on the device
2286 // otherwise host thinks again and again the hash was cracked
2287 // and returns invalid password each time
2288
2289 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2290
2291 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);
2292 }
2293
2294 num_cracked = 0;
2295
2296 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2297 }
2298 }
2299
2300 static void save_hash ()
2301 {
2302 char *hashfile = data.hashfile;
2303
2304 char new_hashfile[256] = { 0 };
2305 char old_hashfile[256] = { 0 };
2306
2307 snprintf (new_hashfile, 255, "%s.new", hashfile);
2308 snprintf (old_hashfile, 255, "%s.old", hashfile);
2309
2310 unlink (new_hashfile);
2311
2312 char separator = data.separator;
2313
2314 FILE *fp = fopen (new_hashfile, "wb");
2315
2316 if (fp == NULL)
2317 {
2318 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2319
2320 exit (-1);
2321 }
2322
2323 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2324 {
2325 if (data.salts_shown[salt_pos] == 1) continue;
2326
2327 salt_t *salt_buf = &data.salts_buf[salt_pos];
2328
2329 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2330 {
2331 uint idx = salt_buf->digests_offset + digest_pos;
2332
2333 if (data.digests_shown[idx] == 1) continue;
2334
2335 if (data.hash_mode != 2500)
2336 {
2337 char out_buf[HCBUFSIZ] = { 0 };
2338
2339 if (data.username == 1)
2340 {
2341 user_t *user = data.hash_info[idx]->user;
2342
2343 uint i;
2344
2345 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2346
2347 fputc (separator, fp);
2348 }
2349
2350 ascii_digest (out_buf, salt_pos, digest_pos);
2351
2352 fputs (out_buf, fp);
2353
2354 log_out (fp, "");
2355 }
2356 else
2357 {
2358 hccap_t hccap;
2359
2360 to_hccap_t (&hccap, salt_pos, digest_pos);
2361
2362 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2363 }
2364 }
2365 }
2366
2367 fflush (fp);
2368
2369 fclose (fp);
2370
2371 unlink (old_hashfile);
2372
2373 if (rename (hashfile, old_hashfile) != 0)
2374 {
2375 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2376
2377 exit (-1);
2378 }
2379
2380 unlink (hashfile);
2381
2382 if (rename (new_hashfile, hashfile) != 0)
2383 {
2384 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2385
2386 exit (-1);
2387 }
2388
2389 unlink (old_hashfile);
2390 }
2391
2392 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2393 {
2394 // function called only in case kernel_power_all > words_left
2395
2396 float kernel_power_div = (float) (total_left) / kernel_power_all;
2397
2398 kernel_power_div += kernel_power_div / 100;
2399
2400 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2401
2402 while (kernel_power_new < total_left)
2403 {
2404 kernel_power_div += kernel_power_div / 100;
2405
2406 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2407 }
2408
2409 if (data.quiet == 0)
2410 {
2411 clear_prompt ();
2412
2413 //log_info ("");
2414
2415 log_info ("INFO: approaching final keyspace, workload adjusted");
2416 log_info ("");
2417
2418 fprintf (stdout, "%s", PROMPT);
2419
2420 fflush (stdout);
2421 }
2422
2423 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2424
2425 return kernel_power_div;
2426 }
2427
2428 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2429 {
2430 uint num_elements = num;
2431
2432 device_param->kernel_params_buf32[30] = data.combs_mode;
2433 device_param->kernel_params_buf32[31] = num;
2434
2435 uint kernel_threads = device_param->kernel_threads;
2436
2437 while (num_elements % kernel_threads) num_elements++;
2438
2439 cl_kernel kernel = NULL;
2440
2441 switch (kern_run)
2442 {
2443 case KERN_RUN_1: kernel = device_param->kernel1; break;
2444 case KERN_RUN_12: kernel = device_param->kernel12; break;
2445 case KERN_RUN_2: kernel = device_param->kernel2; break;
2446 case KERN_RUN_23: kernel = device_param->kernel23; break;
2447 case KERN_RUN_3: kernel = device_param->kernel3; break;
2448 }
2449
2450 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2451 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2452 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2453 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2454 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2455 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2456 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2457 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2458 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2459 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2460 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2461
2462 cl_event event;
2463
2464 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2465 {
2466 const size_t global_work_size[3] = { num_elements, 32, 1 };
2467 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2468
2469 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2470 }
2471 else
2472 {
2473 if (kern_run == KERN_RUN_2)
2474 {
2475 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2476 {
2477 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2478 }
2479 }
2480
2481 while (num_elements % kernel_threads) num_elements++;
2482
2483 const size_t global_work_size[3] = { num_elements, 1, 1 };
2484 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2485
2486 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2487 }
2488
2489 hc_clFlush (data.ocl, device_param->command_queue);
2490
2491 hc_clWaitForEvents (data.ocl, 1, &event);
2492
2493 if (event_update)
2494 {
2495 cl_ulong time_start;
2496 cl_ulong time_end;
2497
2498 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2499 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2500
2501 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2502
2503 uint exec_pos = device_param->exec_pos;
2504
2505 device_param->exec_ms[exec_pos] = exec_time;
2506
2507 exec_pos++;
2508
2509 if (exec_pos == EXEC_CACHE)
2510 {
2511 exec_pos = 0;
2512 }
2513
2514 device_param->exec_pos = exec_pos;
2515 }
2516
2517 hc_clReleaseEvent (data.ocl, event);
2518
2519 hc_clFinish (data.ocl, device_param->command_queue);
2520 }
2521
2522 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2523 {
2524 uint num_elements = num;
2525
2526 switch (kern_run)
2527 {
2528 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2529 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2530 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2531 }
2532
2533 // causes problems with special threads like in bcrypt
2534 // const uint kernel_threads = device_param->kernel_threads;
2535
2536 uint kernel_threads = device_param->kernel_threads;
2537
2538 while (num_elements % kernel_threads) num_elements++;
2539
2540 cl_kernel kernel = NULL;
2541
2542 switch (kern_run)
2543 {
2544 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2545 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2546 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2547 }
2548
2549 switch (kern_run)
2550 {
2551 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2552 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2553 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2554 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2555 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2556 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2557 break;
2558 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2559 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2560 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2561 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2562 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2563 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2564 break;
2565 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2566 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2567 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2568 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2569 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2570 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2571 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2572 break;
2573 }
2574
2575 const size_t global_work_size[3] = { num_elements, 1, 1 };
2576 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2577
2578 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2579
2580 hc_clFlush (data.ocl, device_param->command_queue);
2581
2582 hc_clFinish (data.ocl, device_param->command_queue);
2583 }
2584
2585 static void run_kernel_tm (hc_device_param_t *device_param)
2586 {
2587 const uint num_elements = 1024; // fixed
2588
2589 uint kernel_threads = 32;
2590
2591 cl_kernel kernel = device_param->kernel_tm;
2592
2593 const size_t global_work_size[3] = { num_elements, 1, 1 };
2594 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2595
2596 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2597
2598 hc_clFlush (data.ocl, device_param->command_queue);
2599
2600 hc_clFinish (data.ocl, device_param->command_queue);
2601 }
2602
2603 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2604 {
2605 uint num_elements = num;
2606
2607 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2608 device_param->kernel_params_amp_buf32[6] = num_elements;
2609
2610 // causes problems with special threads like in bcrypt
2611 // const uint kernel_threads = device_param->kernel_threads;
2612
2613 uint kernel_threads = device_param->kernel_threads;
2614
2615 while (num_elements % kernel_threads) num_elements++;
2616
2617 cl_kernel kernel = device_param->kernel_amp;
2618
2619 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2620 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2621
2622 const size_t global_work_size[3] = { num_elements, 1, 1 };
2623 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2624
2625 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2626
2627 hc_clFlush (data.ocl, device_param->command_queue);
2628
2629 hc_clFinish (data.ocl, device_param->command_queue);
2630 }
2631
2632 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2633 {
2634 const u32 num16d = num / 16;
2635 const u32 num16m = num % 16;
2636
2637 if (num16d)
2638 {
2639 device_param->kernel_params_memset_buf32[1] = value;
2640 device_param->kernel_params_memset_buf32[2] = num16d;
2641
2642 uint kernel_threads = device_param->kernel_threads;
2643
2644 uint num_elements = num16d;
2645
2646 while (num_elements % kernel_threads) num_elements++;
2647
2648 cl_kernel kernel = device_param->kernel_memset;
2649
2650 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2651 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2652 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2653
2654 const size_t global_work_size[3] = { num_elements, 1, 1 };
2655 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2656
2657 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2658
2659 hc_clFlush (data.ocl, device_param->command_queue);
2660
2661 hc_clFinish (data.ocl, device_param->command_queue);
2662 }
2663
2664 if (num16m)
2665 {
2666 u32 tmp[4];
2667
2668 tmp[0] = value;
2669 tmp[1] = value;
2670 tmp[2] = value;
2671 tmp[3] = value;
2672
2673 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2674 }
2675 }
2676
2677 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2678 {
2679 run_kernel_memset (device_param, buf, 0, size);
2680
2681 /*
2682 int rc = -1;
2683
2684 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2685 {
2686 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2687
2688 const cl_uchar zero = 0;
2689
2690 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2691 }
2692
2693 if (rc != 0)
2694 {
2695 // NOTE: clEnqueueFillBuffer () always fails with -59
2696 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2697 // How's that possible, OpenCL 1.2 support is advertised??
2698 // We need to workaround...
2699
2700 #define FILLSZ 0x100000
2701
2702 char *tmp = (char *) mymalloc (FILLSZ);
2703
2704 for (size_t i = 0; i < size; i += FILLSZ)
2705 {
2706 const size_t left = size - i;
2707
2708 const size_t fillsz = MIN (FILLSZ, left);
2709
2710 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2711 }
2712
2713 myfree (tmp);
2714 }
2715 */
2716 }
2717
2718 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2719 {
2720 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2721 {
2722 if (attack_mode == ATTACK_MODE_BF)
2723 {
2724 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2725 {
2726 const uint size_tm = 32 * sizeof (bs_word_t);
2727
2728 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2729
2730 run_kernel_tm (device_param);
2731
2732 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2733 }
2734 }
2735
2736 if (highest_pw_len < 16)
2737 {
2738 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2739 }
2740 else if (highest_pw_len < 32)
2741 {
2742 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2743 }
2744 else
2745 {
2746 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2747 }
2748 }
2749 else
2750 {
2751 run_kernel_amp (device_param, pws_cnt);
2752
2753 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2754
2755 if (opts_type & OPTS_TYPE_HOOK12)
2756 {
2757 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2758 }
2759
2760 uint iter = salt_buf->salt_iter;
2761
2762 uint loop_step = device_param->kernel_loops;
2763
2764 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2765 {
2766 uint loop_left = iter - loop_pos;
2767
2768 loop_left = MIN (loop_left, loop_step);
2769
2770 device_param->kernel_params_buf32[25] = loop_pos;
2771 device_param->kernel_params_buf32[26] = loop_left;
2772
2773 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2774
2775 if (data.devices_status == STATUS_CRACKED) break;
2776 if (data.devices_status == STATUS_ABORTED) break;
2777 if (data.devices_status == STATUS_QUIT) break;
2778
2779 /**
2780 * speed
2781 */
2782
2783 const float iter_part = (float) (loop_pos + loop_left) / iter;
2784
2785 const u64 perf_sum_all = pws_cnt * iter_part;
2786
2787 double speed_ms;
2788
2789 hc_timer_get (device_param->timer_speed, speed_ms);
2790
2791 const u32 speed_pos = device_param->speed_pos;
2792
2793 device_param->speed_cnt[speed_pos] = perf_sum_all;
2794
2795 device_param->speed_ms[speed_pos] = speed_ms;
2796
2797 if (data.benchmark == 1)
2798 {
2799 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2800 }
2801 }
2802
2803 if (opts_type & OPTS_TYPE_HOOK23)
2804 {
2805 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2806
2807 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2808
2809 // do something with data
2810
2811 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2812 }
2813
2814 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2815 }
2816 }
2817
2818 static int run_rule_engine (const int rule_len, const char *rule_buf)
2819 {
2820 if (rule_len == 0)
2821 {
2822 return 0;
2823 }
2824 else if (rule_len == 1)
2825 {
2826 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2827 }
2828
2829 return 1;
2830 }
2831
2832 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2833 {
2834 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2835 {
2836 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2837 }
2838 else if (data.attack_kern == ATTACK_KERN_COMBI)
2839 {
2840 if (data.attack_mode == ATTACK_MODE_COMBI)
2841 {
2842 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2843 {
2844 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2845 {
2846 for (u32 i = 0; i < pws_cnt; i++)
2847 {
2848 const u32 pw_len = device_param->pws_buf[i].pw_len;
2849
2850 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2851
2852 ptr[pw_len] = 0x01;
2853 }
2854 }
2855 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2856 {
2857 for (u32 i = 0; i < pws_cnt; i++)
2858 {
2859 const u32 pw_len = device_param->pws_buf[i].pw_len;
2860
2861 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2862
2863 ptr[pw_len] = 0x80;
2864 }
2865 }
2866 }
2867 }
2868 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2869 {
2870 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2871 {
2872 for (u32 i = 0; i < pws_cnt; i++)
2873 {
2874 const u32 pw_len = device_param->pws_buf[i].pw_len;
2875
2876 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2877
2878 ptr[pw_len] = 0x01;
2879 }
2880 }
2881 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2882 {
2883 for (u32 i = 0; i < pws_cnt; i++)
2884 {
2885 const u32 pw_len = device_param->pws_buf[i].pw_len;
2886
2887 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2888
2889 ptr[pw_len] = 0x80;
2890 }
2891 }
2892 }
2893
2894 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2895 }
2896 else if (data.attack_kern == ATTACK_KERN_BF)
2897 {
2898 const u64 off = device_param->words_off;
2899
2900 device_param->kernel_params_mp_l_buf64[3] = off;
2901
2902 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2903 }
2904 }
2905
2906 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2907 {
2908 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2909
2910 device_param->kernel_params_buf32[25] = 0;
2911 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2912 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2913
2914 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2915 {
2916 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2917 }
2918 else
2919 {
2920 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2921 }
2922
2923 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2924
2925 return exec_ms_prev;
2926 }
2927
2928 static void autotune (hc_device_param_t *device_param)
2929 {
2930 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2931
2932 const u32 kernel_accel_min = device_param->kernel_accel_min;
2933 const u32 kernel_accel_max = device_param->kernel_accel_max;
2934
2935 const u32 kernel_loops_min = device_param->kernel_loops_min;
2936 const u32 kernel_loops_max = device_param->kernel_loops_max;
2937
2938 u32 kernel_accel = kernel_accel_min;
2939 u32 kernel_loops = kernel_loops_min;
2940
2941 // in this case the user specified a fixed -u and -n on the commandline
2942 // no way to tune anything
2943 // but we need to run a few caching rounds
2944
2945 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2946 {
2947 try_run (device_param, kernel_accel, kernel_loops);
2948 try_run (device_param, kernel_accel, kernel_loops);
2949 try_run (device_param, kernel_accel, kernel_loops);
2950 try_run (device_param, kernel_accel, kernel_loops);
2951
2952 device_param->kernel_accel = kernel_accel;
2953 device_param->kernel_loops = kernel_loops;
2954
2955 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2956
2957 device_param->kernel_power = kernel_power;
2958
2959 return;
2960 }
2961
2962 // from here it's clear we are allowed to autotune
2963 // so let's init some fake words
2964
2965 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2966
2967 if (data.attack_kern == ATTACK_KERN_BF)
2968 {
2969 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2970 }
2971 else
2972 {
2973 for (u32 i = 0; i < kernel_power_max; i++)
2974 {
2975 device_param->pws_buf[i].i[0] = i;
2976 device_param->pws_buf[i].i[1] = 0x01234567;
2977 device_param->pws_buf[i].pw_len = 7 + (i & 7);
2978 }
2979
2980 if (data.kernel_rules_cnt > 1)
2981 {
2982 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, 0, 0, kernel_loops_max * sizeof (kernel_rule_t), 0, NULL, NULL);
2983 }
2984
2985 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);
2986 }
2987
2988 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2989 {
2990 run_kernel_amp (device_param, kernel_power_max);
2991 }
2992
2993 #define VERIFIER_CNT 1
2994
2995 // first find out highest kernel-loops that stays below target_ms
2996
2997 if (kernel_loops_min < kernel_loops_max)
2998 {
2999 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3000 {
3001 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3002
3003 for (int i = 0; i < VERIFIER_CNT; i++)
3004 {
3005 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3006
3007 exec_ms = MIN (exec_ms, exec_ms_v);
3008 }
3009
3010 if (exec_ms < target_ms) break;
3011 }
3012 }
3013
3014 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3015
3016 #define STEPS_CNT 10
3017
3018 if (kernel_accel_min < kernel_accel_max)
3019 {
3020 for (int i = 0; i < STEPS_CNT; i++)
3021 {
3022 const u32 kernel_accel_try = 1 << i;
3023
3024 if (kernel_accel_try < kernel_accel_min) continue;
3025 if (kernel_accel_try > kernel_accel_max) break;
3026
3027 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3028
3029 for (int i = 0; i < VERIFIER_CNT; i++)
3030 {
3031 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3032
3033 exec_ms = MIN (exec_ms, exec_ms_v);
3034 }
3035
3036 if (exec_ms > target_ms) break;
3037
3038 kernel_accel = kernel_accel_try;
3039 }
3040 }
3041
3042 // at this point we want to know the actual runtime for the following reason:
3043 // we need a reference for the balancing loop following up, and this
3044 // the balancing loop can have an effect that the creates a new opportunity, for example:
3045 // if the target is 95 ms and the current runtime is 48ms the above loop
3046 // stopped the execution because the previous exec_ms was > 95ms
3047 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3048 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3049
3050 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3051
3052 for (int i = 0; i < VERIFIER_CNT; i++)
3053 {
3054 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3055
3056 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3057 }
3058
3059 u32 diff = kernel_loops - kernel_accel;
3060
3061 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3062 {
3063 u32 kernel_accel_orig = kernel_accel;
3064 u32 kernel_loops_orig = kernel_loops;
3065
3066 for (u32 f = 1; f < 1024; f++)
3067 {
3068 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3069 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3070
3071 if (kernel_accel_try > kernel_accel_max) break;
3072 if (kernel_loops_try < kernel_loops_min) break;
3073
3074 u32 diff_new = kernel_loops_try - kernel_accel_try;
3075
3076 if (diff_new > diff) break;
3077
3078 diff_new = diff;
3079
3080 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3081
3082 for (int i = 0; i < VERIFIER_CNT; i++)
3083 {
3084 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3085
3086 exec_ms = MIN (exec_ms, exec_ms_v);
3087 }
3088
3089 if (exec_ms < exec_ms_pre_final)
3090 {
3091 exec_ms_pre_final = exec_ms;
3092
3093 kernel_accel = kernel_accel_try;
3094 kernel_loops = kernel_loops_try;
3095 }
3096 }
3097 }
3098
3099 const double exec_left = target_ms / exec_ms_pre_final;
3100
3101 const double accel_left = kernel_accel_max / kernel_accel;
3102
3103 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3104
3105 if (exec_accel_min >= 1.0)
3106 {
3107 // this is safe to not overflow kernel_accel_max because of accel_left
3108
3109 kernel_accel = (double) kernel_accel * exec_accel_min;
3110 }
3111
3112 // reset them fake words
3113
3114 /*
3115 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3116
3117 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);
3118 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);
3119 */
3120
3121 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3122
3123 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3124 {
3125 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3126 }
3127
3128 // reset timer
3129
3130 device_param->exec_pos = 0;
3131
3132 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3133
3134 // store
3135
3136 device_param->kernel_accel = kernel_accel;
3137 device_param->kernel_loops = kernel_loops;
3138
3139 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3140
3141 device_param->kernel_power = kernel_power;
3142
3143 #ifdef DEBUG
3144
3145 if (data.quiet == 0)
3146 {
3147 clear_prompt ();
3148
3149 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3150 "Device #%u: autotuned kernel-loops to %u\n",
3151 device_param->device_id + 1, kernel_accel,
3152 device_param->device_id + 1, kernel_loops);
3153
3154 fprintf (stdout, "%s", PROMPT);
3155
3156 fflush (stdout);
3157 }
3158
3159 #endif
3160 }
3161
3162 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3163 {
3164 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3165
3166 // init speed timer
3167
3168 uint speed_pos = device_param->speed_pos;
3169
3170 #ifdef _POSIX
3171 if (device_param->timer_speed.tv_sec == 0)
3172 {
3173 hc_timer_set (&device_param->timer_speed);
3174 }
3175 #endif
3176
3177 #ifdef _WIN
3178 if (device_param->timer_speed.QuadPart == 0)
3179 {
3180 hc_timer_set (&device_param->timer_speed);
3181 }
3182 #endif
3183
3184 // find higest password length, this is for optimization stuff
3185
3186 uint highest_pw_len = 0;
3187
3188 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3189 {
3190 }
3191 else if (data.attack_kern == ATTACK_KERN_COMBI)
3192 {
3193 }
3194 else if (data.attack_kern == ATTACK_KERN_BF)
3195 {
3196 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3197 + device_param->kernel_params_mp_l_buf32[5];
3198 }
3199
3200 // iteration type
3201
3202 uint innerloop_step = 0;
3203 uint innerloop_cnt = 0;
3204
3205 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3206 else innerloop_step = 1;
3207
3208 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3209 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3210 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3211
3212 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3213
3214 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3215 {
3216 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3217
3218 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3219
3220 if (data.devices_status == STATUS_CRACKED) break;
3221 if (data.devices_status == STATUS_ABORTED) break;
3222 if (data.devices_status == STATUS_QUIT) break;
3223 if (data.devices_status == STATUS_BYPASS) break;
3224
3225 salt_t *salt_buf = &data.salts_buf[salt_pos];
3226
3227 device_param->kernel_params_buf32[24] = salt_pos;
3228 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3229 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3230
3231 FILE *combs_fp = device_param->combs_fp;
3232
3233 if (data.attack_mode == ATTACK_MODE_COMBI)
3234 {
3235 rewind (combs_fp);
3236 }
3237
3238 // innerloops
3239
3240 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3241 {
3242 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3243
3244 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3245
3246 if (data.devices_status == STATUS_CRACKED) break;
3247 if (data.devices_status == STATUS_ABORTED) break;
3248 if (data.devices_status == STATUS_QUIT) break;
3249 if (data.devices_status == STATUS_BYPASS) break;
3250
3251 uint innerloop_left = innerloop_cnt - innerloop_pos;
3252
3253 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3254
3255 device_param->innerloop_pos = innerloop_pos;
3256 device_param->innerloop_left = innerloop_left;
3257
3258 device_param->kernel_params_buf32[27] = innerloop_left;
3259
3260 // i think we can get rid of this
3261 if (innerloop_left == 0)
3262 {
3263 puts ("bug, how should this happen????\n");
3264
3265 continue;
3266 }
3267
3268 if (data.salts_shown[salt_pos] == 1)
3269 {
3270 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3271
3272 continue;
3273 }
3274
3275 // initialize amplifiers
3276
3277 if (data.attack_mode == ATTACK_MODE_COMBI)
3278 {
3279 uint i = 0;
3280
3281 while (i < innerloop_left)
3282 {
3283 if (feof (combs_fp)) break;
3284
3285 int line_len = fgetl (combs_fp, line_buf);
3286
3287 if (line_len >= PW_MAX1) continue;
3288
3289 line_len = convert_from_hex (line_buf, line_len);
3290
3291 char *line_buf_new = line_buf;
3292
3293 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3294 {
3295 char rule_buf_out[BLOCK_SIZE] = { 0 };
3296
3297 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3298
3299 if (rule_len_out < 0)
3300 {
3301 data.words_progress_rejected[salt_pos] += pws_cnt;
3302
3303 continue;
3304 }
3305
3306 line_len = rule_len_out;
3307
3308 line_buf_new = rule_buf_out;
3309 }
3310
3311 line_len = MIN (line_len, PW_DICTMAX);
3312
3313 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3314
3315 memcpy (ptr, line_buf_new, line_len);
3316
3317 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3318
3319 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3320 {
3321 uppercase (ptr, line_len);
3322 }
3323
3324 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3325 {
3326 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3327 {
3328 ptr[line_len] = 0x80;
3329 }
3330
3331 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3332 {
3333 ptr[line_len] = 0x01;
3334 }
3335 }
3336
3337 device_param->combs_buf[i].pw_len = line_len;
3338
3339 i++;
3340 }
3341
3342 for (uint j = i; j < innerloop_left; j++)
3343 {
3344 device_param->combs_buf[j].i[0] = 0;
3345 device_param->combs_buf[j].i[1] = 0;
3346 device_param->combs_buf[j].i[2] = 0;
3347 device_param->combs_buf[j].i[3] = 0;
3348 device_param->combs_buf[j].i[4] = 0;
3349 device_param->combs_buf[j].i[5] = 0;
3350 device_param->combs_buf[j].i[6] = 0;
3351 device_param->combs_buf[j].i[7] = 0;
3352
3353 device_param->combs_buf[j].pw_len = 0;
3354 }
3355
3356 innerloop_left = i;
3357 }
3358 else if (data.attack_mode == ATTACK_MODE_BF)
3359 {
3360 u64 off = innerloop_pos;
3361
3362 device_param->kernel_params_mp_r_buf64[3] = off;
3363
3364 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3365 }
3366 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3367 {
3368 u64 off = innerloop_pos;
3369
3370 device_param->kernel_params_mp_buf64[3] = off;
3371
3372 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3373 }
3374 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3375 {
3376 u64 off = innerloop_pos;
3377
3378 device_param->kernel_params_mp_buf64[3] = off;
3379
3380 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3381 }
3382
3383 // copy amplifiers
3384
3385 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3386 {
3387 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);
3388 }
3389 else if (data.attack_mode == ATTACK_MODE_COMBI)
3390 {
3391 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);
3392 }
3393 else if (data.attack_mode == ATTACK_MODE_BF)
3394 {
3395 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);
3396 }
3397 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3398 {
3399 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);
3400 }
3401 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3402 {
3403 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);
3404 }
3405
3406 if (data.benchmark == 1)
3407 {
3408 hc_timer_set (&device_param->timer_speed);
3409 }
3410
3411 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3412
3413 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3414
3415 if (data.devices_status == STATUS_CRACKED) break;
3416 if (data.devices_status == STATUS_ABORTED) break;
3417 if (data.devices_status == STATUS_QUIT) break;
3418
3419 /**
3420 * result
3421 */
3422
3423 check_cracked (device_param, salt_pos);
3424
3425 /**
3426 * progress
3427 */
3428
3429 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3430
3431 hc_thread_mutex_lock (mux_counter);
3432
3433 data.words_progress_done[salt_pos] += perf_sum_all;
3434
3435 hc_thread_mutex_unlock (mux_counter);
3436
3437 /**
3438 * speed
3439 */
3440
3441 double speed_ms;
3442
3443 hc_timer_get (device_param->timer_speed, speed_ms);
3444
3445 hc_timer_set (&device_param->timer_speed);
3446
3447 // current speed
3448
3449 //hc_thread_mutex_lock (mux_display);
3450
3451 device_param->speed_cnt[speed_pos] = perf_sum_all;
3452
3453 device_param->speed_ms[speed_pos] = speed_ms;
3454
3455 //hc_thread_mutex_unlock (mux_display);
3456
3457 speed_pos++;
3458
3459 if (speed_pos == SPEED_CACHE)
3460 {
3461 speed_pos = 0;
3462 }
3463
3464 /**
3465 * benchmark
3466 */
3467
3468 if (data.benchmark == 1) break;
3469 }
3470 }
3471
3472 device_param->speed_pos = speed_pos;
3473
3474 myfree (line_buf);
3475 }
3476
3477 static void load_segment (wl_data_t *wl_data, FILE *fd)
3478 {
3479 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3480
3481 wl_data->pos = 0;
3482
3483 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3484
3485 wl_data->buf[wl_data->cnt] = 0;
3486
3487 if (wl_data->cnt == 0) return;
3488
3489 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3490
3491 while (!feof (fd))
3492 {
3493 if (wl_data->cnt == wl_data->avail)
3494 {
3495 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3496
3497 wl_data->avail += wl_data->incr;
3498 }
3499
3500 const int c = fgetc (fd);
3501
3502 if (c == EOF) break;
3503
3504 wl_data->buf[wl_data->cnt] = (char) c;
3505
3506 wl_data->cnt++;
3507
3508 if (c == '\n') break;
3509 }
3510
3511 // ensure stream ends with a newline
3512
3513 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3514 {
3515 wl_data->cnt++;
3516
3517 wl_data->buf[wl_data->cnt - 1] = '\n';
3518 }
3519
3520 return;
3521 }
3522
3523 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3524 {
3525 char *ptr = buf;
3526
3527 for (u32 i = 0; i < sz; i++, ptr++)
3528 {
3529 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3530
3531 if (i == 7)
3532 {
3533 *off = i;
3534 *len = i;
3535
3536 return;
3537 }
3538
3539 if (*ptr != '\n') continue;
3540
3541 *off = i + 1;
3542
3543 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3544
3545 *len = i;
3546
3547 return;
3548 }
3549
3550 *off = sz;
3551 *len = sz;
3552 }
3553
3554 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3555 {
3556 char *ptr = buf;
3557
3558 for (u32 i = 0; i < sz; i++, ptr++)
3559 {
3560 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3561
3562 if (*ptr != '\n') continue;
3563
3564 *off = i + 1;
3565
3566 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3567
3568 *len = i;
3569
3570 return;
3571 }
3572
3573 *off = sz;
3574 *len = sz;
3575 }
3576
3577 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3578 {
3579 char *ptr = buf;
3580
3581 for (u32 i = 0; i < sz; i++, ptr++)
3582 {
3583 if (*ptr != '\n') continue;
3584
3585 *off = i + 1;
3586
3587 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3588
3589 *len = i;
3590
3591 return;
3592 }
3593
3594 *off = sz;
3595 *len = sz;
3596 }
3597
3598 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3599 {
3600 while (wl_data->pos < wl_data->cnt)
3601 {
3602 uint off;
3603 uint len;
3604
3605 char *ptr = wl_data->buf + wl_data->pos;
3606
3607 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3608
3609 wl_data->pos += off;
3610
3611 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3612 {
3613 char rule_buf_out[BLOCK_SIZE] = { 0 };
3614
3615 int rule_len_out = -1;
3616
3617 if (len < BLOCK_SIZE)
3618 {
3619 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3620 }
3621
3622 if (rule_len_out < 0)
3623 {
3624 continue;
3625 }
3626
3627 if (rule_len_out > PW_MAX)
3628 {
3629 continue;
3630 }
3631 }
3632 else
3633 {
3634 if (len > PW_MAX)
3635 {
3636 continue;
3637 }
3638 }
3639
3640 *out_buf = ptr;
3641 *out_len = len;
3642
3643 return;
3644 }
3645
3646 if (feof (fd))
3647 {
3648 fprintf (stderr, "BUG feof()!!\n");
3649
3650 return;
3651 }
3652
3653 load_segment (wl_data, fd);
3654
3655 get_next_word (wl_data, fd, out_buf, out_len);
3656 }
3657
3658 #ifdef _POSIX
3659 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3660 #endif
3661
3662 #ifdef _WIN
3663 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3664 #endif
3665 {
3666 hc_signal (NULL);
3667
3668 dictstat_t d;
3669
3670 d.cnt = 0;
3671
3672 #ifdef _POSIX
3673 fstat (fileno (fd), &d.stat);
3674 #endif
3675
3676 #ifdef _WIN
3677 _fstat64 (fileno (fd), &d.stat);
3678 #endif
3679
3680 d.stat.st_mode = 0;
3681 d.stat.st_nlink = 0;
3682 d.stat.st_uid = 0;
3683 d.stat.st_gid = 0;
3684 d.stat.st_rdev = 0;
3685 d.stat.st_atime = 0;
3686
3687 #ifdef _POSIX
3688 d.stat.st_blksize = 0;
3689 d.stat.st_blocks = 0;
3690 #endif
3691
3692 if (d.stat.st_size == 0) return 0;
3693
3694 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3695
3696 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3697 {
3698 if (d_cache)
3699 {
3700 u64 cnt = d_cache->cnt;
3701
3702 u64 keyspace = cnt;
3703
3704 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3705 {
3706 keyspace *= data.kernel_rules_cnt;
3707 }
3708 else if (data.attack_kern == ATTACK_KERN_COMBI)
3709 {
3710 keyspace *= data.combs_cnt;
3711 }
3712
3713 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);
3714 if (data.quiet == 0) log_info ("");
3715
3716 hc_signal (sigHandler_default);
3717
3718 return (keyspace);
3719 }
3720 }
3721
3722 time_t now = 0;
3723 time_t prev = 0;
3724
3725 u64 comp = 0;
3726 u64 cnt = 0;
3727 u64 cnt2 = 0;
3728
3729 while (!feof (fd))
3730 {
3731 load_segment (wl_data, fd);
3732
3733 comp += wl_data->cnt;
3734
3735 u32 i = 0;
3736
3737 while (i < wl_data->cnt)
3738 {
3739 u32 len;
3740 u32 off;
3741
3742 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3743
3744 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3745 {
3746 char rule_buf_out[BLOCK_SIZE] = { 0 };
3747
3748 int rule_len_out = -1;
3749
3750 if (len < BLOCK_SIZE)
3751 {
3752 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3753 }
3754
3755 if (rule_len_out < 0)
3756 {
3757 len = PW_MAX1;
3758 }
3759 else
3760 {
3761 len = rule_len_out;
3762 }
3763 }
3764
3765 if (len < PW_MAX1)
3766 {
3767 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3768 {
3769 cnt += data.kernel_rules_cnt;
3770 }
3771 else if (data.attack_kern == ATTACK_KERN_COMBI)
3772 {
3773 cnt += data.combs_cnt;
3774 }
3775
3776 d.cnt++;
3777 }
3778
3779 i += off;
3780
3781 cnt2++;
3782 }
3783
3784 time (&now);
3785
3786 if ((now - prev) == 0) continue;
3787
3788 float percent = (float) comp / (float) d.stat.st_size;
3789
3790 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);
3791
3792 time (&prev);
3793 }
3794
3795 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);
3796 if (data.quiet == 0) log_info ("");
3797
3798 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3799
3800 hc_signal (sigHandler_default);
3801
3802 return (cnt);
3803 }
3804
3805 static void *thread_monitor (void *p)
3806 {
3807 uint runtime_check = 0;
3808 uint remove_check = 0;
3809 uint status_check = 0;
3810 uint restore_check = 0;
3811
3812 uint restore_left = data.restore_timer;
3813 uint remove_left = data.remove_timer;
3814 uint status_left = data.status_timer;
3815
3816 #ifdef HAVE_HWMON
3817 uint hwmon_check = 0;
3818
3819 int slowdown_warnings = 0;
3820
3821 // these variables are mainly used for fan control
3822
3823 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3824
3825 // temperature controller "loopback" values
3826
3827 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3828 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3829
3830 int temp_threshold = 1; // degrees celcius
3831
3832 int fan_speed_min = 15; // in percentage
3833 int fan_speed_max = 100;
3834
3835 time_t last_temp_check_time;
3836 #endif // HAVE_HWMON
3837
3838 uint sleep_time = 1;
3839
3840 if (data.runtime)
3841 {
3842 runtime_check = 1;
3843 }
3844
3845 if (data.restore_timer)
3846 {
3847 restore_check = 1;
3848 }
3849
3850 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3851 {
3852 remove_check = 1;
3853 }
3854
3855 if (data.status == 1)
3856 {
3857 status_check = 1;
3858 }
3859
3860 #ifdef HAVE_HWMON
3861 if (data.gpu_temp_disable == 0)
3862 {
3863 time (&last_temp_check_time);
3864
3865 hwmon_check = 1;
3866 }
3867 #endif
3868
3869 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3870 {
3871 #ifdef HAVE_HWMON
3872 if (hwmon_check == 0)
3873 #endif
3874 return (p);
3875 }
3876
3877 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3878 {
3879 hc_sleep (sleep_time);
3880
3881 if (data.devices_status != STATUS_RUNNING) continue;
3882
3883 #ifdef HAVE_HWMON
3884
3885 if (1)
3886 {
3887 hc_thread_mutex_lock (mux_adl);
3888
3889 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3890 {
3891 hc_device_param_t *device_param = &data.devices_param[device_id];
3892
3893 if (device_param->skipped) continue;
3894
3895 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3896
3897 const int temperature = hm_get_temperature_with_device_id (device_id);
3898
3899 const int threshold = data.hm_device[device_id].gpu_temp_threshold_slowdown;
3900
3901 if (temperature >= threshold)
3902 {
3903 if (slowdown_warnings < 3)
3904 {
3905 if (data.quiet == 0) clear_prompt ();
3906
3907 log_info ("WARNING: Drivers temperature threshold (%dc) hit on GPU #%d, expect performance to drop...", threshold, device_id + 1);
3908
3909 if (slowdown_warnings == 2)
3910 {
3911 log_info ("");
3912 }
3913
3914 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
3915 if (data.quiet == 0) fflush (stdout);
3916
3917 slowdown_warnings++;
3918 }
3919 }
3920 else
3921 {
3922 slowdown_warnings = 0;
3923 }
3924 }
3925
3926 hc_thread_mutex_unlock (mux_adl);
3927 }
3928
3929 if (hwmon_check == 1)
3930 {
3931 hc_thread_mutex_lock (mux_adl);
3932
3933 time_t temp_check_time;
3934
3935 time (&temp_check_time);
3936
3937 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3938
3939 if (Ta == 0) Ta = 1;
3940
3941 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3942 {
3943 hc_device_param_t *device_param = &data.devices_param[device_id];
3944
3945 if (device_param->skipped) continue;
3946
3947 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3948
3949 const int temperature = hm_get_temperature_with_device_id (device_id);
3950
3951 if (temperature > (int) data.gpu_temp_abort)
3952 {
3953 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3954
3955 if (data.devices_status != STATUS_QUIT) myabort ();
3956
3957 break;
3958 }
3959
3960 const int gpu_temp_retain = data.gpu_temp_retain;
3961
3962 if (gpu_temp_retain)
3963 {
3964 if (data.hm_device[device_id].fan_set_supported == 1)
3965 {
3966 int temp_cur = temperature;
3967
3968 int temp_diff_new = gpu_temp_retain - temp_cur;
3969
3970 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3971
3972 // calculate Ta value (time difference in seconds between the last check and this check)
3973
3974 last_temp_check_time = temp_check_time;
3975
3976 float Kp = 1.8;
3977 float Ki = 0.005;
3978 float Kd = 6;
3979
3980 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3981
3982 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);
3983
3984 if (abs (fan_diff_required) >= temp_threshold)
3985 {
3986 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3987
3988 int fan_speed_level = fan_speed_cur;
3989
3990 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3991
3992 int fan_speed_new = fan_speed_level - fan_diff_required;
3993
3994 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3995 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3996
3997 if (fan_speed_new != fan_speed_cur)
3998 {
3999 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4000 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4001
4002 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4003 {
4004 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4005 {
4006 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new, 1);
4007 }
4008 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4009 {
4010
4011 }
4012
4013 fan_speed_chgd[device_id] = 1;
4014 }
4015
4016 temp_diff_old[device_id] = temp_diff_new;
4017 }
4018 }
4019 }
4020 }
4021 }
4022
4023 hc_thread_mutex_unlock (mux_adl);
4024 }
4025 #endif // HAVE_HWMON
4026
4027 if (restore_check == 1)
4028 {
4029 restore_left--;
4030
4031 if (restore_left == 0)
4032 {
4033 if (data.restore_disable == 0) cycle_restore ();
4034
4035 restore_left = data.restore_timer;
4036 }
4037 }
4038
4039 if ((runtime_check == 1) && (data.runtime_start > 0))
4040 {
4041 time_t runtime_cur;
4042
4043 time (&runtime_cur);
4044
4045 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4046
4047 if (runtime_left <= 0)
4048 {
4049 if (data.benchmark == 0)
4050 {
4051 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4052 }
4053
4054 if (data.devices_status != STATUS_QUIT) myabort ();
4055 }
4056 }
4057
4058 if (remove_check == 1)
4059 {
4060 remove_left--;
4061
4062 if (remove_left == 0)
4063 {
4064 if (data.digests_saved != data.digests_done)
4065 {
4066 data.digests_saved = data.digests_done;
4067
4068 save_hash ();
4069 }
4070
4071 remove_left = data.remove_timer;
4072 }
4073 }
4074
4075 if (status_check == 1)
4076 {
4077 status_left--;
4078
4079 if (status_left == 0)
4080 {
4081 //hc_thread_mutex_lock (mux_display);
4082
4083 if (data.quiet == 0) clear_prompt ();
4084
4085 if (data.quiet == 0) log_info ("");
4086
4087 status_display ();
4088
4089 if (data.quiet == 0) log_info ("");
4090
4091 //hc_thread_mutex_unlock (mux_display);
4092
4093 status_left = data.status_timer;
4094 }
4095 }
4096 }
4097
4098 #ifdef HAVE_HWMON
4099 myfree (fan_speed_chgd);
4100
4101 myfree (temp_diff_old);
4102 myfree (temp_diff_sum);
4103 #endif
4104
4105 p = NULL;
4106
4107 return (p);
4108 }
4109
4110 static void *thread_outfile_remove (void *p)
4111 {
4112 // some hash-dependent constants
4113 char *outfile_dir = data.outfile_check_directory;
4114 uint dgst_size = data.dgst_size;
4115 uint isSalted = data.isSalted;
4116 uint esalt_size = data.esalt_size;
4117 uint hash_mode = data.hash_mode;
4118
4119 uint outfile_check_timer = data.outfile_check_timer;
4120
4121 char separator = data.separator;
4122
4123 // some hash-dependent functions
4124 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4125 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4126
4127 // buffers
4128 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4129
4130 hash_buf.digest = mymalloc (dgst_size);
4131
4132 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4133
4134 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4135
4136 uint digest_buf[64] = { 0 };
4137
4138 outfile_data_t *out_info = NULL;
4139
4140 char **out_files = NULL;
4141
4142 time_t folder_mtime = 0;
4143
4144 int out_cnt = 0;
4145
4146 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4147
4148 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4149 {
4150 hc_sleep (1);
4151
4152 if (data.devices_status != STATUS_RUNNING) continue;
4153
4154 check_left--;
4155
4156 if (check_left == 0)
4157 {
4158 struct stat outfile_check_stat;
4159
4160 if (stat (outfile_dir, &outfile_check_stat) == 0)
4161 {
4162 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4163
4164 if (is_dir == 1)
4165 {
4166 if (outfile_check_stat.st_mtime > folder_mtime)
4167 {
4168 char **out_files_new = scan_directory (outfile_dir);
4169
4170 int out_cnt_new = count_dictionaries (out_files_new);
4171
4172 outfile_data_t *out_info_new = NULL;
4173
4174 if (out_cnt_new > 0)
4175 {
4176 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4177
4178 for (int i = 0; i < out_cnt_new; i++)
4179 {
4180 out_info_new[i].file_name = out_files_new[i];
4181
4182 // check if there are files that we have seen/checked before (and not changed)
4183
4184 for (int j = 0; j < out_cnt; j++)
4185 {
4186 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4187 {
4188 struct stat outfile_stat;
4189
4190 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4191 {
4192 if (outfile_stat.st_ctime == out_info[j].ctime)
4193 {
4194 out_info_new[i].ctime = out_info[j].ctime;
4195 out_info_new[i].seek = out_info[j].seek;
4196 }
4197 }
4198 }
4199 }
4200 }
4201 }
4202
4203 local_free (out_info);
4204 local_free (out_files);
4205
4206 out_files = out_files_new;
4207 out_cnt = out_cnt_new;
4208 out_info = out_info_new;
4209
4210 folder_mtime = outfile_check_stat.st_mtime;
4211 }
4212
4213 for (int j = 0; j < out_cnt; j++)
4214 {
4215 FILE *fp = fopen (out_info[j].file_name, "rb");
4216
4217 if (fp != NULL)
4218 {
4219 //hc_thread_mutex_lock (mux_display);
4220
4221 #ifdef _POSIX
4222 struct stat outfile_stat;
4223
4224 fstat (fileno (fp), &outfile_stat);
4225 #endif
4226
4227 #ifdef _WIN
4228 struct stat64 outfile_stat;
4229
4230 _fstat64 (fileno (fp), &outfile_stat);
4231 #endif
4232
4233 if (outfile_stat.st_ctime > out_info[j].ctime)
4234 {
4235 out_info[j].ctime = outfile_stat.st_ctime;
4236 out_info[j].seek = 0;
4237 }
4238
4239 fseek (fp, out_info[j].seek, SEEK_SET);
4240
4241 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4242
4243 while (!feof (fp))
4244 {
4245 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4246
4247 if (ptr == NULL) break;
4248
4249 int line_len = strlen (line_buf);
4250
4251 if (line_len <= 0) continue;
4252
4253 int iter = MAX_CUT_TRIES;
4254
4255 for (uint i = line_len - 1; i && iter; i--, line_len--)
4256 {
4257 if (line_buf[i] != separator) continue;
4258
4259 int parser_status = PARSER_OK;
4260
4261 if ((hash_mode != 2500) && (hash_mode != 6800))
4262 {
4263 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4264 }
4265
4266 uint found = 0;
4267
4268 if (parser_status == PARSER_OK)
4269 {
4270 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4271 {
4272 if (data.salts_shown[salt_pos] == 1) continue;
4273
4274 salt_t *salt_buf = &data.salts_buf[salt_pos];
4275
4276 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4277 {
4278 uint idx = salt_buf->digests_offset + digest_pos;
4279
4280 if (data.digests_shown[idx] == 1) continue;
4281
4282 uint cracked = 0;
4283
4284 if (hash_mode == 6800)
4285 {
4286 if (i == salt_buf->salt_len)
4287 {
4288 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4289 }
4290 }
4291 else if (hash_mode == 2500)
4292 {
4293 // BSSID : MAC1 : MAC2 (:plain)
4294 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4295 {
4296 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4297
4298 if (!cracked) continue;
4299
4300 // now compare MAC1 and MAC2 too, since we have this additional info
4301 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4302 char *mac2_pos = mac1_pos + 12 + 1;
4303
4304 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4305 wpa_t *wpa = &wpas[salt_pos];
4306
4307 // compare hex string(s) vs binary MAC address(es)
4308
4309 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4310 {
4311 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4312 {
4313 cracked = 0;
4314
4315 break;
4316 }
4317 }
4318
4319 // early skip ;)
4320 if (!cracked) continue;
4321
4322 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4323 {
4324 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4325 {
4326 cracked = 0;
4327
4328 break;
4329 }
4330 }
4331 }
4332 }
4333 else
4334 {
4335 char *digests_buf_ptr = (char *) data.digests_buf;
4336
4337 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4338
4339 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4340 }
4341
4342 if (cracked == 1)
4343 {
4344 found = 1;
4345
4346 data.digests_shown[idx] = 1;
4347
4348 data.digests_done++;
4349
4350 salt_buf->digests_done++;
4351
4352 if (salt_buf->digests_done == salt_buf->digests_cnt)
4353 {
4354 data.salts_shown[salt_pos] = 1;
4355
4356 data.salts_done++;
4357
4358 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4359 }
4360 }
4361 }
4362
4363 if (data.devices_status == STATUS_CRACKED) break;
4364 }
4365 }
4366
4367 if (found) break;
4368
4369 if (data.devices_status == STATUS_CRACKED) break;
4370
4371 iter--;
4372 }
4373
4374 if (data.devices_status == STATUS_CRACKED) break;
4375 }
4376
4377 myfree (line_buf);
4378
4379 out_info[j].seek = ftell (fp);
4380
4381 //hc_thread_mutex_unlock (mux_display);
4382
4383 fclose (fp);
4384 }
4385 }
4386 }
4387 }
4388
4389 check_left = outfile_check_timer;
4390 }
4391 }
4392
4393 if (esalt_size) local_free (hash_buf.esalt);
4394
4395 if (isSalted) local_free (hash_buf.salt);
4396
4397 local_free (hash_buf.digest);
4398
4399 local_free (out_info);
4400
4401 local_free (out_files);
4402
4403 p = NULL;
4404
4405 return (p);
4406 }
4407
4408 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4409 {
4410 if (device_param->pws_cnt < device_param->kernel_power)
4411 {
4412 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4413
4414 u8 *ptr = (u8 *) pw->i;
4415
4416 memcpy (ptr, pw_buf, pw_len);
4417
4418 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4419
4420 pw->pw_len = pw_len;
4421
4422 device_param->pws_cnt++;
4423 }
4424 else
4425 {
4426 fprintf (stderr, "BUG pw_add()!!\n");
4427
4428 return;
4429 }
4430 }
4431
4432 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4433 {
4434 hc_thread_mutex_lock (mux_dispatcher);
4435
4436 const u64 words_cur = data.words_cur;
4437 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4438
4439 device_param->words_off = words_cur;
4440
4441 const u64 words_left = words_base - words_cur;
4442
4443 if (allow_div)
4444 {
4445 if (data.kernel_power_all > words_left)
4446 {
4447 if (data.kernel_power_div == 0)
4448 {
4449 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4450 }
4451 }
4452
4453 if (data.kernel_power_div)
4454 {
4455 if (device_param->kernel_power == device_param->kernel_power_user)
4456 {
4457 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4458
4459 if (kernel_power_new < device_param->kernel_power)
4460 {
4461 device_param->kernel_power = kernel_power_new;
4462 }
4463 }
4464 }
4465 }
4466
4467 const uint kernel_power = device_param->kernel_power;
4468
4469 uint work = MIN (words_left, kernel_power);
4470
4471 work = MIN (work, max);
4472
4473 data.words_cur += work;
4474
4475 hc_thread_mutex_unlock (mux_dispatcher);
4476
4477 return work;
4478 }
4479
4480 static void *thread_calc_stdin (void *p)
4481 {
4482 hc_device_param_t *device_param = (hc_device_param_t *) p;
4483
4484 if (device_param->skipped) return NULL;
4485
4486 autotune (device_param);
4487
4488 char *buf = (char *) mymalloc (HCBUFSIZ);
4489
4490 const uint attack_kern = data.attack_kern;
4491
4492 const uint kernel_power = device_param->kernel_power;
4493
4494 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4495 {
4496 hc_thread_mutex_lock (mux_dispatcher);
4497
4498 if (feof (stdin) != 0)
4499 {
4500 hc_thread_mutex_unlock (mux_dispatcher);
4501
4502 break;
4503 }
4504
4505 uint words_cur = 0;
4506
4507 while (words_cur < kernel_power)
4508 {
4509 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4510
4511 if (line_buf == NULL) break;
4512
4513 uint line_len = in_superchop (line_buf);
4514
4515 line_len = convert_from_hex (line_buf, line_len);
4516
4517 // post-process rule engine
4518
4519 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4520 {
4521 char rule_buf_out[BLOCK_SIZE] = { 0 };
4522
4523 int rule_len_out = -1;
4524
4525 if (line_len < BLOCK_SIZE)
4526 {
4527 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4528 }
4529
4530 if (rule_len_out < 0) continue;
4531
4532 line_buf = rule_buf_out;
4533 line_len = rule_len_out;
4534 }
4535
4536 if (line_len > PW_MAX)
4537 {
4538 continue;
4539 }
4540
4541 if (attack_kern == ATTACK_KERN_STRAIGHT)
4542 {
4543 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4544 {
4545 hc_thread_mutex_lock (mux_counter);
4546
4547 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4548 {
4549 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4550 }
4551
4552 hc_thread_mutex_unlock (mux_counter);
4553
4554 continue;
4555 }
4556 }
4557 else if (attack_kern == ATTACK_KERN_COMBI)
4558 {
4559 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4560 // since we still need to combine the plains
4561
4562 if (line_len > data.pw_max)
4563 {
4564 hc_thread_mutex_lock (mux_counter);
4565
4566 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4567 {
4568 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4569 }
4570
4571 hc_thread_mutex_unlock (mux_counter);
4572
4573 continue;
4574 }
4575 }
4576
4577 pw_add (device_param, (u8 *) line_buf, line_len);
4578
4579 words_cur++;
4580
4581 if (data.devices_status == STATUS_CRACKED) break;
4582 if (data.devices_status == STATUS_ABORTED) break;
4583 if (data.devices_status == STATUS_QUIT) break;
4584 if (data.devices_status == STATUS_BYPASS) break;
4585 }
4586
4587 hc_thread_mutex_unlock (mux_dispatcher);
4588
4589 if (data.devices_status == STATUS_CRACKED) break;
4590 if (data.devices_status == STATUS_ABORTED) break;
4591 if (data.devices_status == STATUS_QUIT) break;
4592 if (data.devices_status == STATUS_BYPASS) break;
4593
4594 // flush
4595
4596 const uint pws_cnt = device_param->pws_cnt;
4597
4598 if (pws_cnt)
4599 {
4600 run_copy (device_param, pws_cnt);
4601
4602 run_cracker (device_param, pws_cnt);
4603
4604 device_param->pws_cnt = 0;
4605
4606 /*
4607 still required?
4608 if (attack_kern == ATTACK_KERN_STRAIGHT)
4609 {
4610 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4611 }
4612 else if (attack_kern == ATTACK_KERN_COMBI)
4613 {
4614 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4615 }
4616 */
4617 }
4618 }
4619
4620 device_param->kernel_accel = 0;
4621 device_param->kernel_loops = 0;
4622
4623 myfree (buf);
4624
4625 return NULL;
4626 }
4627
4628 static void *thread_calc (void *p)
4629 {
4630 hc_device_param_t *device_param = (hc_device_param_t *) p;
4631
4632 if (device_param->skipped) return NULL;
4633
4634 autotune (device_param);
4635
4636 const uint attack_mode = data.attack_mode;
4637 const uint attack_kern = data.attack_kern;
4638
4639 if (attack_mode == ATTACK_MODE_BF)
4640 {
4641 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4642 {
4643 const uint work = get_work (device_param, -1, true);
4644
4645 if (work == 0) break;
4646
4647 const u64 words_off = device_param->words_off;
4648 const u64 words_fin = words_off + work;
4649
4650 const uint pws_cnt = work;
4651
4652 device_param->pws_cnt = pws_cnt;
4653
4654 if (pws_cnt)
4655 {
4656 run_copy (device_param, pws_cnt);
4657
4658 run_cracker (device_param, pws_cnt);
4659
4660 device_param->pws_cnt = 0;
4661
4662 /*
4663 still required?
4664 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4665 */
4666 }
4667
4668 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4669
4670 if (data.devices_status == STATUS_CRACKED) break;
4671 if (data.devices_status == STATUS_ABORTED) break;
4672 if (data.devices_status == STATUS_QUIT) break;
4673 if (data.devices_status == STATUS_BYPASS) break;
4674
4675 if (data.benchmark == 1) break;
4676
4677 device_param->words_done = words_fin;
4678 }
4679 }
4680 else
4681 {
4682 const uint segment_size = data.segment_size;
4683
4684 char *dictfile = data.dictfile;
4685
4686 if (attack_mode == ATTACK_MODE_COMBI)
4687 {
4688 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4689 {
4690 dictfile = data.dictfile2;
4691 }
4692 }
4693
4694 FILE *fd = fopen (dictfile, "rb");
4695
4696 if (fd == NULL)
4697 {
4698 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4699
4700 return NULL;
4701 }
4702
4703 if (attack_mode == ATTACK_MODE_COMBI)
4704 {
4705 const uint combs_mode = data.combs_mode;
4706
4707 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4708 {
4709 const char *dictfilec = data.dictfile2;
4710
4711 FILE *combs_fp = fopen (dictfilec, "rb");
4712
4713 if (combs_fp == NULL)
4714 {
4715 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4716
4717 fclose (fd);
4718
4719 return NULL;
4720 }
4721
4722 device_param->combs_fp = combs_fp;
4723 }
4724 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4725 {
4726 const char *dictfilec = data.dictfile;
4727
4728 FILE *combs_fp = fopen (dictfilec, "rb");
4729
4730 if (combs_fp == NULL)
4731 {
4732 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4733
4734 fclose (fd);
4735
4736 return NULL;
4737 }
4738
4739 device_param->combs_fp = combs_fp;
4740 }
4741 }
4742
4743 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4744
4745 wl_data->buf = (char *) mymalloc (segment_size);
4746 wl_data->avail = segment_size;
4747 wl_data->incr = segment_size;
4748 wl_data->cnt = 0;
4749 wl_data->pos = 0;
4750
4751 u64 words_cur = 0;
4752
4753 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4754 {
4755 u64 words_off = 0;
4756 u64 words_fin = 0;
4757
4758 bool allow_div = true;
4759
4760 u64 max = -1;
4761
4762 while (max)
4763 {
4764 const uint work = get_work (device_param, max, allow_div);
4765
4766 allow_div = false;
4767
4768 if (work == 0) break;
4769
4770 words_off = device_param->words_off;
4771 words_fin = words_off + work;
4772
4773 char *line_buf;
4774 uint line_len;
4775
4776 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4777
4778 max = 0;
4779
4780 for ( ; words_cur < words_fin; words_cur++)
4781 {
4782 get_next_word (wl_data, fd, &line_buf, &line_len);
4783
4784 line_len = convert_from_hex (line_buf, line_len);
4785
4786 // post-process rule engine
4787
4788 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4789 {
4790 char rule_buf_out[BLOCK_SIZE] = { 0 };
4791
4792 int rule_len_out = -1;
4793
4794 if (line_len < BLOCK_SIZE)
4795 {
4796 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4797 }
4798
4799 if (rule_len_out < 0) continue;
4800
4801 line_buf = rule_buf_out;
4802 line_len = rule_len_out;
4803 }
4804
4805 if (attack_kern == ATTACK_KERN_STRAIGHT)
4806 {
4807 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4808 {
4809 max++;
4810
4811 hc_thread_mutex_lock (mux_counter);
4812
4813 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4814 {
4815 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4816 }
4817
4818 hc_thread_mutex_unlock (mux_counter);
4819
4820 continue;
4821 }
4822 }
4823 else if (attack_kern == ATTACK_KERN_COMBI)
4824 {
4825 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4826 // since we still need to combine the plains
4827
4828 if (line_len > data.pw_max)
4829 {
4830 max++;
4831
4832 hc_thread_mutex_lock (mux_counter);
4833
4834 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4835 {
4836 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4837 }
4838
4839 hc_thread_mutex_unlock (mux_counter);
4840
4841 continue;
4842 }
4843 }
4844
4845 pw_add (device_param, (u8 *) line_buf, line_len);
4846
4847 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4848
4849 if (data.devices_status == STATUS_CRACKED) break;
4850 if (data.devices_status == STATUS_ABORTED) break;
4851 if (data.devices_status == STATUS_QUIT) break;
4852 if (data.devices_status == STATUS_BYPASS) break;
4853 }
4854
4855 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4856
4857 if (data.devices_status == STATUS_CRACKED) break;
4858 if (data.devices_status == STATUS_ABORTED) break;
4859 if (data.devices_status == STATUS_QUIT) break;
4860 if (data.devices_status == STATUS_BYPASS) break;
4861 }
4862
4863 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4864
4865 if (data.devices_status == STATUS_CRACKED) break;
4866 if (data.devices_status == STATUS_ABORTED) break;
4867 if (data.devices_status == STATUS_QUIT) break;
4868 if (data.devices_status == STATUS_BYPASS) break;
4869
4870 //
4871 // flush
4872 //
4873
4874 const uint pws_cnt = device_param->pws_cnt;
4875
4876 if (pws_cnt)
4877 {
4878 run_copy (device_param, pws_cnt);
4879
4880 run_cracker (device_param, pws_cnt);
4881
4882 device_param->pws_cnt = 0;
4883
4884 /*
4885 still required?
4886 if (attack_kern == ATTACK_KERN_STRAIGHT)
4887 {
4888 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4889 }
4890 else if (attack_kern == ATTACK_KERN_COMBI)
4891 {
4892 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4893 }
4894 */
4895 }
4896
4897 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4898
4899 if (data.devices_status == STATUS_CRACKED) break;
4900 if (data.devices_status == STATUS_ABORTED) break;
4901 if (data.devices_status == STATUS_QUIT) break;
4902 if (data.devices_status == STATUS_BYPASS) break;
4903
4904 if (words_fin == 0) break;
4905
4906 device_param->words_done = words_fin;
4907 }
4908
4909 if (attack_mode == ATTACK_MODE_COMBI)
4910 {
4911 fclose (device_param->combs_fp);
4912 }
4913
4914 free (wl_data->buf);
4915 free (wl_data);
4916
4917 fclose (fd);
4918 }
4919
4920 device_param->kernel_accel = 0;
4921 device_param->kernel_loops = 0;
4922
4923 return NULL;
4924 }
4925
4926 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4927 {
4928 if (!device_param)
4929 {
4930 log_error ("ERROR: %s : Invalid argument", __func__);
4931
4932 exit (-1);
4933 }
4934
4935 salt_t *salt_buf = &data.salts_buf[salt_pos];
4936
4937 device_param->kernel_params_buf32[24] = salt_pos;
4938 device_param->kernel_params_buf32[27] = 1;
4939 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4940 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4941 device_param->kernel_params_buf32[30] = 0;
4942 device_param->kernel_params_buf32[31] = 1;
4943
4944 char *dictfile_old = data.dictfile;
4945
4946 const char *weak_hash_check = "weak-hash-check";
4947
4948 data.dictfile = (char *) weak_hash_check;
4949
4950 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4951
4952 data.kernel_rules_buf[0].cmds[0] = 0;
4953
4954 /**
4955 * run the kernel
4956 */
4957
4958 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4959 {
4960 run_kernel (KERN_RUN_1, device_param, 1, false);
4961 }
4962 else
4963 {
4964 run_kernel (KERN_RUN_1, device_param, 1, false);
4965
4966 uint loop_step = 16;
4967
4968 const uint iter = salt_buf->salt_iter;
4969
4970 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4971 {
4972 uint loop_left = iter - loop_pos;
4973
4974 loop_left = MIN (loop_left, loop_step);
4975
4976 device_param->kernel_params_buf32[25] = loop_pos;
4977 device_param->kernel_params_buf32[26] = loop_left;
4978
4979 run_kernel (KERN_RUN_2, device_param, 1, false);
4980 }
4981
4982 run_kernel (KERN_RUN_3, device_param, 1, false);
4983 }
4984
4985 /**
4986 * result
4987 */
4988
4989 check_cracked (device_param, salt_pos);
4990
4991 /**
4992 * cleanup
4993 */
4994
4995 device_param->kernel_params_buf32[24] = 0;
4996 device_param->kernel_params_buf32[25] = 0;
4997 device_param->kernel_params_buf32[26] = 0;
4998 device_param->kernel_params_buf32[27] = 0;
4999 device_param->kernel_params_buf32[28] = 0;
5000 device_param->kernel_params_buf32[29] = 0;
5001 device_param->kernel_params_buf32[30] = 0;
5002 device_param->kernel_params_buf32[31] = 0;
5003
5004 data.dictfile = dictfile_old;
5005
5006 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5007 }
5008
5009 // hlfmt hashcat
5010
5011 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5012 {
5013 if (data.username == 0)
5014 {
5015 *hashbuf_pos = line_buf;
5016 *hashbuf_len = line_len;
5017 }
5018 else
5019 {
5020 char *pos = line_buf;
5021 int len = line_len;
5022
5023 for (int i = 0; i < line_len; i++, pos++, len--)
5024 {
5025 if (line_buf[i] == data.separator)
5026 {
5027 pos++;
5028
5029 len--;
5030
5031 break;
5032 }
5033 }
5034
5035 *hashbuf_pos = pos;
5036 *hashbuf_len = len;
5037 }
5038 }
5039
5040 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5041 {
5042 char *pos = NULL;
5043 int len = 0;
5044
5045 int sep_cnt = 0;
5046
5047 for (int i = 0; i < line_len; i++)
5048 {
5049 if (line_buf[i] == data.separator)
5050 {
5051 sep_cnt++;
5052
5053 continue;
5054 }
5055
5056 if (sep_cnt == 0)
5057 {
5058 if (pos == NULL) pos = line_buf + i;
5059
5060 len++;
5061 }
5062 }
5063
5064 *userbuf_pos = pos;
5065 *userbuf_len = len;
5066 }
5067
5068 // hlfmt pwdump
5069
5070 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5071 {
5072 int sep_cnt = 0;
5073
5074 int sep2_len = 0;
5075 int sep3_len = 0;
5076
5077 for (int i = 0; i < line_len; i++)
5078 {
5079 if (line_buf[i] == ':')
5080 {
5081 sep_cnt++;
5082
5083 continue;
5084 }
5085
5086 if (sep_cnt == 2) sep2_len++;
5087 if (sep_cnt == 3) sep3_len++;
5088 }
5089
5090 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5091
5092 return 0;
5093 }
5094
5095 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5096 {
5097 char *pos = NULL;
5098 int len = 0;
5099
5100 int sep_cnt = 0;
5101
5102 for (int i = 0; i < line_len; i++)
5103 {
5104 if (line_buf[i] == ':')
5105 {
5106 sep_cnt++;
5107
5108 continue;
5109 }
5110
5111 if (data.hash_mode == 1000)
5112 {
5113 if (sep_cnt == 3)
5114 {
5115 if (pos == NULL) pos = line_buf + i;
5116
5117 len++;
5118 }
5119 }
5120 else if (data.hash_mode == 3000)
5121 {
5122 if (sep_cnt == 2)
5123 {
5124 if (pos == NULL) pos = line_buf + i;
5125
5126 len++;
5127 }
5128 }
5129 }
5130
5131 *hashbuf_pos = pos;
5132 *hashbuf_len = len;
5133 }
5134
5135 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5136 {
5137 char *pos = NULL;
5138 int len = 0;
5139
5140 int sep_cnt = 0;
5141
5142 for (int i = 0; i < line_len; i++)
5143 {
5144 if (line_buf[i] == ':')
5145 {
5146 sep_cnt++;
5147
5148 continue;
5149 }
5150
5151 if (sep_cnt == 0)
5152 {
5153 if (pos == NULL) pos = line_buf + i;
5154
5155 len++;
5156 }
5157 }
5158
5159 *userbuf_pos = pos;
5160 *userbuf_len = len;
5161 }
5162
5163 // hlfmt passwd
5164
5165 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5166 {
5167 int sep_cnt = 0;
5168
5169 char sep5_first = 0;
5170 char sep6_first = 0;
5171
5172 for (int i = 0; i < line_len; i++)
5173 {
5174 if (line_buf[i] == ':')
5175 {
5176 sep_cnt++;
5177
5178 continue;
5179 }
5180
5181 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5182 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5183 }
5184
5185 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5186
5187 return 0;
5188 }
5189
5190 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5191 {
5192 char *pos = NULL;
5193 int len = 0;
5194
5195 int sep_cnt = 0;
5196
5197 for (int i = 0; i < line_len; i++)
5198 {
5199 if (line_buf[i] == ':')
5200 {
5201 sep_cnt++;
5202
5203 continue;
5204 }
5205
5206 if (sep_cnt == 1)
5207 {
5208 if (pos == NULL) pos = line_buf + i;
5209
5210 len++;
5211 }
5212 }
5213
5214 *hashbuf_pos = pos;
5215 *hashbuf_len = len;
5216 }
5217
5218 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5219 {
5220 char *pos = NULL;
5221 int len = 0;
5222
5223 int sep_cnt = 0;
5224
5225 for (int i = 0; i < line_len; i++)
5226 {
5227 if (line_buf[i] == ':')
5228 {
5229 sep_cnt++;
5230
5231 continue;
5232 }
5233
5234 if (sep_cnt == 0)
5235 {
5236 if (pos == NULL) pos = line_buf + i;
5237
5238 len++;
5239 }
5240 }
5241
5242 *userbuf_pos = pos;
5243 *userbuf_len = len;
5244 }
5245
5246 // hlfmt shadow
5247
5248 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5249 {
5250 int sep_cnt = 0;
5251
5252 for (int i = 0; i < line_len; i++)
5253 {
5254 if (line_buf[i] == ':') sep_cnt++;
5255 }
5256
5257 if (sep_cnt == 8) return 1;
5258
5259 return 0;
5260 }
5261
5262 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5263 {
5264 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5265 }
5266
5267 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5268 {
5269 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5270 }
5271
5272 // hlfmt main
5273
5274 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5275 {
5276 switch (hashfile_format)
5277 {
5278 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5279 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5280 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5281 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5282 }
5283 }
5284
5285 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5286 {
5287 switch (hashfile_format)
5288 {
5289 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5290 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5291 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5292 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5293 }
5294 }
5295
5296 char *strhlfmt (const uint hashfile_format)
5297 {
5298 switch (hashfile_format)
5299 {
5300 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5301 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5302 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5303 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5304 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5305 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5306 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5307 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5308 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5309 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5310 }
5311
5312 return ((char *) "Unknown");
5313 }
5314
5315 static uint hlfmt_detect (FILE *fp, uint max_check)
5316 {
5317 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5318
5319 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5320 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5321
5322 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5323
5324 uint num_check = 0;
5325
5326 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5327
5328 while (!feof (fp))
5329 {
5330 int line_len = fgetl (fp, line_buf);
5331
5332 if (line_len == 0) continue;
5333
5334 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5335 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5336 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5337
5338 if (num_check == max_check) break;
5339
5340 num_check++;
5341 }
5342
5343 myfree (line_buf);
5344
5345 uint hashlist_format = HLFMT_HASHCAT;
5346
5347 for (int i = 1; i < HLFMTS_CNT; i++)
5348 {
5349 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5350
5351 hashlist_format = i;
5352 }
5353
5354 free (formats_cnt);
5355
5356 return hashlist_format;
5357 }
5358
5359 /**
5360 * some further helper function
5361 */
5362
5363 // wrapper around mymalloc for ADL
5364
5365 #if defined(HAVE_HWMON)
5366 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5367 {
5368 return mymalloc (iSize);
5369 }
5370 #endif
5371
5372 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)
5373 {
5374 u64 collisions = 0;
5375
5376 const uint dgst_pos0 = data.dgst_pos0;
5377 const uint dgst_pos1 = data.dgst_pos1;
5378 const uint dgst_pos2 = data.dgst_pos2;
5379 const uint dgst_pos3 = data.dgst_pos3;
5380
5381 memset (bitmap_a, 0, bitmap_size);
5382 memset (bitmap_b, 0, bitmap_size);
5383 memset (bitmap_c, 0, bitmap_size);
5384 memset (bitmap_d, 0, bitmap_size);
5385
5386 for (uint i = 0; i < digests_cnt; i++)
5387 {
5388 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5389
5390 uint *digest_ptr = (uint *) digests_buf_ptr;
5391
5392 digests_buf_ptr += dgst_size;
5393
5394 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5395 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5396 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5397 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5398
5399 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5400 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5401 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5402 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5403
5404 if (bitmap_a[idx0] & val0) collisions++;
5405 if (bitmap_b[idx1] & val1) collisions++;
5406 if (bitmap_c[idx2] & val2) collisions++;
5407 if (bitmap_d[idx3] & val3) collisions++;
5408
5409 bitmap_a[idx0] |= val0;
5410 bitmap_b[idx1] |= val1;
5411 bitmap_c[idx2] |= val2;
5412 bitmap_d[idx3] |= val3;
5413
5414 if (collisions >= collisions_max) return 0x7fffffff;
5415 }
5416
5417 return collisions;
5418 }
5419
5420 /**
5421 * main
5422 */
5423
5424 #ifdef _WIN
5425 void SetConsoleWindowSize (const int x)
5426 {
5427 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5428
5429 if (h == INVALID_HANDLE_VALUE) return;
5430
5431 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5432
5433 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5434
5435 SMALL_RECT *sr = &bufferInfo.srWindow;
5436
5437 sr->Right = MAX (sr->Right, x - 1);
5438
5439 COORD co;
5440
5441 co.X = sr->Right + 1;
5442 co.Y = sr->Bottom + 1;
5443
5444 if (!SetConsoleScreenBufferSize (h, co)) return;
5445
5446 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5447 }
5448 #endif
5449
5450 int main (int argc, char **argv)
5451 {
5452 #ifdef _WIN
5453 SetConsoleWindowSize (132);
5454 #endif
5455
5456 /**
5457 * To help users a bit
5458 */
5459
5460 char *compute = getenv ("COMPUTE");
5461
5462 if (compute)
5463 {
5464 static char display[100];
5465
5466 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5467
5468 putenv (display);
5469 }
5470 else
5471 {
5472 if (getenv ("DISPLAY") == NULL)
5473 putenv ((char *) "DISPLAY=:0");
5474 }
5475
5476 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5477 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5478
5479 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5480 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5481
5482 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5483 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5484
5485 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5486 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5487
5488 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5489 putenv ((char *) "POCL_KERNEL_CACHE=0");
5490
5491 umask (077);
5492
5493 /**
5494 * Real init
5495 */
5496
5497 memset (&data, 0, sizeof (hc_global_data_t));
5498
5499 time_t proc_start;
5500
5501 time (&proc_start);
5502
5503 data.proc_start = proc_start;
5504
5505 int myargc = argc;
5506 char **myargv = argv;
5507
5508 hc_thread_mutex_init (mux_dispatcher);
5509 hc_thread_mutex_init (mux_counter);
5510 hc_thread_mutex_init (mux_display);
5511 hc_thread_mutex_init (mux_adl);
5512
5513 /**
5514 * commandline parameters
5515 */
5516
5517 uint usage = USAGE;
5518 uint version = VERSION;
5519 uint quiet = QUIET;
5520 uint benchmark = BENCHMARK;
5521 uint show = SHOW;
5522 uint left = LEFT;
5523 uint username = USERNAME;
5524 uint remove = REMOVE;
5525 uint remove_timer = REMOVE_TIMER;
5526 u64 skip = SKIP;
5527 u64 limit = LIMIT;
5528 uint keyspace = KEYSPACE;
5529 uint potfile_disable = POTFILE_DISABLE;
5530 char *potfile_path = NULL;
5531 uint debug_mode = DEBUG_MODE;
5532 char *debug_file = NULL;
5533 char *induction_dir = NULL;
5534 char *outfile_check_dir = NULL;
5535 uint force = FORCE;
5536 uint runtime = RUNTIME;
5537 uint hash_mode = HASH_MODE;
5538 uint attack_mode = ATTACK_MODE;
5539 uint markov_disable = MARKOV_DISABLE;
5540 uint markov_classic = MARKOV_CLASSIC;
5541 uint markov_threshold = MARKOV_THRESHOLD;
5542 char *markov_hcstat = NULL;
5543 char *outfile = NULL;
5544 uint outfile_format = OUTFILE_FORMAT;
5545 uint outfile_autohex = OUTFILE_AUTOHEX;
5546 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5547 uint restore = RESTORE;
5548 uint restore_timer = RESTORE_TIMER;
5549 uint restore_disable = RESTORE_DISABLE;
5550 uint status = STATUS;
5551 uint status_timer = STATUS_TIMER;
5552 uint machine_readable = MACHINE_READABLE;
5553 uint loopback = LOOPBACK;
5554 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5555 char *session = NULL;
5556 uint hex_charset = HEX_CHARSET;
5557 uint hex_salt = HEX_SALT;
5558 uint hex_wordlist = HEX_WORDLIST;
5559 uint rp_gen = RP_GEN;
5560 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5561 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5562 uint rp_gen_seed = RP_GEN_SEED;
5563 char *rule_buf_l = (char *) RULE_BUF_L;
5564 char *rule_buf_r = (char *) RULE_BUF_R;
5565 uint increment = INCREMENT;
5566 uint increment_min = INCREMENT_MIN;
5567 uint increment_max = INCREMENT_MAX;
5568 char *cpu_affinity = NULL;
5569 OCL_PTR *ocl = NULL;
5570 char *opencl_devices = NULL;
5571 char *opencl_platforms = NULL;
5572 char *opencl_device_types = NULL;
5573 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5574 char *truecrypt_keyfiles = NULL;
5575 char *veracrypt_keyfiles = NULL;
5576 uint veracrypt_pim = 0;
5577 uint workload_profile = WORKLOAD_PROFILE;
5578 uint kernel_accel = KERNEL_ACCEL;
5579 uint kernel_loops = KERNEL_LOOPS;
5580 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5581 #ifdef HAVE_HWMON
5582 uint gpu_temp_abort = GPU_TEMP_ABORT;
5583 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5584 uint powertune_enable = POWERTUNE_ENABLE;
5585 #endif
5586 uint logfile_disable = LOGFILE_DISABLE;
5587 uint segment_size = SEGMENT_SIZE;
5588 uint scrypt_tmto = SCRYPT_TMTO;
5589 char separator = SEPARATOR;
5590 uint bitmap_min = BITMAP_MIN;
5591 uint bitmap_max = BITMAP_MAX;
5592 char *custom_charset_1 = NULL;
5593 char *custom_charset_2 = NULL;
5594 char *custom_charset_3 = NULL;
5595 char *custom_charset_4 = NULL;
5596
5597 #define IDX_HELP 'h'
5598 #define IDX_VERSION 'V'
5599 #define IDX_VERSION_LOWER 'v'
5600 #define IDX_QUIET 0xff02
5601 #define IDX_SHOW 0xff03
5602 #define IDX_LEFT 0xff04
5603 #define IDX_REMOVE 0xff05
5604 #define IDX_REMOVE_TIMER 0xff37
5605 #define IDX_SKIP 's'
5606 #define IDX_LIMIT 'l'
5607 #define IDX_KEYSPACE 0xff35
5608 #define IDX_POTFILE_DISABLE 0xff06
5609 #define IDX_POTFILE_PATH 0xffe0
5610 #define IDX_DEBUG_MODE 0xff43
5611 #define IDX_DEBUG_FILE 0xff44
5612 #define IDX_INDUCTION_DIR 0xff46
5613 #define IDX_OUTFILE_CHECK_DIR 0xff47
5614 #define IDX_USERNAME 0xff07
5615 #define IDX_FORCE 0xff08
5616 #define IDX_RUNTIME 0xff09
5617 #define IDX_BENCHMARK 'b'
5618 #define IDX_HASH_MODE 'm'
5619 #define IDX_ATTACK_MODE 'a'
5620 #define IDX_RP_FILE 'r'
5621 #define IDX_RP_GEN 'g'
5622 #define IDX_RP_GEN_FUNC_MIN 0xff10
5623 #define IDX_RP_GEN_FUNC_MAX 0xff11
5624 #define IDX_RP_GEN_SEED 0xff34
5625 #define IDX_RULE_BUF_L 'j'
5626 #define IDX_RULE_BUF_R 'k'
5627 #define IDX_INCREMENT 'i'
5628 #define IDX_INCREMENT_MIN 0xff12
5629 #define IDX_INCREMENT_MAX 0xff13
5630 #define IDX_OUTFILE 'o'
5631 #define IDX_OUTFILE_FORMAT 0xff14
5632 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5633 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5634 #define IDX_RESTORE 0xff15
5635 #define IDX_RESTORE_DISABLE 0xff27
5636 #define IDX_STATUS 0xff17
5637 #define IDX_STATUS_TIMER 0xff18
5638 #define IDX_MACHINE_READABLE 0xff50
5639 #define IDX_LOOPBACK 0xff38
5640 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5641 #define IDX_SESSION 0xff19
5642 #define IDX_HEX_CHARSET 0xff20
5643 #define IDX_HEX_SALT 0xff21
5644 #define IDX_HEX_WORDLIST 0xff40
5645 #define IDX_MARKOV_DISABLE 0xff22
5646 #define IDX_MARKOV_CLASSIC 0xff23
5647 #define IDX_MARKOV_THRESHOLD 't'
5648 #define IDX_MARKOV_HCSTAT 0xff24
5649 #define IDX_CPU_AFFINITY 0xff25
5650 #define IDX_OPENCL_DEVICES 'd'
5651 #define IDX_OPENCL_PLATFORMS 0xff72
5652 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5653 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5654 #define IDX_WORKLOAD_PROFILE 'w'
5655 #define IDX_KERNEL_ACCEL 'n'
5656 #define IDX_KERNEL_LOOPS 'u'
5657 #define IDX_GPU_TEMP_DISABLE 0xff29
5658 #define IDX_GPU_TEMP_ABORT 0xff30
5659 #define IDX_GPU_TEMP_RETAIN 0xff31
5660 #define IDX_POWERTUNE_ENABLE 0xff41
5661 #define IDX_LOGFILE_DISABLE 0xff51
5662 #define IDX_TRUECRYPT_KEYFILES 0xff52
5663 #define IDX_VERACRYPT_KEYFILES 0xff53
5664 #define IDX_VERACRYPT_PIM 0xff54
5665 #define IDX_SCRYPT_TMTO 0xff61
5666 #define IDX_SEGMENT_SIZE 'c'
5667 #define IDX_SEPARATOR 'p'
5668 #define IDX_BITMAP_MIN 0xff70
5669 #define IDX_BITMAP_MAX 0xff71
5670 #define IDX_CUSTOM_CHARSET_1 '1'
5671 #define IDX_CUSTOM_CHARSET_2 '2'
5672 #define IDX_CUSTOM_CHARSET_3 '3'
5673 #define IDX_CUSTOM_CHARSET_4 '4'
5674
5675 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5676
5677 struct option long_options[] =
5678 {
5679 {"help", no_argument, 0, IDX_HELP},
5680 {"version", no_argument, 0, IDX_VERSION},
5681 {"quiet", no_argument, 0, IDX_QUIET},
5682 {"show", no_argument, 0, IDX_SHOW},
5683 {"left", no_argument, 0, IDX_LEFT},
5684 {"username", no_argument, 0, IDX_USERNAME},
5685 {"remove", no_argument, 0, IDX_REMOVE},
5686 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5687 {"skip", required_argument, 0, IDX_SKIP},
5688 {"limit", required_argument, 0, IDX_LIMIT},
5689 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5690 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5691 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5692 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5693 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5694 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5695 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5696 {"force", no_argument, 0, IDX_FORCE},
5697 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5698 {"restore", no_argument, 0, IDX_RESTORE},
5699 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5700 {"status", no_argument, 0, IDX_STATUS},
5701 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5702 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5703 {"loopback", no_argument, 0, IDX_LOOPBACK},
5704 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5705 {"session", required_argument, 0, IDX_SESSION},
5706 {"runtime", required_argument, 0, IDX_RUNTIME},
5707 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5708 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5709 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5710 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5711 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5712 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5713 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5714 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5715 {"rules-file", required_argument, 0, IDX_RP_FILE},
5716 {"outfile", required_argument, 0, IDX_OUTFILE},
5717 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5718 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5719 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5720 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5721 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5722 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5723 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5724 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5725 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5726 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5727 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5728 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5729 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5730 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5731 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5732 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5733 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5734 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5735 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5736 #ifdef HAVE_HWMON
5737 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5738 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5739 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5740 #endif // HAVE_HWMON
5741 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5742 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5743 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5744 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5745 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5746 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5747 {"seperator", required_argument, 0, IDX_SEPARATOR},
5748 {"separator", required_argument, 0, IDX_SEPARATOR},
5749 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5750 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5751 {"increment", no_argument, 0, IDX_INCREMENT},
5752 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5753 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5754 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5755 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5756 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5757 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5758 {0, 0, 0, 0}
5759 };
5760
5761 uint rp_files_cnt = 0;
5762
5763 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5764
5765 int option_index = 0;
5766 int c = -1;
5767
5768 optind = 1;
5769 optopt = 0;
5770
5771 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5772 {
5773 switch (c)
5774 {
5775 case IDX_HELP: usage = 1; break;
5776 case IDX_VERSION:
5777 case IDX_VERSION_LOWER: version = 1; break;
5778 case IDX_RESTORE: restore = 1; break;
5779 case IDX_SESSION: session = optarg; break;
5780 case IDX_SHOW: show = 1; break;
5781 case IDX_LEFT: left = 1; break;
5782 case '?': return (-1);
5783 }
5784 }
5785
5786 if (optopt != 0)
5787 {
5788 log_error ("ERROR: Invalid argument specified");
5789
5790 return (-1);
5791 }
5792
5793 /**
5794 * exit functions
5795 */
5796
5797 if (version)
5798 {
5799 log_info ("%s", VERSION_TAG);
5800
5801 return (0);
5802 }
5803
5804 if (usage)
5805 {
5806 usage_big_print (PROGNAME);
5807
5808 return (0);
5809 }
5810
5811 /**
5812 * session needs to be set, always!
5813 */
5814
5815 if (session == NULL) session = (char *) PROGNAME;
5816
5817 /**
5818 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5819 */
5820
5821 char *exec_path = get_exec_path ();
5822
5823 #ifdef LINUX
5824
5825 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5826 char *resolved_exec_path = realpath (exec_path, NULL);
5827
5828 char *install_dir = get_install_dir (resolved_exec_path);
5829 char *profile_dir = NULL;
5830 char *session_dir = NULL;
5831 char *shared_dir = NULL;
5832
5833 if (strcmp (install_dir, resolved_install_folder) == 0)
5834 {
5835 struct passwd *pw = getpwuid (getuid ());
5836
5837 const char *homedir = pw->pw_dir;
5838
5839 profile_dir = get_profile_dir (homedir);
5840 session_dir = get_session_dir (profile_dir);
5841 shared_dir = strdup (SHARED_FOLDER);
5842
5843 mkdir (profile_dir, 0700);
5844 mkdir (session_dir, 0700);
5845 }
5846 else
5847 {
5848 profile_dir = install_dir;
5849 session_dir = install_dir;
5850 shared_dir = install_dir;
5851 }
5852
5853 myfree (resolved_install_folder);
5854 myfree (resolved_exec_path);
5855
5856 #else
5857
5858 char *install_dir = get_install_dir (exec_path);
5859 char *profile_dir = install_dir;
5860 char *session_dir = install_dir;
5861 char *shared_dir = install_dir;
5862
5863 #endif
5864
5865 data.install_dir = install_dir;
5866 data.profile_dir = profile_dir;
5867 data.session_dir = session_dir;
5868 data.shared_dir = shared_dir;
5869
5870 myfree (exec_path);
5871
5872 /**
5873 * kernel cache, we need to make sure folder exist
5874 */
5875
5876 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5877
5878 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5879
5880 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5881
5882 mkdir (kernels_folder, 0700);
5883
5884 myfree (kernels_folder);
5885
5886 /**
5887 * session
5888 */
5889
5890 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5891
5892 data.session = session;
5893
5894 char *eff_restore_file = (char *) mymalloc (session_size);
5895 char *new_restore_file = (char *) mymalloc (session_size);
5896
5897 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5898 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5899
5900 data.eff_restore_file = eff_restore_file;
5901 data.new_restore_file = new_restore_file;
5902
5903 if (((show == 1) || (left == 1)) && (restore == 1))
5904 {
5905 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5906 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5907
5908 return (-1);
5909 }
5910
5911 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5912 if ((show == 1) || (left == 1))
5913 {
5914 restore_disable = 1;
5915
5916 restore = 0;
5917 }
5918
5919 data.restore_disable = restore_disable;
5920
5921 restore_data_t *rd = init_restore (argc, argv);
5922
5923 data.rd = rd;
5924
5925 /**
5926 * restore file
5927 */
5928
5929 if (restore == 1)
5930 {
5931 read_restore (eff_restore_file, rd);
5932
5933 if (rd->version_bin < RESTORE_MIN)
5934 {
5935 log_error ("ERROR: Incompatible restore-file version");
5936
5937 return (-1);
5938 }
5939
5940 myargc = rd->argc;
5941 myargv = rd->argv;
5942
5943 #ifdef _POSIX
5944 rd->pid = getpid ();
5945 #elif _WIN
5946 rd->pid = GetCurrentProcessId ();
5947 #endif
5948 }
5949
5950 uint hash_mode_chgd = 0;
5951 uint runtime_chgd = 0;
5952 uint kernel_loops_chgd = 0;
5953 uint kernel_accel_chgd = 0;
5954 uint attack_mode_chgd = 0;
5955 uint outfile_format_chgd = 0;
5956 uint rp_gen_seed_chgd = 0;
5957 uint remove_timer_chgd = 0;
5958 uint increment_min_chgd = 0;
5959 uint increment_max_chgd = 0;
5960 uint workload_profile_chgd = 0;
5961 uint opencl_vector_width_chgd = 0;
5962
5963 optind = 1;
5964 optopt = 0;
5965 option_index = 0;
5966
5967 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5968 {
5969 switch (c)
5970 {
5971 //case IDX_HELP: usage = 1; break;
5972 //case IDX_VERSION: version = 1; break;
5973 //case IDX_RESTORE: restore = 1; break;
5974 case IDX_QUIET: quiet = 1; break;
5975 //case IDX_SHOW: show = 1; break;
5976 case IDX_SHOW: break;
5977 //case IDX_LEFT: left = 1; break;
5978 case IDX_LEFT: break;
5979 case IDX_USERNAME: username = 1; break;
5980 case IDX_REMOVE: remove = 1; break;
5981 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5982 remove_timer_chgd = 1; break;
5983 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5984 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5985 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5986 case IDX_DEBUG_FILE: debug_file = optarg; break;
5987 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5988 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5989 case IDX_FORCE: force = 1; break;
5990 case IDX_SKIP: skip = atoll (optarg); break;
5991 case IDX_LIMIT: limit = atoll (optarg); break;
5992 case IDX_KEYSPACE: keyspace = 1; break;
5993 case IDX_BENCHMARK: benchmark = 1; break;
5994 case IDX_RESTORE: break;
5995 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5996 case IDX_STATUS: status = 1; break;
5997 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5998 case IDX_MACHINE_READABLE: machine_readable = 1; break;
5999 case IDX_LOOPBACK: loopback = 1; break;
6000 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6001 //case IDX_SESSION: session = optarg; break;
6002 case IDX_SESSION: break;
6003 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6004 hash_mode_chgd = 1; break;
6005 case IDX_RUNTIME: runtime = atoi (optarg);
6006 runtime_chgd = 1; break;
6007 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6008 attack_mode_chgd = 1; break;
6009 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6010 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6011 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6012 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6013 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6014 rp_gen_seed_chgd = 1; break;
6015 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6016 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6017 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6018 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6019 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6020 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6021 case IDX_OUTFILE: outfile = optarg; break;
6022 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6023 outfile_format_chgd = 1; break;
6024 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6025 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6026 case IDX_HEX_CHARSET: hex_charset = 1; break;
6027 case IDX_HEX_SALT: hex_salt = 1; break;
6028 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6029 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6030 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6031 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6032 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6033 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6034 opencl_vector_width_chgd = 1; break;
6035 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6036 workload_profile_chgd = 1; break;
6037 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6038 kernel_accel_chgd = 1; break;
6039 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6040 kernel_loops_chgd = 1; break;
6041 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6042 #ifdef HAVE_HWMON
6043 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6044 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6045 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6046 #endif // HAVE_HWMON
6047 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6048 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6049 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6050 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6051 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6052 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6053 case IDX_SEPARATOR: separator = optarg[0]; break;
6054 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6055 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6056 case IDX_INCREMENT: increment = 1; break;
6057 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6058 increment_min_chgd = 1; break;
6059 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6060 increment_max_chgd = 1; break;
6061 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6062 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6063 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6064 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6065
6066 default:
6067 log_error ("ERROR: Invalid argument specified");
6068 return (-1);
6069 }
6070 }
6071
6072 if (optopt != 0)
6073 {
6074 log_error ("ERROR: Invalid argument specified");
6075
6076 return (-1);
6077 }
6078
6079 /**
6080 * Inform user things getting started,
6081 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6082 * - we do not need to check algorithm_pos
6083 */
6084
6085 if (quiet == 0)
6086 {
6087 if (benchmark == 1)
6088 {
6089 if (machine_readable == 0)
6090 {
6091 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6092 log_info ("");
6093 }
6094 else
6095 {
6096 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6097 }
6098 }
6099 else if (restore == 1)
6100 {
6101 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6102 log_info ("");
6103 }
6104 else
6105 {
6106 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6107 log_info ("");
6108 }
6109 }
6110
6111 /**
6112 * sanity check
6113 */
6114
6115 if (attack_mode > 7)
6116 {
6117 log_error ("ERROR: Invalid attack-mode specified");
6118
6119 return (-1);
6120 }
6121
6122 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6123 {
6124 log_error ("ERROR: Invalid runtime specified");
6125
6126 return (-1);
6127 }
6128
6129 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
6130 {
6131 log_error ("ERROR: Invalid hash-type specified");
6132
6133 return (-1);
6134 }
6135
6136 // renamed hash modes
6137
6138 if (hash_mode_chgd)
6139 {
6140 int n = -1;
6141
6142 switch (hash_mode)
6143 {
6144 case 123: n = 124;
6145 break;
6146 }
6147
6148 if (n >= 0)
6149 {
6150 log_error ("Old -m specified, use -m %d instead", n);
6151
6152 return (-1);
6153 }
6154 }
6155
6156 if (username == 1)
6157 {
6158 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6159 {
6160 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6161
6162 return (-1);
6163 }
6164 }
6165
6166 if (outfile_format > 16)
6167 {
6168 log_error ("ERROR: Invalid outfile-format specified");
6169
6170 return (-1);
6171 }
6172
6173 if (left == 1)
6174 {
6175 if (outfile_format_chgd == 1)
6176 {
6177 if (outfile_format > 1)
6178 {
6179 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6180
6181 return (-1);
6182 }
6183 }
6184 else
6185 {
6186 outfile_format = OUTFILE_FMT_HASH;
6187 }
6188 }
6189
6190 if (show == 1)
6191 {
6192 if (outfile_format_chgd == 1)
6193 {
6194 if ((outfile_format > 7) && (outfile_format < 16))
6195 {
6196 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6197
6198 return (-1);
6199 }
6200 }
6201 }
6202
6203 if (increment_min < INCREMENT_MIN)
6204 {
6205 log_error ("ERROR: Invalid increment-min specified");
6206
6207 return (-1);
6208 }
6209
6210 if (increment_max > INCREMENT_MAX)
6211 {
6212 log_error ("ERROR: Invalid increment-max specified");
6213
6214 return (-1);
6215 }
6216
6217 if (increment_min > increment_max)
6218 {
6219 log_error ("ERROR: Invalid increment-min specified");
6220
6221 return (-1);
6222 }
6223
6224 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6225 {
6226 log_error ("ERROR: increment is not allowed in attack-mode 0");
6227
6228 return (-1);
6229 }
6230
6231 if ((increment == 0) && (increment_min_chgd == 1))
6232 {
6233 log_error ("ERROR: increment-min is only supported together with increment switch");
6234
6235 return (-1);
6236 }
6237
6238 if ((increment == 0) && (increment_max_chgd == 1))
6239 {
6240 log_error ("ERROR: increment-max is only supported together with increment switch");
6241
6242 return (-1);
6243 }
6244
6245 if (rp_files_cnt && rp_gen)
6246 {
6247 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6248
6249 return (-1);
6250 }
6251
6252 if (rp_files_cnt || rp_gen)
6253 {
6254 if (attack_mode != ATTACK_MODE_STRAIGHT)
6255 {
6256 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6257
6258 return (-1);
6259 }
6260 }
6261
6262 if (rp_gen_func_min > rp_gen_func_max)
6263 {
6264 log_error ("ERROR: Invalid rp-gen-func-min specified");
6265
6266 return (-1);
6267 }
6268
6269 if (kernel_accel_chgd == 1)
6270 {
6271 if (force == 0)
6272 {
6273 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6274 log_info ("Please consider using the option -w instead");
6275 log_info ("You can use --force to override this but do not post error reports if you do so");
6276 log_info ("");
6277
6278 return (-1);
6279 }
6280
6281 if (kernel_accel < 1)
6282 {
6283 log_error ("ERROR: Invalid kernel-accel specified");
6284
6285 return (-1);
6286 }
6287
6288 if (kernel_accel > 1024)
6289 {
6290 log_error ("ERROR: Invalid kernel-accel specified");
6291
6292 return (-1);
6293 }
6294 }
6295
6296 if (kernel_loops_chgd == 1)
6297 {
6298 if (force == 0)
6299 {
6300 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6301 log_info ("Please consider using the option -w instead");
6302 log_info ("You can use --force to override this but do not post error reports if you do so");
6303 log_info ("");
6304
6305 return (-1);
6306 }
6307
6308 if (kernel_loops < 1)
6309 {
6310 log_error ("ERROR: Invalid kernel-loops specified");
6311
6312 return (-1);
6313 }
6314
6315 if (kernel_loops > 1024)
6316 {
6317 log_error ("ERROR: Invalid kernel-loops specified");
6318
6319 return (-1);
6320 }
6321 }
6322
6323 if ((workload_profile < 1) || (workload_profile > 4))
6324 {
6325 log_error ("ERROR: workload-profile %i not available", workload_profile);
6326
6327 return (-1);
6328 }
6329
6330 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6331 {
6332 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6333
6334 return (-1);
6335 }
6336
6337 if (show == 1 || left == 1)
6338 {
6339 attack_mode = ATTACK_MODE_NONE;
6340
6341 if (remove == 1)
6342 {
6343 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6344
6345 return (-1);
6346 }
6347
6348 if (potfile_disable == 1)
6349 {
6350 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6351
6352 return (-1);
6353 }
6354 }
6355
6356 uint attack_kern = ATTACK_KERN_NONE;
6357
6358 switch (attack_mode)
6359 {
6360 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6361 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6362 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6363 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6364 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6365 }
6366
6367 if (benchmark == 0)
6368 {
6369 if (keyspace == 1)
6370 {
6371 int num_additional_params = 1;
6372
6373 if (attack_kern == ATTACK_KERN_COMBI)
6374 {
6375 num_additional_params = 2;
6376 }
6377
6378 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6379
6380 if (keyspace_wordlist_specified == 0) optind--;
6381 }
6382
6383 if (attack_kern == ATTACK_KERN_NONE)
6384 {
6385 if ((optind + 1) != myargc)
6386 {
6387 usage_mini_print (myargv[0]);
6388
6389 return (-1);
6390 }
6391 }
6392 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6393 {
6394 if ((optind + 1) > myargc)
6395 {
6396 usage_mini_print (myargv[0]);
6397
6398 return (-1);
6399 }
6400 }
6401 else if (attack_kern == ATTACK_KERN_COMBI)
6402 {
6403 if ((optind + 3) != myargc)
6404 {
6405 usage_mini_print (myargv[0]);
6406
6407 return (-1);
6408 }
6409 }
6410 else if (attack_kern == ATTACK_KERN_BF)
6411 {
6412 if ((optind + 1) > myargc)
6413 {
6414 usage_mini_print (myargv[0]);
6415
6416 return (-1);
6417 }
6418 }
6419 else
6420 {
6421 usage_mini_print (myargv[0]);
6422
6423 return (-1);
6424 }
6425 }
6426 else
6427 {
6428 if (myargv[optind] != 0)
6429 {
6430 log_error ("ERROR: Invalid argument for benchmark mode specified");
6431
6432 return (-1);
6433 }
6434
6435 if (attack_mode_chgd == 1)
6436 {
6437 if (attack_mode != ATTACK_MODE_BF)
6438 {
6439 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6440
6441 return (-1);
6442 }
6443 }
6444 }
6445
6446 if (skip != 0 && limit != 0)
6447 {
6448 limit += skip;
6449 }
6450
6451 if (keyspace == 1)
6452 {
6453 if (show == 1)
6454 {
6455 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6456
6457 return (-1);
6458 }
6459 else if (left == 1)
6460 {
6461 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6462
6463 return (-1);
6464 }
6465
6466 potfile_disable = 1;
6467
6468 restore_disable = 1;
6469
6470 restore = 0;
6471
6472 weak_hash_threshold = 0;
6473
6474 quiet = 1;
6475 }
6476
6477 if (remove_timer_chgd == 1)
6478 {
6479 if (remove == 0)
6480 {
6481 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6482
6483 return (-1);
6484 }
6485
6486 if (remove_timer < 1)
6487 {
6488 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6489
6490 return (-1);
6491 }
6492 }
6493
6494 if (loopback == 1)
6495 {
6496 if (attack_mode == ATTACK_MODE_STRAIGHT)
6497 {
6498 if ((rp_files_cnt == 0) && (rp_gen == 0))
6499 {
6500 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6501
6502 return (-1);
6503 }
6504 }
6505 else
6506 {
6507 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6508
6509 return (-1);
6510 }
6511 }
6512
6513 if (debug_mode > 0)
6514 {
6515 if (attack_mode != ATTACK_MODE_STRAIGHT)
6516 {
6517 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6518
6519 return (-1);
6520 }
6521
6522 if ((rp_files_cnt == 0) && (rp_gen == 0))
6523 {
6524 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6525
6526 return (-1);
6527 }
6528 }
6529
6530 if (debug_mode > 4)
6531 {
6532 log_error ("ERROR: Invalid debug-mode specified");
6533
6534 return (-1);
6535 }
6536
6537 if (debug_file != NULL)
6538 {
6539 if (debug_mode < 1)
6540 {
6541 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6542
6543 return (-1);
6544 }
6545 }
6546
6547 if (induction_dir != NULL)
6548 {
6549 if (attack_mode == ATTACK_MODE_BF)
6550 {
6551 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6552
6553 return (-1);
6554 }
6555 }
6556
6557 if (attack_mode != ATTACK_MODE_STRAIGHT)
6558 {
6559 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6560 {
6561 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6562
6563 return (-1);
6564 }
6565
6566 weak_hash_threshold = 0;
6567 }
6568
6569 /**
6570 * induction directory
6571 */
6572
6573 char *induction_directory = NULL;
6574
6575 if (attack_mode != ATTACK_MODE_BF)
6576 {
6577 if (induction_dir == NULL)
6578 {
6579 induction_directory = (char *) mymalloc (session_size);
6580
6581 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6582
6583 // create induction folder if it does not already exist
6584
6585 if (keyspace == 0)
6586 {
6587 if (rmdir (induction_directory) == -1)
6588 {
6589 if (errno == ENOENT)
6590 {
6591 // good, we can ignore
6592 }
6593 else if (errno == ENOTEMPTY)
6594 {
6595 char *induction_directory_mv = (char *) mymalloc (session_size);
6596
6597 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6598
6599 if (rename (induction_directory, induction_directory_mv) != 0)
6600 {
6601 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6602
6603 return (-1);
6604 }
6605 }
6606 else
6607 {
6608 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6609
6610 return (-1);
6611 }
6612 }
6613
6614 if (mkdir (induction_directory, 0700) == -1)
6615 {
6616 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6617
6618 return (-1);
6619 }
6620 }
6621 }
6622 else
6623 {
6624 induction_directory = induction_dir;
6625 }
6626 }
6627
6628 data.induction_directory = induction_directory;
6629
6630 /**
6631 * loopback
6632 */
6633
6634 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6635
6636 char *loopback_file = (char *) mymalloc (loopback_size);
6637
6638 /**
6639 * tuning db
6640 */
6641
6642 char tuning_db_file[256] = { 0 };
6643
6644 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6645
6646 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6647
6648 /**
6649 * outfile-check directory
6650 */
6651
6652 char *outfile_check_directory = NULL;
6653
6654 if (outfile_check_dir == NULL)
6655 {
6656 outfile_check_directory = (char *) mymalloc (session_size);
6657
6658 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6659 }
6660 else
6661 {
6662 outfile_check_directory = outfile_check_dir;
6663 }
6664
6665 data.outfile_check_directory = outfile_check_directory;
6666
6667 if (keyspace == 0)
6668 {
6669 struct stat outfile_check_stat;
6670
6671 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6672 {
6673 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6674
6675 if (is_dir == 0)
6676 {
6677 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6678
6679 return (-1);
6680 }
6681 }
6682 else if (outfile_check_dir == NULL)
6683 {
6684 if (mkdir (outfile_check_directory, 0700) == -1)
6685 {
6686 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6687
6688 return (-1);
6689 }
6690 }
6691 }
6692
6693 /**
6694 * special other stuff
6695 */
6696
6697 if (hash_mode == 9710)
6698 {
6699 outfile_format = 5;
6700 outfile_format_chgd = 1;
6701 }
6702
6703 if (hash_mode == 9810)
6704 {
6705 outfile_format = 5;
6706 outfile_format_chgd = 1;
6707 }
6708
6709 if (hash_mode == 10410)
6710 {
6711 outfile_format = 5;
6712 outfile_format_chgd = 1;
6713 }
6714
6715 /**
6716 * store stuff
6717 */
6718
6719 data.hash_mode = hash_mode;
6720 data.restore = restore;
6721 data.restore_timer = restore_timer;
6722 data.restore_disable = restore_disable;
6723 data.status = status;
6724 data.status_timer = status_timer;
6725 data.machine_readable = machine_readable;
6726 data.loopback = loopback;
6727 data.runtime = runtime;
6728 data.remove = remove;
6729 data.remove_timer = remove_timer;
6730 data.debug_mode = debug_mode;
6731 data.debug_file = debug_file;
6732 data.username = username;
6733 data.quiet = quiet;
6734 data.outfile = outfile;
6735 data.outfile_format = outfile_format;
6736 data.outfile_autohex = outfile_autohex;
6737 data.hex_charset = hex_charset;
6738 data.hex_salt = hex_salt;
6739 data.hex_wordlist = hex_wordlist;
6740 data.separator = separator;
6741 data.rp_files = rp_files;
6742 data.rp_files_cnt = rp_files_cnt;
6743 data.rp_gen = rp_gen;
6744 data.rp_gen_seed = rp_gen_seed;
6745 data.force = force;
6746 data.benchmark = benchmark;
6747 data.skip = skip;
6748 data.limit = limit;
6749 #ifdef HAVE_HWMON
6750 data.powertune_enable = powertune_enable;
6751 #endif
6752 data.logfile_disable = logfile_disable;
6753 data.truecrypt_keyfiles = truecrypt_keyfiles;
6754 data.veracrypt_keyfiles = veracrypt_keyfiles;
6755 data.veracrypt_pim = veracrypt_pim;
6756 data.scrypt_tmto = scrypt_tmto;
6757 data.workload_profile = workload_profile;
6758
6759 /**
6760 * cpu affinity
6761 */
6762
6763 if (cpu_affinity)
6764 {
6765 set_cpu_affinity (cpu_affinity);
6766 }
6767
6768 if (rp_gen_seed_chgd == 0)
6769 {
6770 srand (proc_start);
6771 }
6772 else
6773 {
6774 srand (rp_gen_seed);
6775 }
6776
6777 /**
6778 * logfile init
6779 */
6780
6781 if (logfile_disable == 0)
6782 {
6783 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6784
6785 char *logfile = (char *) mymalloc (logfile_size);
6786
6787 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6788
6789 data.logfile = logfile;
6790
6791 char *topid = logfile_generate_topid ();
6792
6793 data.topid = topid;
6794 }
6795
6796 // logfile_append() checks for logfile_disable internally to make it easier from here
6797
6798 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6799 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6800 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6801 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6802 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6803 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6804 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6805 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6806 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6807 #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));
6808
6809 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6810 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6811 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6812 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6813 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6814 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6815 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6816 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6817
6818 logfile_top_msg ("START");
6819
6820 logfile_top_uint (attack_mode);
6821 logfile_top_uint (attack_kern);
6822 logfile_top_uint (benchmark);
6823 logfile_top_uint (bitmap_min);
6824 logfile_top_uint (bitmap_max);
6825 logfile_top_uint (debug_mode);
6826 logfile_top_uint (force);
6827 logfile_top_uint (kernel_accel);
6828 logfile_top_uint (kernel_loops);
6829 logfile_top_uint (gpu_temp_disable);
6830 #ifdef HAVE_HWMON
6831 logfile_top_uint (gpu_temp_abort);
6832 logfile_top_uint (gpu_temp_retain);
6833 #endif
6834 logfile_top_uint (hash_mode);
6835 logfile_top_uint (hex_charset);
6836 logfile_top_uint (hex_salt);
6837 logfile_top_uint (hex_wordlist);
6838 logfile_top_uint (increment);
6839 logfile_top_uint (increment_max);
6840 logfile_top_uint (increment_min);
6841 logfile_top_uint (keyspace);
6842 logfile_top_uint (left);
6843 logfile_top_uint (logfile_disable);
6844 logfile_top_uint (loopback);
6845 logfile_top_uint (markov_classic);
6846 logfile_top_uint (markov_disable);
6847 logfile_top_uint (markov_threshold);
6848 logfile_top_uint (outfile_autohex);
6849 logfile_top_uint (outfile_check_timer);
6850 logfile_top_uint (outfile_format);
6851 logfile_top_uint (potfile_disable);
6852 logfile_top_string (potfile_path);
6853 #if defined(HAVE_HWMON)
6854 logfile_top_uint (powertune_enable);
6855 #endif
6856 logfile_top_uint (scrypt_tmto);
6857 logfile_top_uint (quiet);
6858 logfile_top_uint (remove);
6859 logfile_top_uint (remove_timer);
6860 logfile_top_uint (restore);
6861 logfile_top_uint (restore_disable);
6862 logfile_top_uint (restore_timer);
6863 logfile_top_uint (rp_gen);
6864 logfile_top_uint (rp_gen_func_max);
6865 logfile_top_uint (rp_gen_func_min);
6866 logfile_top_uint (rp_gen_seed);
6867 logfile_top_uint (runtime);
6868 logfile_top_uint (segment_size);
6869 logfile_top_uint (show);
6870 logfile_top_uint (status);
6871 logfile_top_uint (machine_readable);
6872 logfile_top_uint (status_timer);
6873 logfile_top_uint (usage);
6874 logfile_top_uint (username);
6875 logfile_top_uint (version);
6876 logfile_top_uint (weak_hash_threshold);
6877 logfile_top_uint (workload_profile);
6878 logfile_top_uint64 (limit);
6879 logfile_top_uint64 (skip);
6880 logfile_top_char (separator);
6881 logfile_top_string (cpu_affinity);
6882 logfile_top_string (custom_charset_1);
6883 logfile_top_string (custom_charset_2);
6884 logfile_top_string (custom_charset_3);
6885 logfile_top_string (custom_charset_4);
6886 logfile_top_string (debug_file);
6887 logfile_top_string (opencl_devices);
6888 logfile_top_string (opencl_platforms);
6889 logfile_top_string (opencl_device_types);
6890 logfile_top_uint (opencl_vector_width);
6891 logfile_top_string (induction_dir);
6892 logfile_top_string (markov_hcstat);
6893 logfile_top_string (outfile);
6894 logfile_top_string (outfile_check_dir);
6895 logfile_top_string (rule_buf_l);
6896 logfile_top_string (rule_buf_r);
6897 logfile_top_string (session);
6898 logfile_top_string (truecrypt_keyfiles);
6899 logfile_top_string (veracrypt_keyfiles);
6900 logfile_top_uint (veracrypt_pim);
6901
6902 /**
6903 * Init OpenCL library loader
6904 */
6905
6906 if (keyspace == 0)
6907 {
6908 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6909
6910 ocl_init (ocl);
6911
6912 data.ocl = ocl;
6913 }
6914
6915 /**
6916 * OpenCL platform selection
6917 */
6918
6919 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6920
6921 /**
6922 * OpenCL device selection
6923 */
6924
6925 u32 devices_filter = setup_devices_filter (opencl_devices);
6926
6927 /**
6928 * OpenCL device type selection
6929 */
6930
6931 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6932
6933 /**
6934 * benchmark
6935 */
6936
6937 if (benchmark == 1)
6938 {
6939 /**
6940 * disable useless stuff for benchmark
6941 */
6942
6943 status_timer = 0;
6944 restore_timer = 0;
6945 restore_disable = 1;
6946 potfile_disable = 1;
6947 weak_hash_threshold = 0;
6948 gpu_temp_disable = 1;
6949
6950 #ifdef HAVE_HWMON
6951 powertune_enable = 1;
6952 #endif
6953
6954 data.status_timer = status_timer;
6955 data.restore_timer = restore_timer;
6956 data.restore_disable = restore_disable;
6957
6958 /**
6959 * force attack mode to be bruteforce
6960 */
6961
6962 attack_mode = ATTACK_MODE_BF;
6963 attack_kern = ATTACK_KERN_BF;
6964
6965 if (workload_profile_chgd == 0)
6966 {
6967 workload_profile = 3;
6968
6969 data.workload_profile = workload_profile;
6970 }
6971 }
6972
6973 /**
6974 * config
6975 */
6976
6977 uint hash_type = 0;
6978 uint salt_type = 0;
6979 uint attack_exec = 0;
6980 uint opts_type = 0;
6981 uint kern_type = 0;
6982 uint dgst_size = 0;
6983 uint esalt_size = 0;
6984 uint opti_type = 0;
6985 uint dgst_pos0 = -1;
6986 uint dgst_pos1 = -1;
6987 uint dgst_pos2 = -1;
6988 uint dgst_pos3 = -1;
6989
6990 int (*parse_func) (char *, uint, hash_t *);
6991 int (*sort_by_digest) (const void *, const void *);
6992
6993 uint algorithm_pos = 0;
6994 uint algorithm_max = 1;
6995
6996 uint *algorithms = default_benchmark_algorithms;
6997
6998 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6999
7000 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7001 {
7002 /*
7003 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7004 * the following algos are skipped entirely
7005 */
7006
7007 if (algorithm_pos > 0)
7008 {
7009 local_free (rd);
7010
7011 rd = init_restore (argc, argv);
7012
7013 data.rd = rd;
7014 }
7015
7016 /**
7017 * update hash_mode in case of multihash benchmark
7018 */
7019
7020 if (benchmark == 1)
7021 {
7022 if (hash_mode_chgd == 0)
7023 {
7024 hash_mode = algorithms[algorithm_pos];
7025
7026 data.hash_mode = hash_mode;
7027 }
7028
7029 quiet = 1;
7030
7031 data.quiet = quiet;
7032 }
7033
7034 switch (hash_mode)
7035 {
7036 case 0: hash_type = HASH_TYPE_MD5;
7037 salt_type = SALT_TYPE_NONE;
7038 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7039 opts_type = OPTS_TYPE_PT_GENERATE_LE
7040 | OPTS_TYPE_PT_ADD80
7041 | OPTS_TYPE_PT_ADDBITS14;
7042 kern_type = KERN_TYPE_MD5;
7043 dgst_size = DGST_SIZE_4_4;
7044 parse_func = md5_parse_hash;
7045 sort_by_digest = sort_by_digest_4_4;
7046 opti_type = OPTI_TYPE_ZERO_BYTE
7047 | OPTI_TYPE_PRECOMPUTE_INIT
7048 | OPTI_TYPE_PRECOMPUTE_MERKLE
7049 | OPTI_TYPE_MEET_IN_MIDDLE
7050 | OPTI_TYPE_EARLY_SKIP
7051 | OPTI_TYPE_NOT_ITERATED
7052 | OPTI_TYPE_NOT_SALTED
7053 | OPTI_TYPE_RAW_HASH;
7054 dgst_pos0 = 0;
7055 dgst_pos1 = 3;
7056 dgst_pos2 = 2;
7057 dgst_pos3 = 1;
7058 break;
7059
7060 case 10: hash_type = HASH_TYPE_MD5;
7061 salt_type = SALT_TYPE_INTERN;
7062 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7063 opts_type = OPTS_TYPE_PT_GENERATE_LE
7064 | OPTS_TYPE_ST_ADD80
7065 | OPTS_TYPE_ST_ADDBITS14;
7066 kern_type = KERN_TYPE_MD5_PWSLT;
7067 dgst_size = DGST_SIZE_4_4;
7068 parse_func = md5s_parse_hash;
7069 sort_by_digest = sort_by_digest_4_4;
7070 opti_type = OPTI_TYPE_ZERO_BYTE
7071 | OPTI_TYPE_PRECOMPUTE_INIT
7072 | OPTI_TYPE_PRECOMPUTE_MERKLE
7073 | OPTI_TYPE_MEET_IN_MIDDLE
7074 | OPTI_TYPE_EARLY_SKIP
7075 | OPTI_TYPE_NOT_ITERATED
7076 | OPTI_TYPE_APPENDED_SALT
7077 | OPTI_TYPE_RAW_HASH;
7078 dgst_pos0 = 0;
7079 dgst_pos1 = 3;
7080 dgst_pos2 = 2;
7081 dgst_pos3 = 1;
7082 break;
7083
7084 case 11: hash_type = HASH_TYPE_MD5;
7085 salt_type = SALT_TYPE_INTERN;
7086 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7087 opts_type = OPTS_TYPE_PT_GENERATE_LE
7088 | OPTS_TYPE_ST_ADD80
7089 | OPTS_TYPE_ST_ADDBITS14;
7090 kern_type = KERN_TYPE_MD5_PWSLT;
7091 dgst_size = DGST_SIZE_4_4;
7092 parse_func = joomla_parse_hash;
7093 sort_by_digest = sort_by_digest_4_4;
7094 opti_type = OPTI_TYPE_ZERO_BYTE
7095 | OPTI_TYPE_PRECOMPUTE_INIT
7096 | OPTI_TYPE_PRECOMPUTE_MERKLE
7097 | OPTI_TYPE_MEET_IN_MIDDLE
7098 | OPTI_TYPE_EARLY_SKIP
7099 | OPTI_TYPE_NOT_ITERATED
7100 | OPTI_TYPE_APPENDED_SALT
7101 | OPTI_TYPE_RAW_HASH;
7102 dgst_pos0 = 0;
7103 dgst_pos1 = 3;
7104 dgst_pos2 = 2;
7105 dgst_pos3 = 1;
7106 break;
7107
7108 case 12: hash_type = HASH_TYPE_MD5;
7109 salt_type = SALT_TYPE_INTERN;
7110 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7111 opts_type = OPTS_TYPE_PT_GENERATE_LE
7112 | OPTS_TYPE_ST_ADD80
7113 | OPTS_TYPE_ST_ADDBITS14;
7114 kern_type = KERN_TYPE_MD5_PWSLT;
7115 dgst_size = DGST_SIZE_4_4;
7116 parse_func = postgresql_parse_hash;
7117 sort_by_digest = sort_by_digest_4_4;
7118 opti_type = OPTI_TYPE_ZERO_BYTE
7119 | OPTI_TYPE_PRECOMPUTE_INIT
7120 | OPTI_TYPE_PRECOMPUTE_MERKLE
7121 | OPTI_TYPE_MEET_IN_MIDDLE
7122 | OPTI_TYPE_EARLY_SKIP
7123 | OPTI_TYPE_NOT_ITERATED
7124 | OPTI_TYPE_APPENDED_SALT
7125 | OPTI_TYPE_RAW_HASH;
7126 dgst_pos0 = 0;
7127 dgst_pos1 = 3;
7128 dgst_pos2 = 2;
7129 dgst_pos3 = 1;
7130 break;
7131
7132 case 20: hash_type = HASH_TYPE_MD5;
7133 salt_type = SALT_TYPE_INTERN;
7134 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7135 opts_type = OPTS_TYPE_PT_GENERATE_LE
7136 | OPTS_TYPE_PT_ADD80
7137 | OPTS_TYPE_PT_ADDBITS14;
7138 kern_type = KERN_TYPE_MD5_SLTPW;
7139 dgst_size = DGST_SIZE_4_4;
7140 parse_func = md5s_parse_hash;
7141 sort_by_digest = sort_by_digest_4_4;
7142 opti_type = OPTI_TYPE_ZERO_BYTE
7143 | OPTI_TYPE_PRECOMPUTE_INIT
7144 | OPTI_TYPE_PRECOMPUTE_MERKLE
7145 | OPTI_TYPE_EARLY_SKIP
7146 | OPTI_TYPE_NOT_ITERATED
7147 | OPTI_TYPE_PREPENDED_SALT
7148 | OPTI_TYPE_RAW_HASH;
7149 dgst_pos0 = 0;
7150 dgst_pos1 = 3;
7151 dgst_pos2 = 2;
7152 dgst_pos3 = 1;
7153 break;
7154
7155 case 21: hash_type = HASH_TYPE_MD5;
7156 salt_type = SALT_TYPE_INTERN;
7157 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7158 opts_type = OPTS_TYPE_PT_GENERATE_LE
7159 | OPTS_TYPE_PT_ADD80
7160 | OPTS_TYPE_PT_ADDBITS14;
7161 kern_type = KERN_TYPE_MD5_SLTPW;
7162 dgst_size = DGST_SIZE_4_4;
7163 parse_func = osc_parse_hash;
7164 sort_by_digest = sort_by_digest_4_4;
7165 opti_type = OPTI_TYPE_ZERO_BYTE
7166 | OPTI_TYPE_PRECOMPUTE_INIT
7167 | OPTI_TYPE_PRECOMPUTE_MERKLE
7168 | OPTI_TYPE_EARLY_SKIP
7169 | OPTI_TYPE_NOT_ITERATED
7170 | OPTI_TYPE_PREPENDED_SALT
7171 | OPTI_TYPE_RAW_HASH;
7172 dgst_pos0 = 0;
7173 dgst_pos1 = 3;
7174 dgst_pos2 = 2;
7175 dgst_pos3 = 1;
7176 break;
7177
7178 case 22: hash_type = HASH_TYPE_MD5;
7179 salt_type = SALT_TYPE_EMBEDDED;
7180 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7181 opts_type = OPTS_TYPE_PT_GENERATE_LE
7182 | OPTS_TYPE_PT_ADD80
7183 | OPTS_TYPE_PT_ADDBITS14;
7184 kern_type = KERN_TYPE_MD5_SLTPW;
7185 dgst_size = DGST_SIZE_4_4;
7186 parse_func = netscreen_parse_hash;
7187 sort_by_digest = sort_by_digest_4_4;
7188 opti_type = OPTI_TYPE_ZERO_BYTE
7189 | OPTI_TYPE_PRECOMPUTE_INIT
7190 | OPTI_TYPE_PRECOMPUTE_MERKLE
7191 | OPTI_TYPE_EARLY_SKIP
7192 | OPTI_TYPE_NOT_ITERATED
7193 | OPTI_TYPE_PREPENDED_SALT
7194 | OPTI_TYPE_RAW_HASH;
7195 dgst_pos0 = 0;
7196 dgst_pos1 = 3;
7197 dgst_pos2 = 2;
7198 dgst_pos3 = 1;
7199 break;
7200
7201 case 23: hash_type = HASH_TYPE_MD5;
7202 salt_type = SALT_TYPE_EMBEDDED;
7203 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7204 opts_type = OPTS_TYPE_PT_GENERATE_LE
7205 | OPTS_TYPE_PT_ADD80
7206 | OPTS_TYPE_PT_ADDBITS14;
7207 kern_type = KERN_TYPE_MD5_SLTPW;
7208 dgst_size = DGST_SIZE_4_4;
7209 parse_func = skype_parse_hash;
7210 sort_by_digest = sort_by_digest_4_4;
7211 opti_type = OPTI_TYPE_ZERO_BYTE
7212 | OPTI_TYPE_PRECOMPUTE_INIT
7213 | OPTI_TYPE_PRECOMPUTE_MERKLE
7214 | OPTI_TYPE_EARLY_SKIP
7215 | OPTI_TYPE_NOT_ITERATED
7216 | OPTI_TYPE_PREPENDED_SALT
7217 | OPTI_TYPE_RAW_HASH;
7218 dgst_pos0 = 0;
7219 dgst_pos1 = 3;
7220 dgst_pos2 = 2;
7221 dgst_pos3 = 1;
7222 break;
7223
7224 case 30: hash_type = HASH_TYPE_MD5;
7225 salt_type = SALT_TYPE_INTERN;
7226 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7227 opts_type = OPTS_TYPE_PT_GENERATE_LE
7228 | OPTS_TYPE_PT_UNICODE
7229 | OPTS_TYPE_ST_ADD80
7230 | OPTS_TYPE_ST_ADDBITS14;
7231 kern_type = KERN_TYPE_MD5_PWUSLT;
7232 dgst_size = DGST_SIZE_4_4;
7233 parse_func = md5s_parse_hash;
7234 sort_by_digest = sort_by_digest_4_4;
7235 opti_type = OPTI_TYPE_ZERO_BYTE
7236 | OPTI_TYPE_PRECOMPUTE_INIT
7237 | OPTI_TYPE_PRECOMPUTE_MERKLE
7238 | OPTI_TYPE_MEET_IN_MIDDLE
7239 | OPTI_TYPE_EARLY_SKIP
7240 | OPTI_TYPE_NOT_ITERATED
7241 | OPTI_TYPE_APPENDED_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 40: 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_ADD80
7254 | OPTS_TYPE_PT_ADDBITS14
7255 | OPTS_TYPE_PT_UNICODE;
7256 kern_type = KERN_TYPE_MD5_SLTPWU;
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_EARLY_SKIP
7264 | OPTI_TYPE_NOT_ITERATED
7265 | OPTI_TYPE_PREPENDED_SALT
7266 | OPTI_TYPE_RAW_HASH;
7267 dgst_pos0 = 0;
7268 dgst_pos1 = 3;
7269 dgst_pos2 = 2;
7270 dgst_pos3 = 1;
7271 break;
7272
7273 case 50: hash_type = HASH_TYPE_MD5;
7274 salt_type = SALT_TYPE_INTERN;
7275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7276 opts_type = OPTS_TYPE_PT_GENERATE_LE
7277 | OPTS_TYPE_ST_ADD80
7278 | OPTS_TYPE_ST_ADDBITS14;
7279 kern_type = KERN_TYPE_HMACMD5_PW;
7280 dgst_size = DGST_SIZE_4_4;
7281 parse_func = hmacmd5_parse_hash;
7282 sort_by_digest = sort_by_digest_4_4;
7283 opti_type = OPTI_TYPE_ZERO_BYTE
7284 | OPTI_TYPE_NOT_ITERATED;
7285 dgst_pos0 = 0;
7286 dgst_pos1 = 3;
7287 dgst_pos2 = 2;
7288 dgst_pos3 = 1;
7289 break;
7290
7291 case 60: hash_type = HASH_TYPE_MD5;
7292 salt_type = SALT_TYPE_INTERN;
7293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7294 opts_type = OPTS_TYPE_PT_GENERATE_LE
7295 | OPTS_TYPE_PT_ADD80
7296 | OPTS_TYPE_PT_ADDBITS14;
7297 kern_type = KERN_TYPE_HMACMD5_SLT;
7298 dgst_size = DGST_SIZE_4_4;
7299 parse_func = hmacmd5_parse_hash;
7300 sort_by_digest = sort_by_digest_4_4;
7301 opti_type = OPTI_TYPE_ZERO_BYTE
7302 | OPTI_TYPE_NOT_ITERATED;
7303 dgst_pos0 = 0;
7304 dgst_pos1 = 3;
7305 dgst_pos2 = 2;
7306 dgst_pos3 = 1;
7307 break;
7308
7309 case 100: hash_type = HASH_TYPE_SHA1;
7310 salt_type = SALT_TYPE_NONE;
7311 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7312 opts_type = OPTS_TYPE_PT_GENERATE_BE
7313 | OPTS_TYPE_PT_ADD80
7314 | OPTS_TYPE_PT_ADDBITS15;
7315 kern_type = KERN_TYPE_SHA1;
7316 dgst_size = DGST_SIZE_4_5;
7317 parse_func = sha1_parse_hash;
7318 sort_by_digest = sort_by_digest_4_5;
7319 opti_type = OPTI_TYPE_ZERO_BYTE
7320 | OPTI_TYPE_PRECOMPUTE_INIT
7321 | OPTI_TYPE_PRECOMPUTE_MERKLE
7322 | OPTI_TYPE_EARLY_SKIP
7323 | OPTI_TYPE_NOT_ITERATED
7324 | OPTI_TYPE_NOT_SALTED
7325 | OPTI_TYPE_RAW_HASH;
7326 dgst_pos0 = 3;
7327 dgst_pos1 = 4;
7328 dgst_pos2 = 2;
7329 dgst_pos3 = 1;
7330 break;
7331
7332 case 101: hash_type = HASH_TYPE_SHA1;
7333 salt_type = SALT_TYPE_NONE;
7334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7335 opts_type = OPTS_TYPE_PT_GENERATE_BE
7336 | OPTS_TYPE_PT_ADD80
7337 | OPTS_TYPE_PT_ADDBITS15;
7338 kern_type = KERN_TYPE_SHA1;
7339 dgst_size = DGST_SIZE_4_5;
7340 parse_func = sha1b64_parse_hash;
7341 sort_by_digest = sort_by_digest_4_5;
7342 opti_type = OPTI_TYPE_ZERO_BYTE
7343 | OPTI_TYPE_PRECOMPUTE_INIT
7344 | OPTI_TYPE_PRECOMPUTE_MERKLE
7345 | OPTI_TYPE_EARLY_SKIP
7346 | OPTI_TYPE_NOT_ITERATED
7347 | OPTI_TYPE_NOT_SALTED
7348 | OPTI_TYPE_RAW_HASH;
7349 dgst_pos0 = 3;
7350 dgst_pos1 = 4;
7351 dgst_pos2 = 2;
7352 dgst_pos3 = 1;
7353 break;
7354
7355 case 110: hash_type = HASH_TYPE_SHA1;
7356 salt_type = SALT_TYPE_INTERN;
7357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7358 opts_type = OPTS_TYPE_PT_GENERATE_BE
7359 | OPTS_TYPE_ST_ADD80
7360 | OPTS_TYPE_ST_ADDBITS15;
7361 kern_type = KERN_TYPE_SHA1_PWSLT;
7362 dgst_size = DGST_SIZE_4_5;
7363 parse_func = sha1s_parse_hash;
7364 sort_by_digest = sort_by_digest_4_5;
7365 opti_type = OPTI_TYPE_ZERO_BYTE
7366 | OPTI_TYPE_PRECOMPUTE_INIT
7367 | OPTI_TYPE_PRECOMPUTE_MERKLE
7368 | OPTI_TYPE_EARLY_SKIP
7369 | OPTI_TYPE_NOT_ITERATED
7370 | OPTI_TYPE_APPENDED_SALT
7371 | OPTI_TYPE_RAW_HASH;
7372 dgst_pos0 = 3;
7373 dgst_pos1 = 4;
7374 dgst_pos2 = 2;
7375 dgst_pos3 = 1;
7376 break;
7377
7378 case 111: hash_type = HASH_TYPE_SHA1;
7379 salt_type = SALT_TYPE_EMBEDDED;
7380 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7381 opts_type = OPTS_TYPE_PT_GENERATE_BE
7382 | OPTS_TYPE_ST_ADD80
7383 | OPTS_TYPE_ST_ADDBITS15;
7384 kern_type = KERN_TYPE_SHA1_PWSLT;
7385 dgst_size = DGST_SIZE_4_5;
7386 parse_func = sha1b64s_parse_hash;
7387 sort_by_digest = sort_by_digest_4_5;
7388 opti_type = OPTI_TYPE_ZERO_BYTE
7389 | OPTI_TYPE_PRECOMPUTE_INIT
7390 | OPTI_TYPE_PRECOMPUTE_MERKLE
7391 | OPTI_TYPE_EARLY_SKIP
7392 | OPTI_TYPE_NOT_ITERATED
7393 | OPTI_TYPE_APPENDED_SALT
7394 | OPTI_TYPE_RAW_HASH;
7395 dgst_pos0 = 3;
7396 dgst_pos1 = 4;
7397 dgst_pos2 = 2;
7398 dgst_pos3 = 1;
7399 break;
7400
7401 case 112: hash_type = HASH_TYPE_SHA1;
7402 salt_type = SALT_TYPE_INTERN;
7403 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7404 opts_type = OPTS_TYPE_PT_GENERATE_BE
7405 | OPTS_TYPE_ST_ADD80
7406 | OPTS_TYPE_ST_ADDBITS15
7407 | OPTS_TYPE_ST_HEX;
7408 kern_type = KERN_TYPE_SHA1_PWSLT;
7409 dgst_size = DGST_SIZE_4_5;
7410 parse_func = oracles_parse_hash;
7411 sort_by_digest = sort_by_digest_4_5;
7412 opti_type = OPTI_TYPE_ZERO_BYTE
7413 | OPTI_TYPE_PRECOMPUTE_INIT
7414 | OPTI_TYPE_PRECOMPUTE_MERKLE
7415 | OPTI_TYPE_EARLY_SKIP
7416 | OPTI_TYPE_NOT_ITERATED
7417 | OPTI_TYPE_APPENDED_SALT
7418 | OPTI_TYPE_RAW_HASH;
7419 dgst_pos0 = 3;
7420 dgst_pos1 = 4;
7421 dgst_pos2 = 2;
7422 dgst_pos3 = 1;
7423 break;
7424
7425 case 120: hash_type = HASH_TYPE_SHA1;
7426 salt_type = SALT_TYPE_INTERN;
7427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7428 opts_type = OPTS_TYPE_PT_GENERATE_BE
7429 | OPTS_TYPE_PT_ADD80
7430 | OPTS_TYPE_PT_ADDBITS15;
7431 kern_type = KERN_TYPE_SHA1_SLTPW;
7432 dgst_size = DGST_SIZE_4_5;
7433 parse_func = sha1s_parse_hash;
7434 sort_by_digest = sort_by_digest_4_5;
7435 opti_type = OPTI_TYPE_ZERO_BYTE
7436 | OPTI_TYPE_PRECOMPUTE_INIT
7437 | OPTI_TYPE_PRECOMPUTE_MERKLE
7438 | OPTI_TYPE_EARLY_SKIP
7439 | OPTI_TYPE_NOT_ITERATED
7440 | OPTI_TYPE_PREPENDED_SALT
7441 | OPTI_TYPE_RAW_HASH;
7442 dgst_pos0 = 3;
7443 dgst_pos1 = 4;
7444 dgst_pos2 = 2;
7445 dgst_pos3 = 1;
7446 break;
7447
7448 case 121: hash_type = HASH_TYPE_SHA1;
7449 salt_type = SALT_TYPE_INTERN;
7450 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7451 opts_type = OPTS_TYPE_PT_GENERATE_BE
7452 | OPTS_TYPE_PT_ADD80
7453 | OPTS_TYPE_PT_ADDBITS15
7454 | OPTS_TYPE_ST_LOWER;
7455 kern_type = KERN_TYPE_SHA1_SLTPW;
7456 dgst_size = DGST_SIZE_4_5;
7457 parse_func = smf_parse_hash;
7458 sort_by_digest = sort_by_digest_4_5;
7459 opti_type = OPTI_TYPE_ZERO_BYTE
7460 | OPTI_TYPE_PRECOMPUTE_INIT
7461 | OPTI_TYPE_PRECOMPUTE_MERKLE
7462 | OPTI_TYPE_EARLY_SKIP
7463 | OPTI_TYPE_NOT_ITERATED
7464 | OPTI_TYPE_PREPENDED_SALT
7465 | OPTI_TYPE_RAW_HASH;
7466 dgst_pos0 = 3;
7467 dgst_pos1 = 4;
7468 dgst_pos2 = 2;
7469 dgst_pos3 = 1;
7470 break;
7471
7472 case 122: hash_type = HASH_TYPE_SHA1;
7473 salt_type = SALT_TYPE_EMBEDDED;
7474 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7475 opts_type = OPTS_TYPE_PT_GENERATE_BE
7476 | OPTS_TYPE_PT_ADD80
7477 | OPTS_TYPE_PT_ADDBITS15
7478 | OPTS_TYPE_ST_HEX;
7479 kern_type = KERN_TYPE_SHA1_SLTPW;
7480 dgst_size = DGST_SIZE_4_5;
7481 parse_func = osx1_parse_hash;
7482 sort_by_digest = sort_by_digest_4_5;
7483 opti_type = OPTI_TYPE_ZERO_BYTE
7484 | OPTI_TYPE_PRECOMPUTE_INIT
7485 | OPTI_TYPE_PRECOMPUTE_MERKLE
7486 | OPTI_TYPE_EARLY_SKIP
7487 | OPTI_TYPE_NOT_ITERATED
7488 | OPTI_TYPE_PREPENDED_SALT
7489 | OPTI_TYPE_RAW_HASH;
7490 dgst_pos0 = 3;
7491 dgst_pos1 = 4;
7492 dgst_pos2 = 2;
7493 dgst_pos3 = 1;
7494 break;
7495
7496 case 124: hash_type = HASH_TYPE_SHA1;
7497 salt_type = SALT_TYPE_EMBEDDED;
7498 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7499 opts_type = OPTS_TYPE_PT_GENERATE_BE
7500 | OPTS_TYPE_PT_ADD80
7501 | OPTS_TYPE_PT_ADDBITS15;
7502 kern_type = KERN_TYPE_SHA1_SLTPW;
7503 dgst_size = DGST_SIZE_4_5;
7504 parse_func = djangosha1_parse_hash;
7505 sort_by_digest = sort_by_digest_4_5;
7506 opti_type = OPTI_TYPE_ZERO_BYTE
7507 | OPTI_TYPE_PRECOMPUTE_INIT
7508 | OPTI_TYPE_PRECOMPUTE_MERKLE
7509 | OPTI_TYPE_EARLY_SKIP
7510 | OPTI_TYPE_NOT_ITERATED
7511 | OPTI_TYPE_PREPENDED_SALT
7512 | OPTI_TYPE_RAW_HASH;
7513 dgst_pos0 = 3;
7514 dgst_pos1 = 4;
7515 dgst_pos2 = 2;
7516 dgst_pos3 = 1;
7517 break;
7518
7519 case 125: hash_type = HASH_TYPE_SHA1;
7520 salt_type = SALT_TYPE_EMBEDDED;
7521 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7522 opts_type = OPTS_TYPE_PT_GENERATE_BE
7523 | OPTS_TYPE_PT_ADD80
7524 | OPTS_TYPE_PT_ADDBITS15
7525 | OPTS_TYPE_ST_HEX;
7526 kern_type = KERN_TYPE_SHA1_SLTPW;
7527 dgst_size = DGST_SIZE_4_5;
7528 parse_func = arubaos_parse_hash;
7529 sort_by_digest = sort_by_digest_4_5;
7530 opti_type = OPTI_TYPE_ZERO_BYTE
7531 | OPTI_TYPE_PRECOMPUTE_INIT
7532 | OPTI_TYPE_PRECOMPUTE_MERKLE
7533 | OPTI_TYPE_EARLY_SKIP
7534 | OPTI_TYPE_NOT_ITERATED
7535 | OPTI_TYPE_PREPENDED_SALT
7536 | OPTI_TYPE_RAW_HASH;
7537 dgst_pos0 = 3;
7538 dgst_pos1 = 4;
7539 dgst_pos2 = 2;
7540 dgst_pos3 = 1;
7541 break;
7542
7543 case 130: hash_type = HASH_TYPE_SHA1;
7544 salt_type = SALT_TYPE_INTERN;
7545 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7546 opts_type = OPTS_TYPE_PT_GENERATE_BE
7547 | OPTS_TYPE_PT_UNICODE
7548 | OPTS_TYPE_ST_ADD80
7549 | OPTS_TYPE_ST_ADDBITS15;
7550 kern_type = KERN_TYPE_SHA1_PWUSLT;
7551 dgst_size = DGST_SIZE_4_5;
7552 parse_func = sha1s_parse_hash;
7553 sort_by_digest = sort_by_digest_4_5;
7554 opti_type = OPTI_TYPE_ZERO_BYTE
7555 | OPTI_TYPE_PRECOMPUTE_INIT
7556 | OPTI_TYPE_PRECOMPUTE_MERKLE
7557 | OPTI_TYPE_EARLY_SKIP
7558 | OPTI_TYPE_NOT_ITERATED
7559 | OPTI_TYPE_APPENDED_SALT
7560 | OPTI_TYPE_RAW_HASH;
7561 dgst_pos0 = 3;
7562 dgst_pos1 = 4;
7563 dgst_pos2 = 2;
7564 dgst_pos3 = 1;
7565 break;
7566
7567 case 131: hash_type = HASH_TYPE_SHA1;
7568 salt_type = SALT_TYPE_EMBEDDED;
7569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7570 opts_type = OPTS_TYPE_PT_GENERATE_BE
7571 | OPTS_TYPE_PT_UNICODE
7572 | OPTS_TYPE_PT_UPPER
7573 | OPTS_TYPE_ST_ADD80
7574 | OPTS_TYPE_ST_ADDBITS15
7575 | OPTS_TYPE_ST_HEX;
7576 kern_type = KERN_TYPE_SHA1_PWUSLT;
7577 dgst_size = DGST_SIZE_4_5;
7578 parse_func = mssql2000_parse_hash;
7579 sort_by_digest = sort_by_digest_4_5;
7580 opti_type = OPTI_TYPE_ZERO_BYTE
7581 | OPTI_TYPE_PRECOMPUTE_INIT
7582 | OPTI_TYPE_PRECOMPUTE_MERKLE
7583 | OPTI_TYPE_EARLY_SKIP
7584 | OPTI_TYPE_NOT_ITERATED
7585 | OPTI_TYPE_APPENDED_SALT
7586 | OPTI_TYPE_RAW_HASH;
7587 dgst_pos0 = 3;
7588 dgst_pos1 = 4;
7589 dgst_pos2 = 2;
7590 dgst_pos3 = 1;
7591 break;
7592
7593 case 132: hash_type = HASH_TYPE_SHA1;
7594 salt_type = SALT_TYPE_EMBEDDED;
7595 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7596 opts_type = OPTS_TYPE_PT_GENERATE_BE
7597 | OPTS_TYPE_PT_UNICODE
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 = mssql2005_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 133: 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 kern_type = KERN_TYPE_SHA1_PWUSLT;
7626 dgst_size = DGST_SIZE_4_5;
7627 parse_func = peoplesoft_parse_hash;
7628 sort_by_digest = sort_by_digest_4_5;
7629 opti_type = OPTI_TYPE_ZERO_BYTE
7630 | OPTI_TYPE_PRECOMPUTE_INIT
7631 | OPTI_TYPE_PRECOMPUTE_MERKLE
7632 | OPTI_TYPE_EARLY_SKIP
7633 | OPTI_TYPE_NOT_ITERATED
7634 | OPTI_TYPE_APPENDED_SALT
7635 | OPTI_TYPE_RAW_HASH;
7636 dgst_pos0 = 3;
7637 dgst_pos1 = 4;
7638 dgst_pos2 = 2;
7639 dgst_pos3 = 1;
7640 break;
7641
7642 case 140: hash_type = HASH_TYPE_SHA1;
7643 salt_type = SALT_TYPE_INTERN;
7644 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7645 opts_type = OPTS_TYPE_PT_GENERATE_BE
7646 | OPTS_TYPE_PT_ADD80
7647 | OPTS_TYPE_PT_ADDBITS15
7648 | OPTS_TYPE_PT_UNICODE;
7649 kern_type = KERN_TYPE_SHA1_SLTPWU;
7650 dgst_size = DGST_SIZE_4_5;
7651 parse_func = sha1s_parse_hash;
7652 sort_by_digest = sort_by_digest_4_5;
7653 opti_type = OPTI_TYPE_ZERO_BYTE
7654 | OPTI_TYPE_PRECOMPUTE_INIT
7655 | OPTI_TYPE_PRECOMPUTE_MERKLE
7656 | OPTI_TYPE_EARLY_SKIP
7657 | OPTI_TYPE_NOT_ITERATED
7658 | OPTI_TYPE_PREPENDED_SALT
7659 | OPTI_TYPE_RAW_HASH;
7660 dgst_pos0 = 3;
7661 dgst_pos1 = 4;
7662 dgst_pos2 = 2;
7663 dgst_pos3 = 1;
7664 break;
7665
7666 case 141: hash_type = HASH_TYPE_SHA1;
7667 salt_type = SALT_TYPE_EMBEDDED;
7668 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7669 opts_type = OPTS_TYPE_PT_GENERATE_BE
7670 | OPTS_TYPE_PT_ADD80
7671 | OPTS_TYPE_PT_ADDBITS15
7672 | OPTS_TYPE_PT_UNICODE
7673 | OPTS_TYPE_ST_BASE64;
7674 kern_type = KERN_TYPE_SHA1_SLTPWU;
7675 dgst_size = DGST_SIZE_4_5;
7676 parse_func = episerver_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 150: hash_type = HASH_TYPE_SHA1;
7692 salt_type = SALT_TYPE_INTERN;
7693 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7694 opts_type = OPTS_TYPE_PT_GENERATE_BE
7695 | OPTS_TYPE_ST_ADD80
7696 | OPTS_TYPE_ST_ADDBITS15;
7697 kern_type = KERN_TYPE_HMACSHA1_PW;
7698 dgst_size = DGST_SIZE_4_5;
7699 parse_func = hmacsha1_parse_hash;
7700 sort_by_digest = sort_by_digest_4_5;
7701 opti_type = OPTI_TYPE_ZERO_BYTE
7702 | OPTI_TYPE_NOT_ITERATED;
7703 dgst_pos0 = 3;
7704 dgst_pos1 = 4;
7705 dgst_pos2 = 2;
7706 dgst_pos3 = 1;
7707 break;
7708
7709 case 160: hash_type = HASH_TYPE_SHA1;
7710 salt_type = SALT_TYPE_INTERN;
7711 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7712 opts_type = OPTS_TYPE_PT_GENERATE_BE
7713 | OPTS_TYPE_PT_ADD80
7714 | OPTS_TYPE_PT_ADDBITS15;
7715 kern_type = KERN_TYPE_HMACSHA1_SLT;
7716 dgst_size = DGST_SIZE_4_5;
7717 parse_func = hmacsha1_parse_hash;
7718 sort_by_digest = sort_by_digest_4_5;
7719 opti_type = OPTI_TYPE_ZERO_BYTE
7720 | OPTI_TYPE_NOT_ITERATED;
7721 dgst_pos0 = 3;
7722 dgst_pos1 = 4;
7723 dgst_pos2 = 2;
7724 dgst_pos3 = 1;
7725 break;
7726
7727 case 190: hash_type = HASH_TYPE_SHA1;
7728 salt_type = SALT_TYPE_NONE;
7729 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7730 opts_type = OPTS_TYPE_PT_GENERATE_BE
7731 | OPTS_TYPE_PT_ADD80
7732 | OPTS_TYPE_PT_ADDBITS15;
7733 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7734 dgst_size = DGST_SIZE_4_5;
7735 parse_func = sha1linkedin_parse_hash;
7736 sort_by_digest = sort_by_digest_4_5;
7737 opti_type = OPTI_TYPE_ZERO_BYTE
7738 | OPTI_TYPE_PRECOMPUTE_INIT
7739 | OPTI_TYPE_EARLY_SKIP
7740 | OPTI_TYPE_NOT_ITERATED
7741 | OPTI_TYPE_NOT_SALTED;
7742 dgst_pos0 = 0;
7743 dgst_pos1 = 4;
7744 dgst_pos2 = 3;
7745 dgst_pos3 = 2;
7746 break;
7747
7748 case 200: hash_type = HASH_TYPE_MYSQL;
7749 salt_type = SALT_TYPE_NONE;
7750 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7751 opts_type = 0;
7752 kern_type = KERN_TYPE_MYSQL;
7753 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7754 parse_func = mysql323_parse_hash;
7755 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7756 opti_type = OPTI_TYPE_ZERO_BYTE;
7757 dgst_pos0 = 0;
7758 dgst_pos1 = 1;
7759 dgst_pos2 = 2;
7760 dgst_pos3 = 3;
7761 break;
7762
7763 case 300: hash_type = HASH_TYPE_SHA1;
7764 salt_type = SALT_TYPE_NONE;
7765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7766 opts_type = OPTS_TYPE_PT_GENERATE_BE
7767 | OPTS_TYPE_PT_ADD80
7768 | OPTS_TYPE_PT_ADDBITS15;
7769 kern_type = KERN_TYPE_MYSQL41;
7770 dgst_size = DGST_SIZE_4_5;
7771 parse_func = sha1_parse_hash;
7772 sort_by_digest = sort_by_digest_4_5;
7773 opti_type = OPTI_TYPE_ZERO_BYTE
7774 | OPTI_TYPE_PRECOMPUTE_INIT
7775 | OPTI_TYPE_PRECOMPUTE_MERKLE
7776 | OPTI_TYPE_EARLY_SKIP
7777 | OPTI_TYPE_NOT_ITERATED
7778 | OPTI_TYPE_NOT_SALTED;
7779 dgst_pos0 = 3;
7780 dgst_pos1 = 4;
7781 dgst_pos2 = 2;
7782 dgst_pos3 = 1;
7783 break;
7784
7785 case 400: hash_type = HASH_TYPE_MD5;
7786 salt_type = SALT_TYPE_EMBEDDED;
7787 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7788 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7789 kern_type = KERN_TYPE_PHPASS;
7790 dgst_size = DGST_SIZE_4_4;
7791 parse_func = phpass_parse_hash;
7792 sort_by_digest = sort_by_digest_4_4;
7793 opti_type = OPTI_TYPE_ZERO_BYTE
7794 | OPTI_TYPE_SLOW_HASH_SIMD;
7795 dgst_pos0 = 0;
7796 dgst_pos1 = 1;
7797 dgst_pos2 = 2;
7798 dgst_pos3 = 3;
7799 break;
7800
7801 case 500: hash_type = HASH_TYPE_MD5;
7802 salt_type = SALT_TYPE_EMBEDDED;
7803 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7804 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7805 kern_type = KERN_TYPE_MD5CRYPT;
7806 dgst_size = DGST_SIZE_4_4;
7807 parse_func = md5crypt_parse_hash;
7808 sort_by_digest = sort_by_digest_4_4;
7809 opti_type = OPTI_TYPE_ZERO_BYTE;
7810 dgst_pos0 = 0;
7811 dgst_pos1 = 1;
7812 dgst_pos2 = 2;
7813 dgst_pos3 = 3;
7814 break;
7815
7816 case 501: hash_type = HASH_TYPE_MD5;
7817 salt_type = SALT_TYPE_EMBEDDED;
7818 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7819 opts_type = OPTS_TYPE_PT_GENERATE_LE
7820 | OPTS_TYPE_HASH_COPY;
7821 kern_type = KERN_TYPE_MD5CRYPT;
7822 dgst_size = DGST_SIZE_4_4;
7823 parse_func = juniper_parse_hash;
7824 sort_by_digest = sort_by_digest_4_4;
7825 opti_type = OPTI_TYPE_ZERO_BYTE;
7826 dgst_pos0 = 0;
7827 dgst_pos1 = 1;
7828 dgst_pos2 = 2;
7829 dgst_pos3 = 3;
7830 break;
7831
7832 case 900: hash_type = HASH_TYPE_MD4;
7833 salt_type = SALT_TYPE_NONE;
7834 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7835 opts_type = OPTS_TYPE_PT_GENERATE_LE
7836 | OPTS_TYPE_PT_ADD80
7837 | OPTS_TYPE_PT_ADDBITS14;
7838 kern_type = KERN_TYPE_MD4;
7839 dgst_size = DGST_SIZE_4_4;
7840 parse_func = md4_parse_hash;
7841 sort_by_digest = sort_by_digest_4_4;
7842 opti_type = OPTI_TYPE_ZERO_BYTE
7843 | OPTI_TYPE_PRECOMPUTE_INIT
7844 | OPTI_TYPE_PRECOMPUTE_MERKLE
7845 | OPTI_TYPE_MEET_IN_MIDDLE
7846 | OPTI_TYPE_EARLY_SKIP
7847 | OPTI_TYPE_NOT_ITERATED
7848 | OPTI_TYPE_NOT_SALTED
7849 | OPTI_TYPE_RAW_HASH;
7850 dgst_pos0 = 0;
7851 dgst_pos1 = 3;
7852 dgst_pos2 = 2;
7853 dgst_pos3 = 1;
7854 break;
7855
7856 case 1000: hash_type = HASH_TYPE_MD4;
7857 salt_type = SALT_TYPE_NONE;
7858 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7859 opts_type = OPTS_TYPE_PT_GENERATE_LE
7860 | OPTS_TYPE_PT_ADD80
7861 | OPTS_TYPE_PT_ADDBITS14
7862 | OPTS_TYPE_PT_UNICODE;
7863 kern_type = KERN_TYPE_MD4_PWU;
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 1100: hash_type = HASH_TYPE_MD4;
7882 salt_type = SALT_TYPE_INTERN;
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 | OPTS_TYPE_ST_ADD80
7889 | OPTS_TYPE_ST_UNICODE
7890 | OPTS_TYPE_ST_LOWER;
7891 kern_type = KERN_TYPE_MD44_PWUSLT;
7892 dgst_size = DGST_SIZE_4_4;
7893 parse_func = dcc_parse_hash;
7894 sort_by_digest = sort_by_digest_4_4;
7895 opti_type = OPTI_TYPE_ZERO_BYTE
7896 | OPTI_TYPE_PRECOMPUTE_INIT
7897 | OPTI_TYPE_PRECOMPUTE_MERKLE
7898 | OPTI_TYPE_EARLY_SKIP
7899 | OPTI_TYPE_NOT_ITERATED;
7900 dgst_pos0 = 0;
7901 dgst_pos1 = 3;
7902 dgst_pos2 = 2;
7903 dgst_pos3 = 1;
7904 break;
7905
7906 case 1400: hash_type = HASH_TYPE_SHA256;
7907 salt_type = SALT_TYPE_NONE;
7908 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7909 opts_type = OPTS_TYPE_PT_GENERATE_BE
7910 | OPTS_TYPE_PT_ADD80
7911 | OPTS_TYPE_PT_ADDBITS15;
7912 kern_type = KERN_TYPE_SHA256;
7913 dgst_size = DGST_SIZE_4_8;
7914 parse_func = sha256_parse_hash;
7915 sort_by_digest = sort_by_digest_4_8;
7916 opti_type = OPTI_TYPE_ZERO_BYTE
7917 | OPTI_TYPE_PRECOMPUTE_INIT
7918 | OPTI_TYPE_PRECOMPUTE_MERKLE
7919 | OPTI_TYPE_EARLY_SKIP
7920 | OPTI_TYPE_NOT_ITERATED
7921 | OPTI_TYPE_NOT_SALTED
7922 | OPTI_TYPE_RAW_HASH;
7923 dgst_pos0 = 3;
7924 dgst_pos1 = 7;
7925 dgst_pos2 = 2;
7926 dgst_pos3 = 6;
7927 break;
7928
7929 case 1410: hash_type = HASH_TYPE_SHA256;
7930 salt_type = SALT_TYPE_INTERN;
7931 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7932 opts_type = OPTS_TYPE_PT_GENERATE_BE
7933 | OPTS_TYPE_ST_ADD80
7934 | OPTS_TYPE_ST_ADDBITS15;
7935 kern_type = KERN_TYPE_SHA256_PWSLT;
7936 dgst_size = DGST_SIZE_4_8;
7937 parse_func = sha256s_parse_hash;
7938 sort_by_digest = sort_by_digest_4_8;
7939 opti_type = OPTI_TYPE_ZERO_BYTE
7940 | OPTI_TYPE_PRECOMPUTE_INIT
7941 | OPTI_TYPE_PRECOMPUTE_MERKLE
7942 | OPTI_TYPE_EARLY_SKIP
7943 | OPTI_TYPE_NOT_ITERATED
7944 | OPTI_TYPE_APPENDED_SALT
7945 | OPTI_TYPE_RAW_HASH;
7946 dgst_pos0 = 3;
7947 dgst_pos1 = 7;
7948 dgst_pos2 = 2;
7949 dgst_pos3 = 6;
7950 break;
7951
7952 case 1420: hash_type = HASH_TYPE_SHA256;
7953 salt_type = SALT_TYPE_INTERN;
7954 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7955 opts_type = OPTS_TYPE_PT_GENERATE_BE
7956 | OPTS_TYPE_PT_ADD80
7957 | OPTS_TYPE_PT_ADDBITS15;
7958 kern_type = KERN_TYPE_SHA256_SLTPW;
7959 dgst_size = DGST_SIZE_4_8;
7960 parse_func = sha256s_parse_hash;
7961 sort_by_digest = sort_by_digest_4_8;
7962 opti_type = OPTI_TYPE_ZERO_BYTE
7963 | OPTI_TYPE_PRECOMPUTE_INIT
7964 | OPTI_TYPE_PRECOMPUTE_MERKLE
7965 | OPTI_TYPE_EARLY_SKIP
7966 | OPTI_TYPE_NOT_ITERATED
7967 | OPTI_TYPE_PREPENDED_SALT
7968 | OPTI_TYPE_RAW_HASH;
7969 dgst_pos0 = 3;
7970 dgst_pos1 = 7;
7971 dgst_pos2 = 2;
7972 dgst_pos3 = 6;
7973 break;
7974
7975 case 1421: hash_type = HASH_TYPE_SHA256;
7976 salt_type = SALT_TYPE_EMBEDDED;
7977 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7978 opts_type = OPTS_TYPE_PT_GENERATE_BE
7979 | OPTS_TYPE_PT_ADD80
7980 | OPTS_TYPE_PT_ADDBITS15;
7981 kern_type = KERN_TYPE_SHA256_SLTPW;
7982 dgst_size = DGST_SIZE_4_8;
7983 parse_func = hmailserver_parse_hash;
7984 sort_by_digest = sort_by_digest_4_8;
7985 opti_type = OPTI_TYPE_ZERO_BYTE
7986 | OPTI_TYPE_PRECOMPUTE_INIT
7987 | OPTI_TYPE_PRECOMPUTE_MERKLE
7988 | OPTI_TYPE_EARLY_SKIP
7989 | OPTI_TYPE_NOT_ITERATED
7990 | OPTI_TYPE_PREPENDED_SALT
7991 | OPTI_TYPE_RAW_HASH;
7992 dgst_pos0 = 3;
7993 dgst_pos1 = 7;
7994 dgst_pos2 = 2;
7995 dgst_pos3 = 6;
7996 break;
7997
7998 case 1430: hash_type = HASH_TYPE_SHA256;
7999 salt_type = SALT_TYPE_INTERN;
8000 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8001 opts_type = OPTS_TYPE_PT_GENERATE_BE
8002 | OPTS_TYPE_PT_UNICODE
8003 | OPTS_TYPE_ST_ADD80
8004 | OPTS_TYPE_ST_ADDBITS15;
8005 kern_type = KERN_TYPE_SHA256_PWUSLT;
8006 dgst_size = DGST_SIZE_4_8;
8007 parse_func = sha256s_parse_hash;
8008 sort_by_digest = sort_by_digest_4_8;
8009 opti_type = OPTI_TYPE_ZERO_BYTE
8010 | OPTI_TYPE_PRECOMPUTE_INIT
8011 | OPTI_TYPE_PRECOMPUTE_MERKLE
8012 | OPTI_TYPE_EARLY_SKIP
8013 | OPTI_TYPE_NOT_ITERATED
8014 | OPTI_TYPE_APPENDED_SALT
8015 | OPTI_TYPE_RAW_HASH;
8016 dgst_pos0 = 3;
8017 dgst_pos1 = 7;
8018 dgst_pos2 = 2;
8019 dgst_pos3 = 6;
8020 break;
8021
8022 case 1440: hash_type = HASH_TYPE_SHA256;
8023 salt_type = SALT_TYPE_INTERN;
8024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8025 opts_type = OPTS_TYPE_PT_GENERATE_BE
8026 | OPTS_TYPE_PT_ADD80
8027 | OPTS_TYPE_PT_ADDBITS15
8028 | OPTS_TYPE_PT_UNICODE;
8029 kern_type = KERN_TYPE_SHA256_SLTPWU;
8030 dgst_size = DGST_SIZE_4_8;
8031 parse_func = sha256s_parse_hash;
8032 sort_by_digest = sort_by_digest_4_8;
8033 opti_type = OPTI_TYPE_ZERO_BYTE
8034 | OPTI_TYPE_PRECOMPUTE_INIT
8035 | OPTI_TYPE_PRECOMPUTE_MERKLE
8036 | OPTI_TYPE_EARLY_SKIP
8037 | OPTI_TYPE_NOT_ITERATED
8038 | OPTI_TYPE_PREPENDED_SALT
8039 | OPTI_TYPE_RAW_HASH;
8040 dgst_pos0 = 3;
8041 dgst_pos1 = 7;
8042 dgst_pos2 = 2;
8043 dgst_pos3 = 6;
8044 break;
8045
8046 case 1441: hash_type = HASH_TYPE_SHA256;
8047 salt_type = SALT_TYPE_EMBEDDED;
8048 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8049 opts_type = OPTS_TYPE_PT_GENERATE_BE
8050 | OPTS_TYPE_PT_ADD80
8051 | OPTS_TYPE_PT_ADDBITS15
8052 | OPTS_TYPE_PT_UNICODE
8053 | OPTS_TYPE_ST_BASE64;
8054 kern_type = KERN_TYPE_SHA256_SLTPWU;
8055 dgst_size = DGST_SIZE_4_8;
8056 parse_func = episerver4_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 1450: hash_type = HASH_TYPE_SHA256;
8072 salt_type = SALT_TYPE_INTERN;
8073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8074 opts_type = OPTS_TYPE_PT_GENERATE_BE
8075 | OPTS_TYPE_ST_ADD80;
8076 kern_type = KERN_TYPE_HMACSHA256_PW;
8077 dgst_size = DGST_SIZE_4_8;
8078 parse_func = hmacsha256_parse_hash;
8079 sort_by_digest = sort_by_digest_4_8;
8080 opti_type = OPTI_TYPE_ZERO_BYTE
8081 | OPTI_TYPE_NOT_ITERATED;
8082 dgst_pos0 = 3;
8083 dgst_pos1 = 7;
8084 dgst_pos2 = 2;
8085 dgst_pos3 = 6;
8086 break;
8087
8088 case 1460: hash_type = HASH_TYPE_SHA256;
8089 salt_type = SALT_TYPE_INTERN;
8090 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8091 opts_type = OPTS_TYPE_PT_GENERATE_BE
8092 | OPTS_TYPE_PT_ADD80
8093 | OPTS_TYPE_PT_ADDBITS15;
8094 kern_type = KERN_TYPE_HMACSHA256_SLT;
8095 dgst_size = DGST_SIZE_4_8;
8096 parse_func = hmacsha256_parse_hash;
8097 sort_by_digest = sort_by_digest_4_8;
8098 opti_type = OPTI_TYPE_ZERO_BYTE
8099 | OPTI_TYPE_NOT_ITERATED;
8100 dgst_pos0 = 3;
8101 dgst_pos1 = 7;
8102 dgst_pos2 = 2;
8103 dgst_pos3 = 6;
8104 break;
8105
8106 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8107 salt_type = SALT_TYPE_EMBEDDED;
8108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8109 opts_type = OPTS_TYPE_PT_GENERATE_LE
8110 | OPTS_TYPE_PT_BITSLICE;
8111 kern_type = KERN_TYPE_DESCRYPT;
8112 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8113 parse_func = descrypt_parse_hash;
8114 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8115 opti_type = OPTI_TYPE_ZERO_BYTE
8116 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8117 dgst_pos0 = 0;
8118 dgst_pos1 = 1;
8119 dgst_pos2 = 2;
8120 dgst_pos3 = 3;
8121 break;
8122
8123 case 1600: hash_type = HASH_TYPE_MD5;
8124 salt_type = SALT_TYPE_EMBEDDED;
8125 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8126 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8127 kern_type = KERN_TYPE_APR1CRYPT;
8128 dgst_size = DGST_SIZE_4_4;
8129 parse_func = md5apr1_parse_hash;
8130 sort_by_digest = sort_by_digest_4_4;
8131 opti_type = OPTI_TYPE_ZERO_BYTE;
8132 dgst_pos0 = 0;
8133 dgst_pos1 = 1;
8134 dgst_pos2 = 2;
8135 dgst_pos3 = 3;
8136 break;
8137
8138 case 1700: hash_type = HASH_TYPE_SHA512;
8139 salt_type = SALT_TYPE_NONE;
8140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8141 opts_type = OPTS_TYPE_PT_GENERATE_BE
8142 | OPTS_TYPE_PT_ADD80
8143 | OPTS_TYPE_PT_ADDBITS15;
8144 kern_type = KERN_TYPE_SHA512;
8145 dgst_size = DGST_SIZE_8_8;
8146 parse_func = sha512_parse_hash;
8147 sort_by_digest = sort_by_digest_8_8;
8148 opti_type = OPTI_TYPE_ZERO_BYTE
8149 | OPTI_TYPE_PRECOMPUTE_INIT
8150 | OPTI_TYPE_PRECOMPUTE_MERKLE
8151 | OPTI_TYPE_EARLY_SKIP
8152 | OPTI_TYPE_NOT_ITERATED
8153 | OPTI_TYPE_NOT_SALTED
8154 | OPTI_TYPE_USES_BITS_64
8155 | OPTI_TYPE_RAW_HASH;
8156 dgst_pos0 = 14;
8157 dgst_pos1 = 15;
8158 dgst_pos2 = 6;
8159 dgst_pos3 = 7;
8160 break;
8161
8162 case 1710: hash_type = HASH_TYPE_SHA512;
8163 salt_type = SALT_TYPE_INTERN;
8164 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8165 opts_type = OPTS_TYPE_PT_GENERATE_BE
8166 | OPTS_TYPE_ST_ADD80
8167 | OPTS_TYPE_ST_ADDBITS15;
8168 kern_type = KERN_TYPE_SHA512_PWSLT;
8169 dgst_size = DGST_SIZE_8_8;
8170 parse_func = sha512s_parse_hash;
8171 sort_by_digest = sort_by_digest_8_8;
8172 opti_type = OPTI_TYPE_ZERO_BYTE
8173 | OPTI_TYPE_PRECOMPUTE_INIT
8174 | OPTI_TYPE_PRECOMPUTE_MERKLE
8175 | OPTI_TYPE_EARLY_SKIP
8176 | OPTI_TYPE_NOT_ITERATED
8177 | OPTI_TYPE_APPENDED_SALT
8178 | OPTI_TYPE_USES_BITS_64
8179 | OPTI_TYPE_RAW_HASH;
8180 dgst_pos0 = 14;
8181 dgst_pos1 = 15;
8182 dgst_pos2 = 6;
8183 dgst_pos3 = 7;
8184 break;
8185
8186 case 1711: hash_type = HASH_TYPE_SHA512;
8187 salt_type = SALT_TYPE_EMBEDDED;
8188 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8189 opts_type = OPTS_TYPE_PT_GENERATE_BE
8190 | OPTS_TYPE_ST_ADD80
8191 | OPTS_TYPE_ST_ADDBITS15;
8192 kern_type = KERN_TYPE_SHA512_PWSLT;
8193 dgst_size = DGST_SIZE_8_8;
8194 parse_func = sha512b64s_parse_hash;
8195 sort_by_digest = sort_by_digest_8_8;
8196 opti_type = OPTI_TYPE_ZERO_BYTE
8197 | OPTI_TYPE_PRECOMPUTE_INIT
8198 | OPTI_TYPE_PRECOMPUTE_MERKLE
8199 | OPTI_TYPE_EARLY_SKIP
8200 | OPTI_TYPE_NOT_ITERATED
8201 | OPTI_TYPE_APPENDED_SALT
8202 | OPTI_TYPE_USES_BITS_64
8203 | OPTI_TYPE_RAW_HASH;
8204 dgst_pos0 = 14;
8205 dgst_pos1 = 15;
8206 dgst_pos2 = 6;
8207 dgst_pos3 = 7;
8208 break;
8209
8210 case 1720: hash_type = HASH_TYPE_SHA512;
8211 salt_type = SALT_TYPE_INTERN;
8212 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8213 opts_type = OPTS_TYPE_PT_GENERATE_BE
8214 | OPTS_TYPE_PT_ADD80
8215 | OPTS_TYPE_PT_ADDBITS15;
8216 kern_type = KERN_TYPE_SHA512_SLTPW;
8217 dgst_size = DGST_SIZE_8_8;
8218 parse_func = sha512s_parse_hash;
8219 sort_by_digest = sort_by_digest_8_8;
8220 opti_type = OPTI_TYPE_ZERO_BYTE
8221 | OPTI_TYPE_PRECOMPUTE_INIT
8222 | OPTI_TYPE_PRECOMPUTE_MERKLE
8223 | OPTI_TYPE_EARLY_SKIP
8224 | OPTI_TYPE_NOT_ITERATED
8225 | OPTI_TYPE_PREPENDED_SALT
8226 | OPTI_TYPE_USES_BITS_64
8227 | OPTI_TYPE_RAW_HASH;
8228 dgst_pos0 = 14;
8229 dgst_pos1 = 15;
8230 dgst_pos2 = 6;
8231 dgst_pos3 = 7;
8232 break;
8233
8234 case 1722: hash_type = HASH_TYPE_SHA512;
8235 salt_type = SALT_TYPE_EMBEDDED;
8236 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8237 opts_type = OPTS_TYPE_PT_GENERATE_BE
8238 | OPTS_TYPE_PT_ADD80
8239 | OPTS_TYPE_PT_ADDBITS15
8240 | OPTS_TYPE_ST_HEX;
8241 kern_type = KERN_TYPE_SHA512_SLTPW;
8242 dgst_size = DGST_SIZE_8_8;
8243 parse_func = osx512_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 1730: hash_type = HASH_TYPE_SHA512;
8260 salt_type = SALT_TYPE_INTERN;
8261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8262 opts_type = OPTS_TYPE_PT_GENERATE_BE
8263 | OPTS_TYPE_PT_UNICODE
8264 | OPTS_TYPE_ST_ADD80
8265 | OPTS_TYPE_ST_ADDBITS15;
8266 kern_type = KERN_TYPE_SHA512_PWSLTU;
8267 dgst_size = DGST_SIZE_8_8;
8268 parse_func = sha512s_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_APPENDED_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 1731: hash_type = HASH_TYPE_SHA512;
8285 salt_type = SALT_TYPE_EMBEDDED;
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 | OPTS_TYPE_ST_HEX;
8292 kern_type = KERN_TYPE_SHA512_PWSLTU;
8293 dgst_size = DGST_SIZE_8_8;
8294 parse_func = mssql2012_parse_hash;
8295 sort_by_digest = sort_by_digest_8_8;
8296 opti_type = OPTI_TYPE_ZERO_BYTE
8297 | OPTI_TYPE_PRECOMPUTE_INIT
8298 | OPTI_TYPE_PRECOMPUTE_MERKLE
8299 | OPTI_TYPE_EARLY_SKIP
8300 | OPTI_TYPE_NOT_ITERATED
8301 | OPTI_TYPE_APPENDED_SALT
8302 | OPTI_TYPE_USES_BITS_64
8303 | OPTI_TYPE_RAW_HASH;
8304 dgst_pos0 = 14;
8305 dgst_pos1 = 15;
8306 dgst_pos2 = 6;
8307 dgst_pos3 = 7;
8308 break;
8309
8310 case 1740: hash_type = HASH_TYPE_SHA512;
8311 salt_type = SALT_TYPE_INTERN;
8312 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8313 opts_type = OPTS_TYPE_PT_GENERATE_BE
8314 | OPTS_TYPE_PT_ADD80
8315 | OPTS_TYPE_PT_ADDBITS15
8316 | OPTS_TYPE_PT_UNICODE;
8317 kern_type = KERN_TYPE_SHA512_SLTPWU;
8318 dgst_size = DGST_SIZE_8_8;
8319 parse_func = sha512s_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_PREPENDED_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 1750: 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_ST_ADD80;
8340 kern_type = KERN_TYPE_HMACSHA512_PW;
8341 dgst_size = DGST_SIZE_8_8;
8342 parse_func = hmacsha512_parse_hash;
8343 sort_by_digest = sort_by_digest_8_8;
8344 opti_type = OPTI_TYPE_ZERO_BYTE
8345 | OPTI_TYPE_USES_BITS_64
8346 | OPTI_TYPE_NOT_ITERATED;
8347 dgst_pos0 = 14;
8348 dgst_pos1 = 15;
8349 dgst_pos2 = 6;
8350 dgst_pos3 = 7;
8351 break;
8352
8353 case 1760: hash_type = HASH_TYPE_SHA512;
8354 salt_type = SALT_TYPE_INTERN;
8355 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8356 opts_type = OPTS_TYPE_PT_GENERATE_BE
8357 | OPTS_TYPE_PT_ADD80
8358 | OPTS_TYPE_PT_ADDBITS15;
8359 kern_type = KERN_TYPE_HMACSHA512_SLT;
8360 dgst_size = DGST_SIZE_8_8;
8361 parse_func = hmacsha512_parse_hash;
8362 sort_by_digest = sort_by_digest_8_8;
8363 opti_type = OPTI_TYPE_ZERO_BYTE
8364 | OPTI_TYPE_USES_BITS_64
8365 | OPTI_TYPE_NOT_ITERATED;
8366 dgst_pos0 = 14;
8367 dgst_pos1 = 15;
8368 dgst_pos2 = 6;
8369 dgst_pos3 = 7;
8370 break;
8371
8372 case 1800: hash_type = HASH_TYPE_SHA512;
8373 salt_type = SALT_TYPE_EMBEDDED;
8374 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8375 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8376 kern_type = KERN_TYPE_SHA512CRYPT;
8377 dgst_size = DGST_SIZE_8_8;
8378 parse_func = sha512crypt_parse_hash;
8379 sort_by_digest = sort_by_digest_8_8;
8380 opti_type = OPTI_TYPE_ZERO_BYTE
8381 | OPTI_TYPE_USES_BITS_64;
8382 dgst_pos0 = 0;
8383 dgst_pos1 = 1;
8384 dgst_pos2 = 2;
8385 dgst_pos3 = 3;
8386 break;
8387
8388 case 2100: hash_type = HASH_TYPE_DCC2;
8389 salt_type = SALT_TYPE_EMBEDDED;
8390 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8391 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8392 | OPTS_TYPE_ST_LOWER
8393 | OPTS_TYPE_ST_UNICODE;
8394 kern_type = KERN_TYPE_DCC2;
8395 dgst_size = DGST_SIZE_4_4;
8396 parse_func = dcc2_parse_hash;
8397 sort_by_digest = sort_by_digest_4_4;
8398 opti_type = OPTI_TYPE_ZERO_BYTE
8399 | OPTI_TYPE_SLOW_HASH_SIMD;
8400 dgst_pos0 = 0;
8401 dgst_pos1 = 1;
8402 dgst_pos2 = 2;
8403 dgst_pos3 = 3;
8404 break;
8405
8406 case 2400: hash_type = HASH_TYPE_MD5;
8407 salt_type = SALT_TYPE_NONE;
8408 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8409 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8410 kern_type = KERN_TYPE_MD5PIX;
8411 dgst_size = DGST_SIZE_4_4;
8412 parse_func = md5pix_parse_hash;
8413 sort_by_digest = sort_by_digest_4_4;
8414 opti_type = OPTI_TYPE_ZERO_BYTE
8415 | OPTI_TYPE_PRECOMPUTE_INIT
8416 | OPTI_TYPE_PRECOMPUTE_MERKLE
8417 | OPTI_TYPE_EARLY_SKIP
8418 | OPTI_TYPE_NOT_ITERATED
8419 | OPTI_TYPE_NOT_SALTED;
8420 dgst_pos0 = 0;
8421 dgst_pos1 = 3;
8422 dgst_pos2 = 2;
8423 dgst_pos3 = 1;
8424 break;
8425
8426 case 2410: hash_type = HASH_TYPE_MD5;
8427 salt_type = SALT_TYPE_INTERN;
8428 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8429 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8430 kern_type = KERN_TYPE_MD5ASA;
8431 dgst_size = DGST_SIZE_4_4;
8432 parse_func = md5asa_parse_hash;
8433 sort_by_digest = sort_by_digest_4_4;
8434 opti_type = OPTI_TYPE_ZERO_BYTE
8435 | OPTI_TYPE_PRECOMPUTE_INIT
8436 | OPTI_TYPE_PRECOMPUTE_MERKLE
8437 | OPTI_TYPE_EARLY_SKIP
8438 | OPTI_TYPE_NOT_ITERATED;
8439 dgst_pos0 = 0;
8440 dgst_pos1 = 3;
8441 dgst_pos2 = 2;
8442 dgst_pos3 = 1;
8443 break;
8444
8445 case 2500: hash_type = HASH_TYPE_WPA;
8446 salt_type = SALT_TYPE_EMBEDDED;
8447 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8448 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8449 kern_type = KERN_TYPE_WPA;
8450 dgst_size = DGST_SIZE_4_4;
8451 parse_func = wpa_parse_hash;
8452 sort_by_digest = sort_by_digest_4_4;
8453 opti_type = OPTI_TYPE_ZERO_BYTE
8454 | OPTI_TYPE_SLOW_HASH_SIMD;
8455 dgst_pos0 = 0;
8456 dgst_pos1 = 1;
8457 dgst_pos2 = 2;
8458 dgst_pos3 = 3;
8459 break;
8460
8461 case 2600: hash_type = HASH_TYPE_MD5;
8462 salt_type = SALT_TYPE_VIRTUAL;
8463 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8464 opts_type = OPTS_TYPE_PT_GENERATE_LE
8465 | OPTS_TYPE_PT_ADD80
8466 | OPTS_TYPE_PT_ADDBITS14
8467 | OPTS_TYPE_ST_ADD80;
8468 kern_type = KERN_TYPE_MD55_PWSLT1;
8469 dgst_size = DGST_SIZE_4_4;
8470 parse_func = md5md5_parse_hash;
8471 sort_by_digest = sort_by_digest_4_4;
8472 opti_type = OPTI_TYPE_ZERO_BYTE
8473 | OPTI_TYPE_PRECOMPUTE_INIT
8474 | OPTI_TYPE_PRECOMPUTE_MERKLE
8475 | OPTI_TYPE_EARLY_SKIP;
8476 dgst_pos0 = 0;
8477 dgst_pos1 = 3;
8478 dgst_pos2 = 2;
8479 dgst_pos3 = 1;
8480 break;
8481
8482 case 2611: hash_type = HASH_TYPE_MD5;
8483 salt_type = SALT_TYPE_INTERN;
8484 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8485 opts_type = OPTS_TYPE_PT_GENERATE_LE
8486 | OPTS_TYPE_PT_ADD80
8487 | OPTS_TYPE_PT_ADDBITS14
8488 | OPTS_TYPE_ST_ADD80;
8489 kern_type = KERN_TYPE_MD55_PWSLT1;
8490 dgst_size = DGST_SIZE_4_4;
8491 parse_func = vb3_parse_hash;
8492 sort_by_digest = sort_by_digest_4_4;
8493 opti_type = OPTI_TYPE_ZERO_BYTE
8494 | OPTI_TYPE_PRECOMPUTE_INIT
8495 | OPTI_TYPE_PRECOMPUTE_MERKLE
8496 | OPTI_TYPE_EARLY_SKIP;
8497 dgst_pos0 = 0;
8498 dgst_pos1 = 3;
8499 dgst_pos2 = 2;
8500 dgst_pos3 = 1;
8501 break;
8502
8503 case 2612: hash_type = HASH_TYPE_MD5;
8504 salt_type = SALT_TYPE_EMBEDDED;
8505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8506 opts_type = OPTS_TYPE_PT_GENERATE_LE
8507 | OPTS_TYPE_PT_ADD80
8508 | OPTS_TYPE_PT_ADDBITS14
8509 | OPTS_TYPE_ST_ADD80
8510 | OPTS_TYPE_ST_HEX;
8511 kern_type = KERN_TYPE_MD55_PWSLT1;
8512 dgst_size = DGST_SIZE_4_4;
8513 parse_func = phps_parse_hash;
8514 sort_by_digest = sort_by_digest_4_4;
8515 opti_type = OPTI_TYPE_ZERO_BYTE
8516 | OPTI_TYPE_PRECOMPUTE_INIT
8517 | OPTI_TYPE_PRECOMPUTE_MERKLE
8518 | OPTI_TYPE_EARLY_SKIP;
8519 dgst_pos0 = 0;
8520 dgst_pos1 = 3;
8521 dgst_pos2 = 2;
8522 dgst_pos3 = 1;
8523 break;
8524
8525 case 2711: hash_type = HASH_TYPE_MD5;
8526 salt_type = SALT_TYPE_INTERN;
8527 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8528 opts_type = OPTS_TYPE_PT_GENERATE_LE
8529 | OPTS_TYPE_PT_ADD80
8530 | OPTS_TYPE_PT_ADDBITS14
8531 | OPTS_TYPE_ST_ADD80;
8532 kern_type = KERN_TYPE_MD55_PWSLT2;
8533 dgst_size = DGST_SIZE_4_4;
8534 parse_func = vb30_parse_hash;
8535 sort_by_digest = sort_by_digest_4_4;
8536 opti_type = OPTI_TYPE_ZERO_BYTE
8537 | OPTI_TYPE_PRECOMPUTE_INIT
8538 | OPTI_TYPE_EARLY_SKIP;
8539 dgst_pos0 = 0;
8540 dgst_pos1 = 3;
8541 dgst_pos2 = 2;
8542 dgst_pos3 = 1;
8543 break;
8544
8545 case 2811: hash_type = HASH_TYPE_MD5;
8546 salt_type = SALT_TYPE_INTERN;
8547 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8548 opts_type = OPTS_TYPE_PT_GENERATE_LE
8549 | OPTS_TYPE_PT_ADD80
8550 | OPTS_TYPE_PT_ADDBITS14;
8551 kern_type = KERN_TYPE_MD55_SLTPW;
8552 dgst_size = DGST_SIZE_4_4;
8553 parse_func = ipb2_parse_hash;
8554 sort_by_digest = sort_by_digest_4_4;
8555 opti_type = OPTI_TYPE_ZERO_BYTE
8556 | OPTI_TYPE_PRECOMPUTE_INIT
8557 | OPTI_TYPE_EARLY_SKIP;
8558 dgst_pos0 = 0;
8559 dgst_pos1 = 3;
8560 dgst_pos2 = 2;
8561 dgst_pos3 = 1;
8562 break;
8563
8564 case 3000: hash_type = HASH_TYPE_LM;
8565 salt_type = SALT_TYPE_NONE;
8566 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8567 opts_type = OPTS_TYPE_PT_GENERATE_LE
8568 | OPTS_TYPE_PT_UPPER
8569 | OPTS_TYPE_PT_BITSLICE;
8570 kern_type = KERN_TYPE_LM;
8571 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8572 parse_func = lm_parse_hash;
8573 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8574 opti_type = OPTI_TYPE_ZERO_BYTE
8575 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8576 dgst_pos0 = 0;
8577 dgst_pos1 = 1;
8578 dgst_pos2 = 2;
8579 dgst_pos3 = 3;
8580 break;
8581
8582 case 3100: hash_type = HASH_TYPE_ORACLEH;
8583 salt_type = SALT_TYPE_INTERN;
8584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8585 opts_type = OPTS_TYPE_PT_GENERATE_LE
8586 | OPTS_TYPE_PT_UPPER
8587 | OPTS_TYPE_ST_UPPER;
8588 kern_type = KERN_TYPE_ORACLEH;
8589 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8590 parse_func = oracleh_parse_hash;
8591 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8592 opti_type = OPTI_TYPE_ZERO_BYTE;
8593 dgst_pos0 = 0;
8594 dgst_pos1 = 1;
8595 dgst_pos2 = 2;
8596 dgst_pos3 = 3;
8597 break;
8598
8599 case 3200: hash_type = HASH_TYPE_BCRYPT;
8600 salt_type = SALT_TYPE_EMBEDDED;
8601 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8602 opts_type = OPTS_TYPE_PT_GENERATE_LE
8603 | OPTS_TYPE_ST_GENERATE_LE;
8604 kern_type = KERN_TYPE_BCRYPT;
8605 dgst_size = DGST_SIZE_4_6;
8606 parse_func = bcrypt_parse_hash;
8607 sort_by_digest = sort_by_digest_4_6;
8608 opti_type = OPTI_TYPE_ZERO_BYTE;
8609 dgst_pos0 = 0;
8610 dgst_pos1 = 1;
8611 dgst_pos2 = 2;
8612 dgst_pos3 = 3;
8613 break;
8614
8615 case 3710: hash_type = HASH_TYPE_MD5;
8616 salt_type = SALT_TYPE_INTERN;
8617 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8618 opts_type = OPTS_TYPE_PT_GENERATE_LE
8619 | OPTS_TYPE_PT_ADD80
8620 | OPTS_TYPE_PT_ADDBITS14;
8621 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8622 dgst_size = DGST_SIZE_4_4;
8623 parse_func = md5s_parse_hash;
8624 sort_by_digest = sort_by_digest_4_4;
8625 opti_type = OPTI_TYPE_ZERO_BYTE
8626 | OPTI_TYPE_PRECOMPUTE_INIT
8627 | OPTI_TYPE_PRECOMPUTE_MERKLE
8628 | OPTI_TYPE_EARLY_SKIP;
8629 dgst_pos0 = 0;
8630 dgst_pos1 = 3;
8631 dgst_pos2 = 2;
8632 dgst_pos3 = 1;
8633 break;
8634
8635 case 3711: hash_type = HASH_TYPE_MD5;
8636 salt_type = SALT_TYPE_EMBEDDED;
8637 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8638 opts_type = OPTS_TYPE_PT_GENERATE_LE
8639 | OPTS_TYPE_PT_ADD80
8640 | OPTS_TYPE_PT_ADDBITS14;
8641 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8642 dgst_size = DGST_SIZE_4_4;
8643 parse_func = mediawiki_b_parse_hash;
8644 sort_by_digest = sort_by_digest_4_4;
8645 opti_type = OPTI_TYPE_ZERO_BYTE
8646 | OPTI_TYPE_PRECOMPUTE_INIT
8647 | OPTI_TYPE_PRECOMPUTE_MERKLE
8648 | OPTI_TYPE_EARLY_SKIP;
8649 dgst_pos0 = 0;
8650 dgst_pos1 = 3;
8651 dgst_pos2 = 2;
8652 dgst_pos3 = 1;
8653 break;
8654
8655 case 3800: hash_type = HASH_TYPE_MD5;
8656 salt_type = SALT_TYPE_INTERN;
8657 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8658 opts_type = OPTS_TYPE_PT_GENERATE_LE
8659 | OPTS_TYPE_ST_ADDBITS14;
8660 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8661 dgst_size = DGST_SIZE_4_4;
8662 parse_func = md5s_parse_hash;
8663 sort_by_digest = sort_by_digest_4_4;
8664 opti_type = OPTI_TYPE_ZERO_BYTE
8665 | OPTI_TYPE_PRECOMPUTE_INIT
8666 | OPTI_TYPE_PRECOMPUTE_MERKLE
8667 | OPTI_TYPE_EARLY_SKIP
8668 | OPTI_TYPE_NOT_ITERATED
8669 | OPTI_TYPE_RAW_HASH;
8670 dgst_pos0 = 0;
8671 dgst_pos1 = 3;
8672 dgst_pos2 = 2;
8673 dgst_pos3 = 1;
8674 break;
8675
8676 case 4300: hash_type = HASH_TYPE_MD5;
8677 salt_type = SALT_TYPE_VIRTUAL;
8678 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8679 opts_type = OPTS_TYPE_PT_GENERATE_LE
8680 | OPTS_TYPE_PT_ADD80
8681 | OPTS_TYPE_PT_ADDBITS14
8682 | OPTS_TYPE_ST_ADD80;
8683 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8684 dgst_size = DGST_SIZE_4_4;
8685 parse_func = md5md5_parse_hash;
8686 sort_by_digest = sort_by_digest_4_4;
8687 opti_type = OPTI_TYPE_ZERO_BYTE
8688 | OPTI_TYPE_PRECOMPUTE_INIT
8689 | OPTI_TYPE_PRECOMPUTE_MERKLE
8690 | OPTI_TYPE_EARLY_SKIP;
8691 dgst_pos0 = 0;
8692 dgst_pos1 = 3;
8693 dgst_pos2 = 2;
8694 dgst_pos3 = 1;
8695 break;
8696
8697
8698 case 4400: hash_type = HASH_TYPE_MD5;
8699 salt_type = SALT_TYPE_NONE;
8700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8701 opts_type = OPTS_TYPE_PT_GENERATE_BE
8702 | OPTS_TYPE_PT_ADD80
8703 | OPTS_TYPE_PT_ADDBITS15;
8704 kern_type = KERN_TYPE_MD5_SHA1;
8705 dgst_size = DGST_SIZE_4_4;
8706 parse_func = md5_parse_hash;
8707 sort_by_digest = sort_by_digest_4_4;
8708 opti_type = OPTI_TYPE_ZERO_BYTE
8709 | OPTI_TYPE_PRECOMPUTE_INIT
8710 | OPTI_TYPE_PRECOMPUTE_MERKLE
8711 | OPTI_TYPE_EARLY_SKIP
8712 | OPTI_TYPE_NOT_ITERATED
8713 | OPTI_TYPE_NOT_SALTED
8714 | OPTI_TYPE_RAW_HASH;
8715 dgst_pos0 = 0;
8716 dgst_pos1 = 3;
8717 dgst_pos2 = 2;
8718 dgst_pos3 = 1;
8719 break;
8720
8721 case 4500: hash_type = HASH_TYPE_SHA1;
8722 salt_type = SALT_TYPE_NONE;
8723 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8724 opts_type = OPTS_TYPE_PT_GENERATE_BE
8725 | OPTS_TYPE_PT_ADD80
8726 | OPTS_TYPE_PT_ADDBITS15;
8727 kern_type = KERN_TYPE_SHA11;
8728 dgst_size = DGST_SIZE_4_5;
8729 parse_func = sha1_parse_hash;
8730 sort_by_digest = sort_by_digest_4_5;
8731 opti_type = OPTI_TYPE_ZERO_BYTE
8732 | OPTI_TYPE_PRECOMPUTE_INIT
8733 | OPTI_TYPE_PRECOMPUTE_MERKLE
8734 | OPTI_TYPE_EARLY_SKIP
8735 | OPTI_TYPE_NOT_SALTED;
8736 dgst_pos0 = 3;
8737 dgst_pos1 = 4;
8738 dgst_pos2 = 2;
8739 dgst_pos3 = 1;
8740 break;
8741
8742 case 4700: hash_type = HASH_TYPE_SHA1;
8743 salt_type = SALT_TYPE_NONE;
8744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8745 opts_type = OPTS_TYPE_PT_GENERATE_LE
8746 | OPTS_TYPE_PT_ADD80
8747 | OPTS_TYPE_PT_ADDBITS14;
8748 kern_type = KERN_TYPE_SHA1_MD5;
8749 dgst_size = DGST_SIZE_4_5;
8750 parse_func = sha1_parse_hash;
8751 sort_by_digest = sort_by_digest_4_5;
8752 opti_type = OPTI_TYPE_ZERO_BYTE
8753 | OPTI_TYPE_PRECOMPUTE_INIT
8754 | OPTI_TYPE_PRECOMPUTE_MERKLE
8755 | OPTI_TYPE_EARLY_SKIP
8756 | OPTI_TYPE_NOT_ITERATED
8757 | OPTI_TYPE_NOT_SALTED
8758 | OPTI_TYPE_RAW_HASH;
8759 dgst_pos0 = 3;
8760 dgst_pos1 = 4;
8761 dgst_pos2 = 2;
8762 dgst_pos3 = 1;
8763 break;
8764
8765 case 4800: hash_type = HASH_TYPE_MD5;
8766 salt_type = SALT_TYPE_EMBEDDED;
8767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8768 opts_type = OPTS_TYPE_PT_GENERATE_LE
8769 | OPTS_TYPE_PT_ADDBITS14;
8770 kern_type = KERN_TYPE_MD5_CHAP;
8771 dgst_size = DGST_SIZE_4_4;
8772 parse_func = chap_parse_hash;
8773 sort_by_digest = sort_by_digest_4_4;
8774 opti_type = OPTI_TYPE_ZERO_BYTE
8775 | OPTI_TYPE_PRECOMPUTE_INIT
8776 | OPTI_TYPE_PRECOMPUTE_MERKLE
8777 | OPTI_TYPE_MEET_IN_MIDDLE
8778 | OPTI_TYPE_EARLY_SKIP
8779 | OPTI_TYPE_NOT_ITERATED
8780 | OPTI_TYPE_RAW_HASH;
8781 dgst_pos0 = 0;
8782 dgst_pos1 = 3;
8783 dgst_pos2 = 2;
8784 dgst_pos3 = 1;
8785 break;
8786
8787 case 4900: hash_type = HASH_TYPE_SHA1;
8788 salt_type = SALT_TYPE_INTERN;
8789 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8790 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8791 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8792 dgst_size = DGST_SIZE_4_5;
8793 parse_func = sha1s_parse_hash;
8794 sort_by_digest = sort_by_digest_4_5;
8795 opti_type = OPTI_TYPE_ZERO_BYTE
8796 | OPTI_TYPE_PRECOMPUTE_INIT
8797 | OPTI_TYPE_PRECOMPUTE_MERKLE
8798 | OPTI_TYPE_EARLY_SKIP;
8799 dgst_pos0 = 3;
8800 dgst_pos1 = 4;
8801 dgst_pos2 = 2;
8802 dgst_pos3 = 1;
8803 break;
8804
8805 case 5000: hash_type = HASH_TYPE_KECCAK;
8806 salt_type = SALT_TYPE_EMBEDDED;
8807 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8808 opts_type = OPTS_TYPE_PT_GENERATE_LE
8809 | OPTS_TYPE_PT_ADD01;
8810 kern_type = KERN_TYPE_KECCAK;
8811 dgst_size = DGST_SIZE_8_25;
8812 parse_func = keccak_parse_hash;
8813 sort_by_digest = sort_by_digest_8_25;
8814 opti_type = OPTI_TYPE_ZERO_BYTE
8815 | OPTI_TYPE_USES_BITS_64
8816 | OPTI_TYPE_RAW_HASH;
8817 dgst_pos0 = 2;
8818 dgst_pos1 = 3;
8819 dgst_pos2 = 4;
8820 dgst_pos3 = 5;
8821 break;
8822
8823 case 5100: hash_type = HASH_TYPE_MD5H;
8824 salt_type = SALT_TYPE_NONE;
8825 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8826 opts_type = OPTS_TYPE_PT_GENERATE_LE
8827 | OPTS_TYPE_PT_ADD80
8828 | OPTS_TYPE_PT_ADDBITS14;
8829 kern_type = KERN_TYPE_MD5H;
8830 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8831 parse_func = md5half_parse_hash;
8832 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8833 opti_type = OPTI_TYPE_ZERO_BYTE
8834 | OPTI_TYPE_RAW_HASH;
8835 dgst_pos0 = 0;
8836 dgst_pos1 = 1;
8837 dgst_pos2 = 2;
8838 dgst_pos3 = 3;
8839 break;
8840
8841 case 5200: hash_type = HASH_TYPE_SHA256;
8842 salt_type = SALT_TYPE_EMBEDDED;
8843 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8844 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8845 kern_type = KERN_TYPE_PSAFE3;
8846 dgst_size = DGST_SIZE_4_8;
8847 parse_func = psafe3_parse_hash;
8848 sort_by_digest = sort_by_digest_4_8;
8849 opti_type = OPTI_TYPE_ZERO_BYTE;
8850 dgst_pos0 = 0;
8851 dgst_pos1 = 1;
8852 dgst_pos2 = 2;
8853 dgst_pos3 = 3;
8854 break;
8855
8856 case 5300: hash_type = HASH_TYPE_MD5;
8857 salt_type = SALT_TYPE_EMBEDDED;
8858 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8859 opts_type = OPTS_TYPE_PT_GENERATE_LE
8860 | OPTS_TYPE_ST_ADD80;
8861 kern_type = KERN_TYPE_IKEPSK_MD5;
8862 dgst_size = DGST_SIZE_4_4;
8863 parse_func = ikepsk_md5_parse_hash;
8864 sort_by_digest = sort_by_digest_4_4;
8865 opti_type = OPTI_TYPE_ZERO_BYTE;
8866 dgst_pos0 = 0;
8867 dgst_pos1 = 3;
8868 dgst_pos2 = 2;
8869 dgst_pos3 = 1;
8870 break;
8871
8872 case 5400: hash_type = HASH_TYPE_SHA1;
8873 salt_type = SALT_TYPE_EMBEDDED;
8874 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8875 opts_type = OPTS_TYPE_PT_GENERATE_BE
8876 | OPTS_TYPE_ST_ADD80;
8877 kern_type = KERN_TYPE_IKEPSK_SHA1;
8878 dgst_size = DGST_SIZE_4_5;
8879 parse_func = ikepsk_sha1_parse_hash;
8880 sort_by_digest = sort_by_digest_4_5;
8881 opti_type = OPTI_TYPE_ZERO_BYTE;
8882 dgst_pos0 = 3;
8883 dgst_pos1 = 4;
8884 dgst_pos2 = 2;
8885 dgst_pos3 = 1;
8886 break;
8887
8888 case 5500: hash_type = HASH_TYPE_NETNTLM;
8889 salt_type = SALT_TYPE_EMBEDDED;
8890 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8891 opts_type = OPTS_TYPE_PT_GENERATE_LE
8892 | OPTS_TYPE_PT_ADD80
8893 | OPTS_TYPE_PT_ADDBITS14
8894 | OPTS_TYPE_PT_UNICODE
8895 | OPTS_TYPE_ST_HEX;
8896 kern_type = KERN_TYPE_NETNTLMv1;
8897 dgst_size = DGST_SIZE_4_4;
8898 parse_func = netntlmv1_parse_hash;
8899 sort_by_digest = sort_by_digest_4_4;
8900 opti_type = OPTI_TYPE_ZERO_BYTE
8901 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8902 dgst_pos0 = 0;
8903 dgst_pos1 = 1;
8904 dgst_pos2 = 2;
8905 dgst_pos3 = 3;
8906 break;
8907
8908 case 5600: hash_type = HASH_TYPE_MD5;
8909 salt_type = SALT_TYPE_EMBEDDED;
8910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8911 opts_type = OPTS_TYPE_PT_GENERATE_LE
8912 | OPTS_TYPE_PT_ADD80
8913 | OPTS_TYPE_PT_ADDBITS14
8914 | OPTS_TYPE_PT_UNICODE;
8915 kern_type = KERN_TYPE_NETNTLMv2;
8916 dgst_size = DGST_SIZE_4_4;
8917 parse_func = netntlmv2_parse_hash;
8918 sort_by_digest = sort_by_digest_4_4;
8919 opti_type = OPTI_TYPE_ZERO_BYTE;
8920 dgst_pos0 = 0;
8921 dgst_pos1 = 3;
8922 dgst_pos2 = 2;
8923 dgst_pos3 = 1;
8924 break;
8925
8926 case 5700: hash_type = HASH_TYPE_SHA256;
8927 salt_type = SALT_TYPE_NONE;
8928 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8929 opts_type = OPTS_TYPE_PT_GENERATE_BE
8930 | OPTS_TYPE_PT_ADD80
8931 | OPTS_TYPE_PT_ADDBITS15;
8932 kern_type = KERN_TYPE_SHA256;
8933 dgst_size = DGST_SIZE_4_8;
8934 parse_func = cisco4_parse_hash;
8935 sort_by_digest = sort_by_digest_4_8;
8936 opti_type = OPTI_TYPE_ZERO_BYTE
8937 | OPTI_TYPE_PRECOMPUTE_INIT
8938 | OPTI_TYPE_PRECOMPUTE_MERKLE
8939 | OPTI_TYPE_EARLY_SKIP
8940 | OPTI_TYPE_NOT_ITERATED
8941 | OPTI_TYPE_NOT_SALTED
8942 | OPTI_TYPE_RAW_HASH;
8943 dgst_pos0 = 3;
8944 dgst_pos1 = 7;
8945 dgst_pos2 = 2;
8946 dgst_pos3 = 6;
8947 break;
8948
8949 case 5800: hash_type = HASH_TYPE_SHA1;
8950 salt_type = SALT_TYPE_INTERN;
8951 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8952 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8953 | OPTS_TYPE_ST_ADD80;
8954 kern_type = KERN_TYPE_ANDROIDPIN;
8955 dgst_size = DGST_SIZE_4_5;
8956 parse_func = androidpin_parse_hash;
8957 sort_by_digest = sort_by_digest_4_5;
8958 opti_type = OPTI_TYPE_ZERO_BYTE;
8959 dgst_pos0 = 0;
8960 dgst_pos1 = 1;
8961 dgst_pos2 = 2;
8962 dgst_pos3 = 3;
8963 break;
8964
8965 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8966 salt_type = SALT_TYPE_NONE;
8967 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8968 opts_type = OPTS_TYPE_PT_GENERATE_LE
8969 | OPTS_TYPE_PT_ADD80;
8970 kern_type = KERN_TYPE_RIPEMD160;
8971 dgst_size = DGST_SIZE_4_5;
8972 parse_func = ripemd160_parse_hash;
8973 sort_by_digest = sort_by_digest_4_5;
8974 opti_type = OPTI_TYPE_ZERO_BYTE;
8975 dgst_pos0 = 0;
8976 dgst_pos1 = 1;
8977 dgst_pos2 = 2;
8978 dgst_pos3 = 3;
8979 break;
8980
8981 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8982 salt_type = SALT_TYPE_NONE;
8983 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8984 opts_type = OPTS_TYPE_PT_GENERATE_BE
8985 | OPTS_TYPE_PT_ADD80;
8986 kern_type = KERN_TYPE_WHIRLPOOL;
8987 dgst_size = DGST_SIZE_4_16;
8988 parse_func = whirlpool_parse_hash;
8989 sort_by_digest = sort_by_digest_4_16;
8990 opti_type = OPTI_TYPE_ZERO_BYTE;
8991 dgst_pos0 = 0;
8992 dgst_pos1 = 1;
8993 dgst_pos2 = 2;
8994 dgst_pos3 = 3;
8995 break;
8996
8997 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8998 salt_type = SALT_TYPE_EMBEDDED;
8999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9000 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9001 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9002 dgst_size = DGST_SIZE_4_5;
9003 parse_func = truecrypt_parse_hash_2k;
9004 sort_by_digest = sort_by_digest_4_5;
9005 opti_type = OPTI_TYPE_ZERO_BYTE;
9006 dgst_pos0 = 0;
9007 dgst_pos1 = 1;
9008 dgst_pos2 = 2;
9009 dgst_pos3 = 3;
9010 break;
9011
9012 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9013 salt_type = SALT_TYPE_EMBEDDED;
9014 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9015 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9016 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9017 dgst_size = DGST_SIZE_4_5;
9018 parse_func = truecrypt_parse_hash_2k;
9019 sort_by_digest = sort_by_digest_4_5;
9020 opti_type = OPTI_TYPE_ZERO_BYTE;
9021 dgst_pos0 = 0;
9022 dgst_pos1 = 1;
9023 dgst_pos2 = 2;
9024 dgst_pos3 = 3;
9025 break;
9026
9027 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9028 salt_type = SALT_TYPE_EMBEDDED;
9029 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9030 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9031 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9032 dgst_size = DGST_SIZE_4_5;
9033 parse_func = truecrypt_parse_hash_2k;
9034 sort_by_digest = sort_by_digest_4_5;
9035 opti_type = OPTI_TYPE_ZERO_BYTE;
9036 dgst_pos0 = 0;
9037 dgst_pos1 = 1;
9038 dgst_pos2 = 2;
9039 dgst_pos3 = 3;
9040 break;
9041
9042 case 6221: hash_type = HASH_TYPE_SHA512;
9043 salt_type = SALT_TYPE_EMBEDDED;
9044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9045 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9046 kern_type = KERN_TYPE_TCSHA512_XTS512;
9047 dgst_size = DGST_SIZE_8_8;
9048 parse_func = truecrypt_parse_hash_1k;
9049 sort_by_digest = sort_by_digest_8_8;
9050 opti_type = OPTI_TYPE_ZERO_BYTE
9051 | OPTI_TYPE_USES_BITS_64;
9052 dgst_pos0 = 0;
9053 dgst_pos1 = 1;
9054 dgst_pos2 = 2;
9055 dgst_pos3 = 3;
9056 break;
9057
9058 case 6222: hash_type = HASH_TYPE_SHA512;
9059 salt_type = SALT_TYPE_EMBEDDED;
9060 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9061 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9062 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9063 dgst_size = DGST_SIZE_8_8;
9064 parse_func = truecrypt_parse_hash_1k;
9065 sort_by_digest = sort_by_digest_8_8;
9066 opti_type = OPTI_TYPE_ZERO_BYTE
9067 | OPTI_TYPE_USES_BITS_64;
9068 dgst_pos0 = 0;
9069 dgst_pos1 = 1;
9070 dgst_pos2 = 2;
9071 dgst_pos3 = 3;
9072 break;
9073
9074 case 6223: hash_type = HASH_TYPE_SHA512;
9075 salt_type = SALT_TYPE_EMBEDDED;
9076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9077 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9078 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9079 dgst_size = DGST_SIZE_8_8;
9080 parse_func = truecrypt_parse_hash_1k;
9081 sort_by_digest = sort_by_digest_8_8;
9082 opti_type = OPTI_TYPE_ZERO_BYTE
9083 | OPTI_TYPE_USES_BITS_64;
9084 dgst_pos0 = 0;
9085 dgst_pos1 = 1;
9086 dgst_pos2 = 2;
9087 dgst_pos3 = 3;
9088 break;
9089
9090 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9091 salt_type = SALT_TYPE_EMBEDDED;
9092 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9093 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9094 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9095 dgst_size = DGST_SIZE_4_8;
9096 parse_func = truecrypt_parse_hash_1k;
9097 sort_by_digest = sort_by_digest_4_8;
9098 opti_type = OPTI_TYPE_ZERO_BYTE;
9099 dgst_pos0 = 0;
9100 dgst_pos1 = 1;
9101 dgst_pos2 = 2;
9102 dgst_pos3 = 3;
9103 break;
9104
9105 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9106 salt_type = SALT_TYPE_EMBEDDED;
9107 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9108 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9109 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9110 dgst_size = DGST_SIZE_4_8;
9111 parse_func = truecrypt_parse_hash_1k;
9112 sort_by_digest = sort_by_digest_4_8;
9113 opti_type = OPTI_TYPE_ZERO_BYTE;
9114 dgst_pos0 = 0;
9115 dgst_pos1 = 1;
9116 dgst_pos2 = 2;
9117 dgst_pos3 = 3;
9118 break;
9119
9120 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9121 salt_type = SALT_TYPE_EMBEDDED;
9122 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9123 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9124 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9125 dgst_size = DGST_SIZE_4_8;
9126 parse_func = truecrypt_parse_hash_1k;
9127 sort_by_digest = sort_by_digest_4_8;
9128 opti_type = OPTI_TYPE_ZERO_BYTE;
9129 dgst_pos0 = 0;
9130 dgst_pos1 = 1;
9131 dgst_pos2 = 2;
9132 dgst_pos3 = 3;
9133 break;
9134
9135 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9136 salt_type = SALT_TYPE_EMBEDDED;
9137 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9138 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9139 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9140 dgst_size = DGST_SIZE_4_5;
9141 parse_func = truecrypt_parse_hash_1k;
9142 sort_by_digest = sort_by_digest_4_5;
9143 opti_type = OPTI_TYPE_ZERO_BYTE;
9144 dgst_pos0 = 0;
9145 dgst_pos1 = 1;
9146 dgst_pos2 = 2;
9147 dgst_pos3 = 3;
9148 break;
9149
9150 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9151 salt_type = SALT_TYPE_EMBEDDED;
9152 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9153 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9154 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9155 dgst_size = DGST_SIZE_4_5;
9156 parse_func = truecrypt_parse_hash_1k;
9157 sort_by_digest = sort_by_digest_4_5;
9158 opti_type = OPTI_TYPE_ZERO_BYTE;
9159 dgst_pos0 = 0;
9160 dgst_pos1 = 1;
9161 dgst_pos2 = 2;
9162 dgst_pos3 = 3;
9163 break;
9164
9165 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9166 salt_type = SALT_TYPE_EMBEDDED;
9167 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9168 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9169 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9170 dgst_size = DGST_SIZE_4_5;
9171 parse_func = truecrypt_parse_hash_1k;
9172 sort_by_digest = sort_by_digest_4_5;
9173 opti_type = OPTI_TYPE_ZERO_BYTE;
9174 dgst_pos0 = 0;
9175 dgst_pos1 = 1;
9176 dgst_pos2 = 2;
9177 dgst_pos3 = 3;
9178 break;
9179
9180 case 6300: hash_type = HASH_TYPE_MD5;
9181 salt_type = SALT_TYPE_EMBEDDED;
9182 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9183 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9184 kern_type = KERN_TYPE_MD5AIX;
9185 dgst_size = DGST_SIZE_4_4;
9186 parse_func = md5aix_parse_hash;
9187 sort_by_digest = sort_by_digest_4_4;
9188 opti_type = OPTI_TYPE_ZERO_BYTE;
9189 dgst_pos0 = 0;
9190 dgst_pos1 = 1;
9191 dgst_pos2 = 2;
9192 dgst_pos3 = 3;
9193 break;
9194
9195 case 6400: hash_type = HASH_TYPE_SHA256;
9196 salt_type = SALT_TYPE_EMBEDDED;
9197 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9198 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9199 kern_type = KERN_TYPE_SHA256AIX;
9200 dgst_size = DGST_SIZE_4_8;
9201 parse_func = sha256aix_parse_hash;
9202 sort_by_digest = sort_by_digest_4_8;
9203 opti_type = OPTI_TYPE_ZERO_BYTE;
9204 dgst_pos0 = 0;
9205 dgst_pos1 = 1;
9206 dgst_pos2 = 2;
9207 dgst_pos3 = 3;
9208 break;
9209
9210 case 6500: hash_type = HASH_TYPE_SHA512;
9211 salt_type = SALT_TYPE_EMBEDDED;
9212 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9213 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9214 kern_type = KERN_TYPE_SHA512AIX;
9215 dgst_size = DGST_SIZE_8_8;
9216 parse_func = sha512aix_parse_hash;
9217 sort_by_digest = sort_by_digest_8_8;
9218 opti_type = OPTI_TYPE_ZERO_BYTE
9219 | OPTI_TYPE_USES_BITS_64;
9220 dgst_pos0 = 0;
9221 dgst_pos1 = 1;
9222 dgst_pos2 = 2;
9223 dgst_pos3 = 3;
9224 break;
9225
9226 case 6600: hash_type = HASH_TYPE_AES;
9227 salt_type = SALT_TYPE_EMBEDDED;
9228 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9229 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9230 kern_type = KERN_TYPE_AGILEKEY;
9231 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9232 parse_func = agilekey_parse_hash;
9233 sort_by_digest = sort_by_digest_4_5;
9234 opti_type = OPTI_TYPE_ZERO_BYTE;
9235 dgst_pos0 = 0;
9236 dgst_pos1 = 1;
9237 dgst_pos2 = 2;
9238 dgst_pos3 = 3;
9239 break;
9240
9241 case 6700: hash_type = HASH_TYPE_SHA1;
9242 salt_type = SALT_TYPE_EMBEDDED;
9243 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9244 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9245 kern_type = KERN_TYPE_SHA1AIX;
9246 dgst_size = DGST_SIZE_4_5;
9247 parse_func = sha1aix_parse_hash;
9248 sort_by_digest = sort_by_digest_4_5;
9249 opti_type = OPTI_TYPE_ZERO_BYTE;
9250 dgst_pos0 = 0;
9251 dgst_pos1 = 1;
9252 dgst_pos2 = 2;
9253 dgst_pos3 = 3;
9254 break;
9255
9256 case 6800: hash_type = HASH_TYPE_AES;
9257 salt_type = SALT_TYPE_EMBEDDED;
9258 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9259 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9260 kern_type = KERN_TYPE_LASTPASS;
9261 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9262 parse_func = lastpass_parse_hash;
9263 sort_by_digest = sort_by_digest_4_8;
9264 opti_type = OPTI_TYPE_ZERO_BYTE;
9265 dgst_pos0 = 0;
9266 dgst_pos1 = 1;
9267 dgst_pos2 = 2;
9268 dgst_pos3 = 3;
9269 break;
9270
9271 case 6900: hash_type = HASH_TYPE_GOST;
9272 salt_type = SALT_TYPE_NONE;
9273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9274 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9275 kern_type = KERN_TYPE_GOST;
9276 dgst_size = DGST_SIZE_4_8;
9277 parse_func = gost_parse_hash;
9278 sort_by_digest = sort_by_digest_4_8;
9279 opti_type = OPTI_TYPE_ZERO_BYTE;
9280 dgst_pos0 = 0;
9281 dgst_pos1 = 1;
9282 dgst_pos2 = 2;
9283 dgst_pos3 = 3;
9284 break;
9285
9286 case 7100: hash_type = HASH_TYPE_SHA512;
9287 salt_type = SALT_TYPE_EMBEDDED;
9288 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9289 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9290 kern_type = KERN_TYPE_PBKDF2_SHA512;
9291 dgst_size = DGST_SIZE_8_16;
9292 parse_func = sha512osx_parse_hash;
9293 sort_by_digest = sort_by_digest_8_16;
9294 opti_type = OPTI_TYPE_ZERO_BYTE
9295 | OPTI_TYPE_USES_BITS_64
9296 | OPTI_TYPE_SLOW_HASH_SIMD;
9297 dgst_pos0 = 0;
9298 dgst_pos1 = 1;
9299 dgst_pos2 = 2;
9300 dgst_pos3 = 3;
9301 break;
9302
9303 case 7200: hash_type = HASH_TYPE_SHA512;
9304 salt_type = SALT_TYPE_EMBEDDED;
9305 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9306 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9307 kern_type = KERN_TYPE_PBKDF2_SHA512;
9308 dgst_size = DGST_SIZE_8_16;
9309 parse_func = sha512grub_parse_hash;
9310 sort_by_digest = sort_by_digest_8_16;
9311 opti_type = OPTI_TYPE_ZERO_BYTE
9312 | OPTI_TYPE_USES_BITS_64
9313 | OPTI_TYPE_SLOW_HASH_SIMD;
9314 dgst_pos0 = 0;
9315 dgst_pos1 = 1;
9316 dgst_pos2 = 2;
9317 dgst_pos3 = 3;
9318 break;
9319
9320 case 7300: hash_type = HASH_TYPE_SHA1;
9321 salt_type = SALT_TYPE_EMBEDDED;
9322 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9323 opts_type = OPTS_TYPE_PT_GENERATE_BE
9324 | OPTS_TYPE_ST_ADD80
9325 | OPTS_TYPE_ST_ADDBITS15;
9326 kern_type = KERN_TYPE_RAKP;
9327 dgst_size = DGST_SIZE_4_5;
9328 parse_func = rakp_parse_hash;
9329 sort_by_digest = sort_by_digest_4_5;
9330 opti_type = OPTI_TYPE_ZERO_BYTE
9331 | OPTI_TYPE_NOT_ITERATED;
9332 dgst_pos0 = 3;
9333 dgst_pos1 = 4;
9334 dgst_pos2 = 2;
9335 dgst_pos3 = 1;
9336 break;
9337
9338 case 7400: hash_type = HASH_TYPE_SHA256;
9339 salt_type = SALT_TYPE_EMBEDDED;
9340 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9341 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9342 kern_type = KERN_TYPE_SHA256CRYPT;
9343 dgst_size = DGST_SIZE_4_8;
9344 parse_func = sha256crypt_parse_hash;
9345 sort_by_digest = sort_by_digest_4_8;
9346 opti_type = OPTI_TYPE_ZERO_BYTE;
9347 dgst_pos0 = 0;
9348 dgst_pos1 = 1;
9349 dgst_pos2 = 2;
9350 dgst_pos3 = 3;
9351 break;
9352
9353 case 7500: hash_type = HASH_TYPE_KRB5PA;
9354 salt_type = SALT_TYPE_EMBEDDED;
9355 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9356 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9357 kern_type = KERN_TYPE_KRB5PA;
9358 dgst_size = DGST_SIZE_4_4;
9359 parse_func = krb5pa_parse_hash;
9360 sort_by_digest = sort_by_digest_4_4;
9361 opti_type = OPTI_TYPE_ZERO_BYTE
9362 | OPTI_TYPE_NOT_ITERATED;
9363 dgst_pos0 = 0;
9364 dgst_pos1 = 1;
9365 dgst_pos2 = 2;
9366 dgst_pos3 = 3;
9367 break;
9368
9369 case 7600: hash_type = HASH_TYPE_SHA1;
9370 salt_type = SALT_TYPE_INTERN;
9371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9372 opts_type = OPTS_TYPE_PT_GENERATE_BE
9373 | OPTS_TYPE_PT_ADD80
9374 | OPTS_TYPE_PT_ADDBITS15;
9375 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9376 dgst_size = DGST_SIZE_4_5;
9377 parse_func = redmine_parse_hash;
9378 sort_by_digest = sort_by_digest_4_5;
9379 opti_type = OPTI_TYPE_ZERO_BYTE
9380 | OPTI_TYPE_PRECOMPUTE_INIT
9381 | OPTI_TYPE_EARLY_SKIP
9382 | OPTI_TYPE_NOT_ITERATED
9383 | OPTI_TYPE_PREPENDED_SALT;
9384 dgst_pos0 = 3;
9385 dgst_pos1 = 4;
9386 dgst_pos2 = 2;
9387 dgst_pos3 = 1;
9388 break;
9389
9390 case 7700: hash_type = HASH_TYPE_SAPB;
9391 salt_type = SALT_TYPE_EMBEDDED;
9392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9393 opts_type = OPTS_TYPE_PT_GENERATE_LE
9394 | OPTS_TYPE_PT_UPPER
9395 | OPTS_TYPE_ST_UPPER;
9396 kern_type = KERN_TYPE_SAPB;
9397 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9398 parse_func = sapb_parse_hash;
9399 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9400 opti_type = OPTI_TYPE_ZERO_BYTE
9401 | OPTI_TYPE_PRECOMPUTE_INIT
9402 | OPTI_TYPE_NOT_ITERATED;
9403 dgst_pos0 = 0;
9404 dgst_pos1 = 1;
9405 dgst_pos2 = 2;
9406 dgst_pos3 = 3;
9407 break;
9408
9409 case 7800: hash_type = HASH_TYPE_SAPG;
9410 salt_type = SALT_TYPE_EMBEDDED;
9411 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9412 opts_type = OPTS_TYPE_PT_GENERATE_BE
9413 | OPTS_TYPE_ST_ADD80
9414 | OPTS_TYPE_ST_UPPER;
9415 kern_type = KERN_TYPE_SAPG;
9416 dgst_size = DGST_SIZE_4_5;
9417 parse_func = sapg_parse_hash;
9418 sort_by_digest = sort_by_digest_4_5;
9419 opti_type = OPTI_TYPE_ZERO_BYTE
9420 | OPTI_TYPE_PRECOMPUTE_INIT
9421 | OPTI_TYPE_NOT_ITERATED;
9422 dgst_pos0 = 3;
9423 dgst_pos1 = 4;
9424 dgst_pos2 = 2;
9425 dgst_pos3 = 1;
9426 break;
9427
9428 case 7900: hash_type = HASH_TYPE_SHA512;
9429 salt_type = SALT_TYPE_EMBEDDED;
9430 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9431 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9432 kern_type = KERN_TYPE_DRUPAL7;
9433 dgst_size = DGST_SIZE_8_8;
9434 parse_func = drupal7_parse_hash;
9435 sort_by_digest = sort_by_digest_8_8;
9436 opti_type = OPTI_TYPE_ZERO_BYTE
9437 | OPTI_TYPE_USES_BITS_64;
9438 dgst_pos0 = 0;
9439 dgst_pos1 = 1;
9440 dgst_pos2 = 2;
9441 dgst_pos3 = 3;
9442 break;
9443
9444 case 8000: hash_type = HASH_TYPE_SHA256;
9445 salt_type = SALT_TYPE_EMBEDDED;
9446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9447 opts_type = OPTS_TYPE_PT_GENERATE_BE
9448 | OPTS_TYPE_PT_UNICODE
9449 | OPTS_TYPE_ST_ADD80
9450 | OPTS_TYPE_ST_HEX;
9451 kern_type = KERN_TYPE_SYBASEASE;
9452 dgst_size = DGST_SIZE_4_8;
9453 parse_func = sybasease_parse_hash;
9454 sort_by_digest = sort_by_digest_4_8;
9455 opti_type = OPTI_TYPE_ZERO_BYTE
9456 | OPTI_TYPE_PRECOMPUTE_INIT
9457 | OPTI_TYPE_EARLY_SKIP
9458 | OPTI_TYPE_NOT_ITERATED
9459 | OPTI_TYPE_RAW_HASH;
9460 dgst_pos0 = 3;
9461 dgst_pos1 = 7;
9462 dgst_pos2 = 2;
9463 dgst_pos3 = 6;
9464 break;
9465
9466 case 8100: hash_type = HASH_TYPE_SHA1;
9467 salt_type = SALT_TYPE_EMBEDDED;
9468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9469 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9470 kern_type = KERN_TYPE_NETSCALER;
9471 dgst_size = DGST_SIZE_4_5;
9472 parse_func = netscaler_parse_hash;
9473 sort_by_digest = sort_by_digest_4_5;
9474 opti_type = OPTI_TYPE_ZERO_BYTE
9475 | OPTI_TYPE_PRECOMPUTE_INIT
9476 | OPTI_TYPE_PRECOMPUTE_MERKLE
9477 | OPTI_TYPE_EARLY_SKIP
9478 | OPTI_TYPE_NOT_ITERATED
9479 | OPTI_TYPE_PREPENDED_SALT
9480 | OPTI_TYPE_RAW_HASH;
9481 dgst_pos0 = 3;
9482 dgst_pos1 = 4;
9483 dgst_pos2 = 2;
9484 dgst_pos3 = 1;
9485 break;
9486
9487 case 8200: hash_type = HASH_TYPE_SHA256;
9488 salt_type = SALT_TYPE_EMBEDDED;
9489 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9490 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9491 kern_type = KERN_TYPE_CLOUDKEY;
9492 dgst_size = DGST_SIZE_4_8;
9493 parse_func = cloudkey_parse_hash;
9494 sort_by_digest = sort_by_digest_4_8;
9495 opti_type = OPTI_TYPE_ZERO_BYTE;
9496 dgst_pos0 = 0;
9497 dgst_pos1 = 1;
9498 dgst_pos2 = 2;
9499 dgst_pos3 = 3;
9500 break;
9501
9502 case 8300: hash_type = HASH_TYPE_SHA1;
9503 salt_type = SALT_TYPE_EMBEDDED;
9504 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9505 opts_type = OPTS_TYPE_PT_GENERATE_BE
9506 | OPTS_TYPE_ST_HEX
9507 | OPTS_TYPE_ST_ADD80;
9508 kern_type = KERN_TYPE_NSEC3;
9509 dgst_size = DGST_SIZE_4_5;
9510 parse_func = nsec3_parse_hash;
9511 sort_by_digest = sort_by_digest_4_5;
9512 opti_type = OPTI_TYPE_ZERO_BYTE;
9513 dgst_pos0 = 3;
9514 dgst_pos1 = 4;
9515 dgst_pos2 = 2;
9516 dgst_pos3 = 1;
9517 break;
9518
9519 case 8400: hash_type = HASH_TYPE_SHA1;
9520 salt_type = SALT_TYPE_INTERN;
9521 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9522 opts_type = OPTS_TYPE_PT_GENERATE_BE
9523 | OPTS_TYPE_PT_ADD80
9524 | OPTS_TYPE_PT_ADDBITS15;
9525 kern_type = KERN_TYPE_WBB3;
9526 dgst_size = DGST_SIZE_4_5;
9527 parse_func = wbb3_parse_hash;
9528 sort_by_digest = sort_by_digest_4_5;
9529 opti_type = OPTI_TYPE_ZERO_BYTE
9530 | OPTI_TYPE_PRECOMPUTE_INIT
9531 | OPTI_TYPE_NOT_ITERATED;
9532 dgst_pos0 = 3;
9533 dgst_pos1 = 4;
9534 dgst_pos2 = 2;
9535 dgst_pos3 = 1;
9536 break;
9537
9538 case 8500: hash_type = HASH_TYPE_DESRACF;
9539 salt_type = SALT_TYPE_EMBEDDED;
9540 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9541 opts_type = OPTS_TYPE_PT_GENERATE_LE
9542 | OPTS_TYPE_ST_UPPER;
9543 kern_type = KERN_TYPE_RACF;
9544 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9545 parse_func = racf_parse_hash;
9546 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9547 opti_type = OPTI_TYPE_ZERO_BYTE
9548 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9549 dgst_pos0 = 0;
9550 dgst_pos1 = 1;
9551 dgst_pos2 = 2;
9552 dgst_pos3 = 3;
9553 break;
9554
9555 case 8600: hash_type = HASH_TYPE_LOTUS5;
9556 salt_type = SALT_TYPE_NONE;
9557 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9558 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9559 kern_type = KERN_TYPE_LOTUS5;
9560 dgst_size = DGST_SIZE_4_4;
9561 parse_func = lotus5_parse_hash;
9562 sort_by_digest = sort_by_digest_4_4;
9563 opti_type = OPTI_TYPE_EARLY_SKIP
9564 | OPTI_TYPE_NOT_ITERATED
9565 | OPTI_TYPE_NOT_SALTED
9566 | OPTI_TYPE_RAW_HASH;
9567 dgst_pos0 = 0;
9568 dgst_pos1 = 1;
9569 dgst_pos2 = 2;
9570 dgst_pos3 = 3;
9571 break;
9572
9573 case 8700: hash_type = HASH_TYPE_LOTUS6;
9574 salt_type = SALT_TYPE_EMBEDDED;
9575 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9576 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9577 kern_type = KERN_TYPE_LOTUS6;
9578 dgst_size = DGST_SIZE_4_4;
9579 parse_func = lotus6_parse_hash;
9580 sort_by_digest = sort_by_digest_4_4;
9581 opti_type = OPTI_TYPE_EARLY_SKIP
9582 | OPTI_TYPE_NOT_ITERATED
9583 | OPTI_TYPE_RAW_HASH;
9584 dgst_pos0 = 0;
9585 dgst_pos1 = 1;
9586 dgst_pos2 = 2;
9587 dgst_pos3 = 3;
9588 break;
9589
9590 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9591 salt_type = SALT_TYPE_EMBEDDED;
9592 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9593 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9594 kern_type = KERN_TYPE_ANDROIDFDE;
9595 dgst_size = DGST_SIZE_4_4;
9596 parse_func = androidfde_parse_hash;
9597 sort_by_digest = sort_by_digest_4_4;
9598 opti_type = OPTI_TYPE_ZERO_BYTE;
9599 dgst_pos0 = 0;
9600 dgst_pos1 = 1;
9601 dgst_pos2 = 2;
9602 dgst_pos3 = 3;
9603 break;
9604
9605 case 8900: hash_type = HASH_TYPE_SCRYPT;
9606 salt_type = SALT_TYPE_EMBEDDED;
9607 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9608 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9609 kern_type = KERN_TYPE_SCRYPT;
9610 dgst_size = DGST_SIZE_4_8;
9611 parse_func = scrypt_parse_hash;
9612 sort_by_digest = sort_by_digest_4_8;
9613 opti_type = OPTI_TYPE_ZERO_BYTE;
9614 dgst_pos0 = 0;
9615 dgst_pos1 = 1;
9616 dgst_pos2 = 2;
9617 dgst_pos3 = 3;
9618 break;
9619
9620 case 9000: hash_type = HASH_TYPE_SHA1;
9621 salt_type = SALT_TYPE_EMBEDDED;
9622 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9623 opts_type = OPTS_TYPE_PT_GENERATE_LE
9624 | OPTS_TYPE_ST_GENERATE_LE;
9625 kern_type = KERN_TYPE_PSAFE2;
9626 dgst_size = DGST_SIZE_4_5;
9627 parse_func = psafe2_parse_hash;
9628 sort_by_digest = sort_by_digest_4_5;
9629 opti_type = OPTI_TYPE_ZERO_BYTE;
9630 dgst_pos0 = 0;
9631 dgst_pos1 = 1;
9632 dgst_pos2 = 2;
9633 dgst_pos3 = 3;
9634 break;
9635
9636 case 9100: hash_type = HASH_TYPE_LOTUS8;
9637 salt_type = SALT_TYPE_EMBEDDED;
9638 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9639 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9640 kern_type = KERN_TYPE_LOTUS8;
9641 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9642 parse_func = lotus8_parse_hash;
9643 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9644 opti_type = OPTI_TYPE_ZERO_BYTE;
9645 dgst_pos0 = 0;
9646 dgst_pos1 = 1;
9647 dgst_pos2 = 2;
9648 dgst_pos3 = 3;
9649 break;
9650
9651 case 9200: hash_type = HASH_TYPE_SHA256;
9652 salt_type = SALT_TYPE_EMBEDDED;
9653 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9654 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9655 kern_type = KERN_TYPE_PBKDF2_SHA256;
9656 dgst_size = DGST_SIZE_4_32;
9657 parse_func = cisco8_parse_hash;
9658 sort_by_digest = sort_by_digest_4_32;
9659 opti_type = OPTI_TYPE_ZERO_BYTE
9660 | OPTI_TYPE_SLOW_HASH_SIMD;
9661 dgst_pos0 = 0;
9662 dgst_pos1 = 1;
9663 dgst_pos2 = 2;
9664 dgst_pos3 = 3;
9665 break;
9666
9667 case 9300: hash_type = HASH_TYPE_SCRYPT;
9668 salt_type = SALT_TYPE_EMBEDDED;
9669 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9670 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9671 kern_type = KERN_TYPE_SCRYPT;
9672 dgst_size = DGST_SIZE_4_8;
9673 parse_func = cisco9_parse_hash;
9674 sort_by_digest = sort_by_digest_4_8;
9675 opti_type = OPTI_TYPE_ZERO_BYTE;
9676 dgst_pos0 = 0;
9677 dgst_pos1 = 1;
9678 dgst_pos2 = 2;
9679 dgst_pos3 = 3;
9680 break;
9681
9682 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9683 salt_type = SALT_TYPE_EMBEDDED;
9684 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9685 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9686 kern_type = KERN_TYPE_OFFICE2007;
9687 dgst_size = DGST_SIZE_4_4;
9688 parse_func = office2007_parse_hash;
9689 sort_by_digest = sort_by_digest_4_4;
9690 opti_type = OPTI_TYPE_ZERO_BYTE;
9691 dgst_pos0 = 0;
9692 dgst_pos1 = 1;
9693 dgst_pos2 = 2;
9694 dgst_pos3 = 3;
9695 break;
9696
9697 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9698 salt_type = SALT_TYPE_EMBEDDED;
9699 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9700 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9701 kern_type = KERN_TYPE_OFFICE2010;
9702 dgst_size = DGST_SIZE_4_4;
9703 parse_func = office2010_parse_hash;
9704 sort_by_digest = sort_by_digest_4_4;
9705 opti_type = OPTI_TYPE_ZERO_BYTE;
9706 dgst_pos0 = 0;
9707 dgst_pos1 = 1;
9708 dgst_pos2 = 2;
9709 dgst_pos3 = 3;
9710 break;
9711
9712 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9713 salt_type = SALT_TYPE_EMBEDDED;
9714 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9715 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9716 kern_type = KERN_TYPE_OFFICE2013;
9717 dgst_size = DGST_SIZE_4_4;
9718 parse_func = office2013_parse_hash;
9719 sort_by_digest = sort_by_digest_4_4;
9720 opti_type = OPTI_TYPE_ZERO_BYTE;
9721 dgst_pos0 = 0;
9722 dgst_pos1 = 1;
9723 dgst_pos2 = 2;
9724 dgst_pos3 = 3;
9725 break;
9726
9727 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9728 salt_type = SALT_TYPE_EMBEDDED;
9729 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9730 opts_type = OPTS_TYPE_PT_GENERATE_LE
9731 | OPTS_TYPE_PT_ADD80
9732 | OPTS_TYPE_PT_UNICODE;
9733 kern_type = KERN_TYPE_OLDOFFICE01;
9734 dgst_size = DGST_SIZE_4_4;
9735 parse_func = oldoffice01_parse_hash;
9736 sort_by_digest = sort_by_digest_4_4;
9737 opti_type = OPTI_TYPE_ZERO_BYTE
9738 | OPTI_TYPE_PRECOMPUTE_INIT
9739 | OPTI_TYPE_NOT_ITERATED;
9740 dgst_pos0 = 0;
9741 dgst_pos1 = 1;
9742 dgst_pos2 = 2;
9743 dgst_pos3 = 3;
9744 break;
9745
9746 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9747 salt_type = SALT_TYPE_EMBEDDED;
9748 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9749 opts_type = OPTS_TYPE_PT_GENERATE_LE
9750 | OPTS_TYPE_PT_ADD80;
9751 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9752 dgst_size = DGST_SIZE_4_4;
9753 parse_func = oldoffice01cm1_parse_hash;
9754 sort_by_digest = sort_by_digest_4_4;
9755 opti_type = OPTI_TYPE_ZERO_BYTE
9756 | OPTI_TYPE_PRECOMPUTE_INIT
9757 | OPTI_TYPE_NOT_ITERATED;
9758 dgst_pos0 = 0;
9759 dgst_pos1 = 1;
9760 dgst_pos2 = 2;
9761 dgst_pos3 = 3;
9762 break;
9763
9764 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9765 salt_type = SALT_TYPE_EMBEDDED;
9766 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9767 opts_type = OPTS_TYPE_PT_GENERATE_LE
9768 | OPTS_TYPE_PT_ADD80
9769 | OPTS_TYPE_PT_UNICODE
9770 | OPTS_TYPE_PT_NEVERCRACK;
9771 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9772 dgst_size = DGST_SIZE_4_4;
9773 parse_func = oldoffice01cm2_parse_hash;
9774 sort_by_digest = sort_by_digest_4_4;
9775 opti_type = OPTI_TYPE_ZERO_BYTE
9776 | OPTI_TYPE_PRECOMPUTE_INIT
9777 | OPTI_TYPE_NOT_ITERATED;
9778 dgst_pos0 = 0;
9779 dgst_pos1 = 1;
9780 dgst_pos2 = 2;
9781 dgst_pos3 = 3;
9782 break;
9783
9784 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9785 salt_type = SALT_TYPE_EMBEDDED;
9786 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9787 opts_type = OPTS_TYPE_PT_GENERATE_BE
9788 | OPTS_TYPE_PT_ADD80
9789 | OPTS_TYPE_PT_UNICODE;
9790 kern_type = KERN_TYPE_OLDOFFICE34;
9791 dgst_size = DGST_SIZE_4_4;
9792 parse_func = oldoffice34_parse_hash;
9793 sort_by_digest = sort_by_digest_4_4;
9794 opti_type = OPTI_TYPE_ZERO_BYTE
9795 | OPTI_TYPE_PRECOMPUTE_INIT
9796 | OPTI_TYPE_NOT_ITERATED;
9797 dgst_pos0 = 0;
9798 dgst_pos1 = 1;
9799 dgst_pos2 = 2;
9800 dgst_pos3 = 3;
9801 break;
9802
9803 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9804 salt_type = SALT_TYPE_EMBEDDED;
9805 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9806 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9807 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9808 dgst_size = DGST_SIZE_4_4;
9809 parse_func = oldoffice34cm1_parse_hash;
9810 sort_by_digest = sort_by_digest_4_4;
9811 opti_type = OPTI_TYPE_ZERO_BYTE
9812 | OPTI_TYPE_PRECOMPUTE_INIT
9813 | OPTI_TYPE_NOT_ITERATED;
9814 dgst_pos0 = 0;
9815 dgst_pos1 = 1;
9816 dgst_pos2 = 2;
9817 dgst_pos3 = 3;
9818 break;
9819
9820 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9821 salt_type = SALT_TYPE_EMBEDDED;
9822 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9823 opts_type = OPTS_TYPE_PT_GENERATE_BE
9824 | OPTS_TYPE_PT_ADD80
9825 | OPTS_TYPE_PT_UNICODE
9826 | OPTS_TYPE_PT_NEVERCRACK;
9827 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9828 dgst_size = DGST_SIZE_4_4;
9829 parse_func = oldoffice34cm2_parse_hash;
9830 sort_by_digest = sort_by_digest_4_4;
9831 opti_type = OPTI_TYPE_ZERO_BYTE
9832 | OPTI_TYPE_PRECOMPUTE_INIT
9833 | OPTI_TYPE_NOT_ITERATED;
9834 dgst_pos0 = 0;
9835 dgst_pos1 = 1;
9836 dgst_pos2 = 2;
9837 dgst_pos3 = 3;
9838 break;
9839
9840 case 9900: hash_type = HASH_TYPE_MD5;
9841 salt_type = SALT_TYPE_NONE;
9842 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9843 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9844 kern_type = KERN_TYPE_RADMIN2;
9845 dgst_size = DGST_SIZE_4_4;
9846 parse_func = radmin2_parse_hash;
9847 sort_by_digest = sort_by_digest_4_4;
9848 opti_type = OPTI_TYPE_ZERO_BYTE
9849 | OPTI_TYPE_PRECOMPUTE_INIT
9850 | OPTI_TYPE_EARLY_SKIP
9851 | OPTI_TYPE_NOT_ITERATED
9852 | OPTI_TYPE_NOT_SALTED;
9853 dgst_pos0 = 0;
9854 dgst_pos1 = 3;
9855 dgst_pos2 = 2;
9856 dgst_pos3 = 1;
9857 break;
9858
9859 case 10000: hash_type = HASH_TYPE_SHA256;
9860 salt_type = SALT_TYPE_EMBEDDED;
9861 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9862 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9863 kern_type = KERN_TYPE_PBKDF2_SHA256;
9864 dgst_size = DGST_SIZE_4_32;
9865 parse_func = djangopbkdf2_parse_hash;
9866 sort_by_digest = sort_by_digest_4_32;
9867 opti_type = OPTI_TYPE_ZERO_BYTE
9868 | OPTI_TYPE_SLOW_HASH_SIMD;
9869 dgst_pos0 = 0;
9870 dgst_pos1 = 1;
9871 dgst_pos2 = 2;
9872 dgst_pos3 = 3;
9873 break;
9874
9875 case 10100: hash_type = HASH_TYPE_SIPHASH;
9876 salt_type = SALT_TYPE_EMBEDDED;
9877 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9878 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9879 kern_type = KERN_TYPE_SIPHASH;
9880 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9881 parse_func = siphash_parse_hash;
9882 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9883 opti_type = OPTI_TYPE_ZERO_BYTE
9884 | OPTI_TYPE_NOT_ITERATED
9885 | OPTI_TYPE_RAW_HASH;
9886 dgst_pos0 = 0;
9887 dgst_pos1 = 1;
9888 dgst_pos2 = 2;
9889 dgst_pos3 = 3;
9890 break;
9891
9892 case 10200: hash_type = HASH_TYPE_MD5;
9893 salt_type = SALT_TYPE_EMBEDDED;
9894 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9895 opts_type = OPTS_TYPE_PT_GENERATE_LE
9896 | OPTS_TYPE_ST_ADD80
9897 | OPTS_TYPE_ST_ADDBITS14;
9898 kern_type = KERN_TYPE_HMACMD5_PW;
9899 dgst_size = DGST_SIZE_4_4;
9900 parse_func = crammd5_parse_hash;
9901 sort_by_digest = sort_by_digest_4_4;
9902 opti_type = OPTI_TYPE_ZERO_BYTE
9903 | OPTI_TYPE_NOT_ITERATED;
9904 dgst_pos0 = 0;
9905 dgst_pos1 = 3;
9906 dgst_pos2 = 2;
9907 dgst_pos3 = 1;
9908 break;
9909
9910 case 10300: hash_type = HASH_TYPE_SHA1;
9911 salt_type = SALT_TYPE_EMBEDDED;
9912 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9913 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9914 kern_type = KERN_TYPE_SAPH_SHA1;
9915 dgst_size = DGST_SIZE_4_5;
9916 parse_func = saph_sha1_parse_hash;
9917 sort_by_digest = sort_by_digest_4_5;
9918 opti_type = OPTI_TYPE_ZERO_BYTE;
9919 dgst_pos0 = 0;
9920 dgst_pos1 = 1;
9921 dgst_pos2 = 2;
9922 dgst_pos3 = 3;
9923 break;
9924
9925 case 10400: hash_type = HASH_TYPE_PDFU16;
9926 salt_type = SALT_TYPE_EMBEDDED;
9927 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9928 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9929 kern_type = KERN_TYPE_PDF11;
9930 dgst_size = DGST_SIZE_4_4;
9931 parse_func = pdf11_parse_hash;
9932 sort_by_digest = sort_by_digest_4_4;
9933 opti_type = OPTI_TYPE_ZERO_BYTE
9934 | OPTI_TYPE_NOT_ITERATED;
9935 dgst_pos0 = 0;
9936 dgst_pos1 = 1;
9937 dgst_pos2 = 2;
9938 dgst_pos3 = 3;
9939 break;
9940
9941 case 10410: hash_type = HASH_TYPE_PDFU16;
9942 salt_type = SALT_TYPE_EMBEDDED;
9943 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9944 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9945 kern_type = KERN_TYPE_PDF11CM1;
9946 dgst_size = DGST_SIZE_4_4;
9947 parse_func = pdf11cm1_parse_hash;
9948 sort_by_digest = sort_by_digest_4_4;
9949 opti_type = OPTI_TYPE_ZERO_BYTE
9950 | OPTI_TYPE_NOT_ITERATED;
9951 dgst_pos0 = 0;
9952 dgst_pos1 = 1;
9953 dgst_pos2 = 2;
9954 dgst_pos3 = 3;
9955 break;
9956
9957 case 10420: hash_type = HASH_TYPE_PDFU16;
9958 salt_type = SALT_TYPE_EMBEDDED;
9959 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9960 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9961 kern_type = KERN_TYPE_PDF11CM2;
9962 dgst_size = DGST_SIZE_4_4;
9963 parse_func = pdf11cm2_parse_hash;
9964 sort_by_digest = sort_by_digest_4_4;
9965 opti_type = OPTI_TYPE_ZERO_BYTE
9966 | OPTI_TYPE_NOT_ITERATED;
9967 dgst_pos0 = 0;
9968 dgst_pos1 = 1;
9969 dgst_pos2 = 2;
9970 dgst_pos3 = 3;
9971 break;
9972
9973 case 10500: hash_type = HASH_TYPE_PDFU16;
9974 salt_type = SALT_TYPE_EMBEDDED;
9975 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9976 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9977 kern_type = KERN_TYPE_PDF14;
9978 dgst_size = DGST_SIZE_4_4;
9979 parse_func = pdf14_parse_hash;
9980 sort_by_digest = sort_by_digest_4_4;
9981 opti_type = OPTI_TYPE_ZERO_BYTE
9982 | OPTI_TYPE_NOT_ITERATED;
9983 dgst_pos0 = 0;
9984 dgst_pos1 = 1;
9985 dgst_pos2 = 2;
9986 dgst_pos3 = 3;
9987 break;
9988
9989 case 10600: hash_type = HASH_TYPE_SHA256;
9990 salt_type = SALT_TYPE_EMBEDDED;
9991 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9992 opts_type = OPTS_TYPE_PT_GENERATE_BE
9993 | OPTS_TYPE_ST_ADD80
9994 | OPTS_TYPE_ST_ADDBITS15
9995 | OPTS_TYPE_HASH_COPY;
9996 kern_type = KERN_TYPE_SHA256_PWSLT;
9997 dgst_size = DGST_SIZE_4_8;
9998 parse_func = pdf17l3_parse_hash;
9999 sort_by_digest = sort_by_digest_4_8;
10000 opti_type = OPTI_TYPE_ZERO_BYTE
10001 | OPTI_TYPE_PRECOMPUTE_INIT
10002 | OPTI_TYPE_PRECOMPUTE_MERKLE
10003 | OPTI_TYPE_EARLY_SKIP
10004 | OPTI_TYPE_NOT_ITERATED
10005 | OPTI_TYPE_APPENDED_SALT
10006 | OPTI_TYPE_RAW_HASH;
10007 dgst_pos0 = 3;
10008 dgst_pos1 = 7;
10009 dgst_pos2 = 2;
10010 dgst_pos3 = 6;
10011 break;
10012
10013 case 10700: hash_type = HASH_TYPE_PDFU32;
10014 salt_type = SALT_TYPE_EMBEDDED;
10015 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10016 opts_type = OPTS_TYPE_PT_GENERATE_LE
10017 | OPTS_TYPE_HASH_COPY;
10018 kern_type = KERN_TYPE_PDF17L8;
10019 dgst_size = DGST_SIZE_4_8;
10020 parse_func = pdf17l8_parse_hash;
10021 sort_by_digest = sort_by_digest_4_8;
10022 opti_type = OPTI_TYPE_ZERO_BYTE
10023 | OPTI_TYPE_NOT_ITERATED;
10024 dgst_pos0 = 0;
10025 dgst_pos1 = 1;
10026 dgst_pos2 = 2;
10027 dgst_pos3 = 3;
10028 break;
10029
10030 case 10800: hash_type = HASH_TYPE_SHA384;
10031 salt_type = SALT_TYPE_NONE;
10032 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10033 opts_type = OPTS_TYPE_PT_GENERATE_BE
10034 | OPTS_TYPE_PT_ADD80
10035 | OPTS_TYPE_PT_ADDBITS15;
10036 kern_type = KERN_TYPE_SHA384;
10037 dgst_size = DGST_SIZE_8_8;
10038 parse_func = sha384_parse_hash;
10039 sort_by_digest = sort_by_digest_8_8;
10040 opti_type = OPTI_TYPE_ZERO_BYTE
10041 | OPTI_TYPE_PRECOMPUTE_INIT
10042 | OPTI_TYPE_PRECOMPUTE_MERKLE
10043 | OPTI_TYPE_EARLY_SKIP
10044 | OPTI_TYPE_NOT_ITERATED
10045 | OPTI_TYPE_NOT_SALTED
10046 | OPTI_TYPE_USES_BITS_64
10047 | OPTI_TYPE_RAW_HASH;
10048 dgst_pos0 = 6;
10049 dgst_pos1 = 7;
10050 dgst_pos2 = 4;
10051 dgst_pos3 = 5;
10052 break;
10053
10054 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10055 salt_type = SALT_TYPE_EMBEDDED;
10056 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10057 opts_type = OPTS_TYPE_PT_GENERATE_LE
10058 | OPTS_TYPE_ST_BASE64
10059 | OPTS_TYPE_HASH_COPY;
10060 kern_type = KERN_TYPE_PBKDF2_SHA256;
10061 dgst_size = DGST_SIZE_4_32;
10062 parse_func = pbkdf2_sha256_parse_hash;
10063 sort_by_digest = sort_by_digest_4_32;
10064 opti_type = OPTI_TYPE_ZERO_BYTE
10065 | OPTI_TYPE_SLOW_HASH_SIMD;
10066 dgst_pos0 = 0;
10067 dgst_pos1 = 1;
10068 dgst_pos2 = 2;
10069 dgst_pos3 = 3;
10070 break;
10071
10072 case 11000: hash_type = HASH_TYPE_MD5;
10073 salt_type = SALT_TYPE_INTERN;
10074 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10075 opts_type = OPTS_TYPE_PT_GENERATE_LE
10076 | OPTS_TYPE_PT_ADD80;
10077 kern_type = KERN_TYPE_PRESTASHOP;
10078 dgst_size = DGST_SIZE_4_4;
10079 parse_func = prestashop_parse_hash;
10080 sort_by_digest = sort_by_digest_4_4;
10081 opti_type = OPTI_TYPE_ZERO_BYTE
10082 | OPTI_TYPE_PRECOMPUTE_INIT
10083 | OPTI_TYPE_NOT_ITERATED
10084 | OPTI_TYPE_PREPENDED_SALT;
10085 dgst_pos0 = 0;
10086 dgst_pos1 = 3;
10087 dgst_pos2 = 2;
10088 dgst_pos3 = 1;
10089 break;
10090
10091 case 11100: hash_type = HASH_TYPE_MD5;
10092 salt_type = SALT_TYPE_EMBEDDED;
10093 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10094 opts_type = OPTS_TYPE_PT_GENERATE_LE
10095 | OPTS_TYPE_ST_ADD80;
10096 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10097 dgst_size = DGST_SIZE_4_4;
10098 parse_func = postgresql_auth_parse_hash;
10099 sort_by_digest = sort_by_digest_4_4;
10100 opti_type = OPTI_TYPE_ZERO_BYTE
10101 | OPTI_TYPE_PRECOMPUTE_INIT
10102 | OPTI_TYPE_PRECOMPUTE_MERKLE
10103 | OPTI_TYPE_EARLY_SKIP;
10104 dgst_pos0 = 0;
10105 dgst_pos1 = 3;
10106 dgst_pos2 = 2;
10107 dgst_pos3 = 1;
10108 break;
10109
10110 case 11200: hash_type = HASH_TYPE_SHA1;
10111 salt_type = SALT_TYPE_EMBEDDED;
10112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10113 opts_type = OPTS_TYPE_PT_GENERATE_BE
10114 | OPTS_TYPE_PT_ADD80
10115 | OPTS_TYPE_ST_HEX;
10116 kern_type = KERN_TYPE_MYSQL_AUTH;
10117 dgst_size = DGST_SIZE_4_5;
10118 parse_func = mysql_auth_parse_hash;
10119 sort_by_digest = sort_by_digest_4_5;
10120 opti_type = OPTI_TYPE_ZERO_BYTE
10121 | OPTI_TYPE_EARLY_SKIP;
10122 dgst_pos0 = 3;
10123 dgst_pos1 = 4;
10124 dgst_pos2 = 2;
10125 dgst_pos3 = 1;
10126 break;
10127
10128 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10129 salt_type = SALT_TYPE_EMBEDDED;
10130 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10131 opts_type = OPTS_TYPE_PT_GENERATE_LE
10132 | OPTS_TYPE_ST_HEX
10133 | OPTS_TYPE_ST_ADD80;
10134 kern_type = KERN_TYPE_BITCOIN_WALLET;
10135 dgst_size = DGST_SIZE_4_4;
10136 parse_func = bitcoin_wallet_parse_hash;
10137 sort_by_digest = sort_by_digest_4_4;
10138 opti_type = OPTI_TYPE_ZERO_BYTE;
10139 dgst_pos0 = 0;
10140 dgst_pos1 = 1;
10141 dgst_pos2 = 2;
10142 dgst_pos3 = 3;
10143 break;
10144
10145 case 11400: hash_type = HASH_TYPE_MD5;
10146 salt_type = SALT_TYPE_EMBEDDED;
10147 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10148 opts_type = OPTS_TYPE_PT_GENERATE_LE
10149 | OPTS_TYPE_PT_ADD80
10150 | OPTS_TYPE_HASH_COPY;
10151 kern_type = KERN_TYPE_SIP_AUTH;
10152 dgst_size = DGST_SIZE_4_4;
10153 parse_func = sip_auth_parse_hash;
10154 sort_by_digest = sort_by_digest_4_4;
10155 opti_type = OPTI_TYPE_ZERO_BYTE;
10156 dgst_pos0 = 0;
10157 dgst_pos1 = 3;
10158 dgst_pos2 = 2;
10159 dgst_pos3 = 1;
10160 break;
10161
10162 case 11500: hash_type = HASH_TYPE_CRC32;
10163 salt_type = SALT_TYPE_INTERN;
10164 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10165 opts_type = OPTS_TYPE_PT_GENERATE_LE
10166 | OPTS_TYPE_ST_GENERATE_LE
10167 | OPTS_TYPE_ST_HEX;
10168 kern_type = KERN_TYPE_CRC32;
10169 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10170 parse_func = crc32_parse_hash;
10171 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10172 opti_type = OPTI_TYPE_ZERO_BYTE;
10173 dgst_pos0 = 0;
10174 dgst_pos1 = 1;
10175 dgst_pos2 = 2;
10176 dgst_pos3 = 3;
10177 break;
10178
10179 case 11600: hash_type = HASH_TYPE_AES;
10180 salt_type = SALT_TYPE_EMBEDDED;
10181 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10182 opts_type = OPTS_TYPE_PT_GENERATE_LE
10183 | OPTS_TYPE_PT_NEVERCRACK;
10184 kern_type = KERN_TYPE_SEVEN_ZIP;
10185 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10186 parse_func = seven_zip_parse_hash;
10187 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10188 opti_type = OPTI_TYPE_ZERO_BYTE;
10189 dgst_pos0 = 0;
10190 dgst_pos1 = 1;
10191 dgst_pos2 = 2;
10192 dgst_pos3 = 3;
10193 break;
10194
10195 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10196 salt_type = SALT_TYPE_NONE;
10197 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10198 opts_type = OPTS_TYPE_PT_GENERATE_LE
10199 | OPTS_TYPE_PT_ADD01;
10200 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10201 dgst_size = DGST_SIZE_4_8;
10202 parse_func = gost2012sbog_256_parse_hash;
10203 sort_by_digest = sort_by_digest_4_8;
10204 opti_type = OPTI_TYPE_ZERO_BYTE;
10205 dgst_pos0 = 0;
10206 dgst_pos1 = 1;
10207 dgst_pos2 = 2;
10208 dgst_pos3 = 3;
10209 break;
10210
10211 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10212 salt_type = SALT_TYPE_NONE;
10213 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10214 opts_type = OPTS_TYPE_PT_GENERATE_LE
10215 | OPTS_TYPE_PT_ADD01;
10216 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10217 dgst_size = DGST_SIZE_4_16;
10218 parse_func = gost2012sbog_512_parse_hash;
10219 sort_by_digest = sort_by_digest_4_16;
10220 opti_type = OPTI_TYPE_ZERO_BYTE;
10221 dgst_pos0 = 0;
10222 dgst_pos1 = 1;
10223 dgst_pos2 = 2;
10224 dgst_pos3 = 3;
10225 break;
10226
10227 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10228 salt_type = SALT_TYPE_EMBEDDED;
10229 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10230 opts_type = OPTS_TYPE_PT_GENERATE_LE
10231 | OPTS_TYPE_ST_BASE64
10232 | OPTS_TYPE_HASH_COPY;
10233 kern_type = KERN_TYPE_PBKDF2_MD5;
10234 dgst_size = DGST_SIZE_4_32;
10235 parse_func = pbkdf2_md5_parse_hash;
10236 sort_by_digest = sort_by_digest_4_32;
10237 opti_type = OPTI_TYPE_ZERO_BYTE
10238 | OPTI_TYPE_SLOW_HASH_SIMD;
10239 dgst_pos0 = 0;
10240 dgst_pos1 = 1;
10241 dgst_pos2 = 2;
10242 dgst_pos3 = 3;
10243 break;
10244
10245 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10246 salt_type = SALT_TYPE_EMBEDDED;
10247 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10248 opts_type = OPTS_TYPE_PT_GENERATE_LE
10249 | OPTS_TYPE_ST_BASE64
10250 | OPTS_TYPE_HASH_COPY;
10251 kern_type = KERN_TYPE_PBKDF2_SHA1;
10252 dgst_size = DGST_SIZE_4_32;
10253 parse_func = pbkdf2_sha1_parse_hash;
10254 sort_by_digest = sort_by_digest_4_32;
10255 opti_type = OPTI_TYPE_ZERO_BYTE
10256 | OPTI_TYPE_SLOW_HASH_SIMD;
10257 dgst_pos0 = 0;
10258 dgst_pos1 = 1;
10259 dgst_pos2 = 2;
10260 dgst_pos3 = 3;
10261 break;
10262
10263 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10264 salt_type = SALT_TYPE_EMBEDDED;
10265 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10266 opts_type = OPTS_TYPE_PT_GENERATE_LE
10267 | OPTS_TYPE_ST_BASE64
10268 | OPTS_TYPE_HASH_COPY;
10269 kern_type = KERN_TYPE_PBKDF2_SHA512;
10270 dgst_size = DGST_SIZE_8_16;
10271 parse_func = pbkdf2_sha512_parse_hash;
10272 sort_by_digest = sort_by_digest_8_16;
10273 opti_type = OPTI_TYPE_ZERO_BYTE
10274 | OPTI_TYPE_USES_BITS_64
10275 | OPTI_TYPE_SLOW_HASH_SIMD;
10276 dgst_pos0 = 0;
10277 dgst_pos1 = 1;
10278 dgst_pos2 = 2;
10279 dgst_pos3 = 3;
10280 break;
10281
10282 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10283 salt_type = SALT_TYPE_EMBEDDED;
10284 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10285 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10286 kern_type = KERN_TYPE_ECRYPTFS;
10287 dgst_size = DGST_SIZE_8_8;
10288 parse_func = ecryptfs_parse_hash;
10289 sort_by_digest = sort_by_digest_8_8;
10290 opti_type = OPTI_TYPE_ZERO_BYTE
10291 | OPTI_TYPE_USES_BITS_64;
10292 dgst_pos0 = 0;
10293 dgst_pos1 = 1;
10294 dgst_pos2 = 2;
10295 dgst_pos3 = 3;
10296 break;
10297
10298 case 12300: hash_type = HASH_TYPE_ORACLET;
10299 salt_type = SALT_TYPE_EMBEDDED;
10300 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10301 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10302 kern_type = KERN_TYPE_ORACLET;
10303 dgst_size = DGST_SIZE_8_16;
10304 parse_func = oraclet_parse_hash;
10305 sort_by_digest = sort_by_digest_8_16;
10306 opti_type = OPTI_TYPE_ZERO_BYTE
10307 | OPTI_TYPE_USES_BITS_64;
10308 dgst_pos0 = 0;
10309 dgst_pos1 = 1;
10310 dgst_pos2 = 2;
10311 dgst_pos3 = 3;
10312 break;
10313
10314 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10315 salt_type = SALT_TYPE_EMBEDDED;
10316 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10317 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10318 kern_type = KERN_TYPE_BSDICRYPT;
10319 dgst_size = DGST_SIZE_4_4;
10320 parse_func = bsdicrypt_parse_hash;
10321 sort_by_digest = sort_by_digest_4_4;
10322 opti_type = OPTI_TYPE_ZERO_BYTE
10323 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10324 dgst_pos0 = 0;
10325 dgst_pos1 = 1;
10326 dgst_pos2 = 2;
10327 dgst_pos3 = 3;
10328 break;
10329
10330 case 12500: hash_type = HASH_TYPE_RAR3HP;
10331 salt_type = SALT_TYPE_EMBEDDED;
10332 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10333 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10334 kern_type = KERN_TYPE_RAR3;
10335 dgst_size = DGST_SIZE_4_4;
10336 parse_func = rar3hp_parse_hash;
10337 sort_by_digest = sort_by_digest_4_4;
10338 opti_type = OPTI_TYPE_ZERO_BYTE;
10339 dgst_pos0 = 0;
10340 dgst_pos1 = 1;
10341 dgst_pos2 = 2;
10342 dgst_pos3 = 3;
10343 break;
10344
10345 case 12600: hash_type = HASH_TYPE_SHA256;
10346 salt_type = SALT_TYPE_INTERN;
10347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10348 opts_type = OPTS_TYPE_PT_GENERATE_BE
10349 | OPTS_TYPE_PT_ADD80;
10350 kern_type = KERN_TYPE_CF10;
10351 dgst_size = DGST_SIZE_4_8;
10352 parse_func = cf10_parse_hash;
10353 sort_by_digest = sort_by_digest_4_8;
10354 opti_type = OPTI_TYPE_ZERO_BYTE
10355 | OPTI_TYPE_PRECOMPUTE_INIT
10356 | OPTI_TYPE_EARLY_SKIP
10357 | OPTI_TYPE_NOT_ITERATED;
10358 dgst_pos0 = 3;
10359 dgst_pos1 = 7;
10360 dgst_pos2 = 2;
10361 dgst_pos3 = 6;
10362 break;
10363
10364 case 12700: hash_type = HASH_TYPE_AES;
10365 salt_type = SALT_TYPE_EMBEDDED;
10366 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10367 opts_type = OPTS_TYPE_PT_GENERATE_LE
10368 | OPTS_TYPE_HASH_COPY;
10369 kern_type = KERN_TYPE_MYWALLET;
10370 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10371 parse_func = mywallet_parse_hash;
10372 sort_by_digest = sort_by_digest_4_5;
10373 opti_type = OPTI_TYPE_ZERO_BYTE;
10374 dgst_pos0 = 0;
10375 dgst_pos1 = 1;
10376 dgst_pos2 = 2;
10377 dgst_pos3 = 3;
10378 break;
10379
10380 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10381 salt_type = SALT_TYPE_EMBEDDED;
10382 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10383 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10384 kern_type = KERN_TYPE_MS_DRSR;
10385 dgst_size = DGST_SIZE_4_8;
10386 parse_func = ms_drsr_parse_hash;
10387 sort_by_digest = sort_by_digest_4_8;
10388 opti_type = OPTI_TYPE_ZERO_BYTE;
10389 dgst_pos0 = 0;
10390 dgst_pos1 = 1;
10391 dgst_pos2 = 2;
10392 dgst_pos3 = 3;
10393 break;
10394
10395 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10396 salt_type = SALT_TYPE_EMBEDDED;
10397 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10398 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10399 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10400 dgst_size = DGST_SIZE_4_8;
10401 parse_func = androidfde_samsung_parse_hash;
10402 sort_by_digest = sort_by_digest_4_8;
10403 opti_type = OPTI_TYPE_ZERO_BYTE;
10404 dgst_pos0 = 0;
10405 dgst_pos1 = 1;
10406 dgst_pos2 = 2;
10407 dgst_pos3 = 3;
10408 break;
10409
10410 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10411 salt_type = SALT_TYPE_EMBEDDED;
10412 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10413 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10414 kern_type = KERN_TYPE_RAR5;
10415 dgst_size = DGST_SIZE_4_4;
10416 parse_func = rar5_parse_hash;
10417 sort_by_digest = sort_by_digest_4_4;
10418 opti_type = OPTI_TYPE_ZERO_BYTE;
10419 dgst_pos0 = 0;
10420 dgst_pos1 = 1;
10421 dgst_pos2 = 2;
10422 dgst_pos3 = 3;
10423 break;
10424
10425 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10426 salt_type = SALT_TYPE_EMBEDDED;
10427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10428 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10429 kern_type = KERN_TYPE_KRB5TGS;
10430 dgst_size = DGST_SIZE_4_4;
10431 parse_func = krb5tgs_parse_hash;
10432 sort_by_digest = sort_by_digest_4_4;
10433 opti_type = OPTI_TYPE_ZERO_BYTE
10434 | OPTI_TYPE_NOT_ITERATED;
10435 dgst_pos0 = 0;
10436 dgst_pos1 = 1;
10437 dgst_pos2 = 2;
10438 dgst_pos3 = 3;
10439 break;
10440
10441 case 13200: hash_type = HASH_TYPE_AES;
10442 salt_type = SALT_TYPE_EMBEDDED;
10443 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10444 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10445 kern_type = KERN_TYPE_AXCRYPT;
10446 dgst_size = DGST_SIZE_4_4;
10447 parse_func = axcrypt_parse_hash;
10448 sort_by_digest = sort_by_digest_4_4;
10449 opti_type = OPTI_TYPE_ZERO_BYTE;
10450 dgst_pos0 = 0;
10451 dgst_pos1 = 1;
10452 dgst_pos2 = 2;
10453 dgst_pos3 = 3;
10454 break;
10455
10456 case 13300: hash_type = HASH_TYPE_SHA1;
10457 salt_type = SALT_TYPE_NONE;
10458 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10459 opts_type = OPTS_TYPE_PT_GENERATE_BE
10460 | OPTS_TYPE_PT_ADD80
10461 | OPTS_TYPE_PT_ADDBITS15;
10462 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10463 dgst_size = DGST_SIZE_4_5;
10464 parse_func = sha1axcrypt_parse_hash;
10465 sort_by_digest = sort_by_digest_4_5;
10466 opti_type = OPTI_TYPE_ZERO_BYTE
10467 | OPTI_TYPE_PRECOMPUTE_INIT
10468 | OPTI_TYPE_EARLY_SKIP
10469 | OPTI_TYPE_NOT_ITERATED
10470 | OPTI_TYPE_NOT_SALTED;
10471 dgst_pos0 = 0;
10472 dgst_pos1 = 4;
10473 dgst_pos2 = 3;
10474 dgst_pos3 = 2;
10475 break;
10476
10477 case 13400: hash_type = HASH_TYPE_AES;
10478 salt_type = SALT_TYPE_EMBEDDED;
10479 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10480 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10481 kern_type = KERN_TYPE_KEEPASS;
10482 dgst_size = DGST_SIZE_4_4;
10483 parse_func = keepass_parse_hash;
10484 sort_by_digest = sort_by_digest_4_4;
10485 opti_type = OPTI_TYPE_ZERO_BYTE;
10486 dgst_pos0 = 0;
10487 dgst_pos1 = 1;
10488 dgst_pos2 = 2;
10489 dgst_pos3 = 3;
10490 break;
10491
10492 case 13500: hash_type = HASH_TYPE_SHA1;
10493 salt_type = SALT_TYPE_EMBEDDED;
10494 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10495 opts_type = OPTS_TYPE_PT_GENERATE_BE
10496 | OPTS_TYPE_PT_UNICODE
10497 | OPTS_TYPE_PT_ADD80;
10498 kern_type = KERN_TYPE_PSTOKEN;
10499 dgst_size = DGST_SIZE_4_5;
10500 parse_func = pstoken_parse_hash;
10501 sort_by_digest = sort_by_digest_4_5;
10502 opti_type = OPTI_TYPE_ZERO_BYTE
10503 | OPTI_TYPE_PRECOMPUTE_INIT
10504 | OPTI_TYPE_EARLY_SKIP
10505 | OPTI_TYPE_NOT_ITERATED
10506 | OPTI_TYPE_PREPENDED_SALT
10507 | OPTI_TYPE_RAW_HASH;
10508 dgst_pos0 = 3;
10509 dgst_pos1 = 4;
10510 dgst_pos2 = 2;
10511 dgst_pos3 = 1;
10512 break;
10513
10514 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10515 salt_type = SALT_TYPE_EMBEDDED;
10516 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10517 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10518 kern_type = KERN_TYPE_ZIP2;
10519 dgst_size = DGST_SIZE_4_4;
10520 parse_func = zip2_parse_hash;
10521 sort_by_digest = sort_by_digest_4_4;
10522 opti_type = OPTI_TYPE_ZERO_BYTE;
10523 dgst_pos0 = 0;
10524 dgst_pos1 = 1;
10525 dgst_pos2 = 2;
10526 dgst_pos3 = 3;
10527 break;
10528
10529 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10530 salt_type = SALT_TYPE_EMBEDDED;
10531 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10532 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10533 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10534 dgst_size = DGST_SIZE_4_5;
10535 parse_func = veracrypt_parse_hash_655331;
10536 sort_by_digest = sort_by_digest_4_5;
10537 opti_type = OPTI_TYPE_ZERO_BYTE;
10538 dgst_pos0 = 0;
10539 dgst_pos1 = 1;
10540 dgst_pos2 = 2;
10541 dgst_pos3 = 3;
10542 break;
10543
10544 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10545 salt_type = SALT_TYPE_EMBEDDED;
10546 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10547 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10548 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10549 dgst_size = DGST_SIZE_4_5;
10550 parse_func = veracrypt_parse_hash_655331;
10551 sort_by_digest = sort_by_digest_4_5;
10552 opti_type = OPTI_TYPE_ZERO_BYTE;
10553 dgst_pos0 = 0;
10554 dgst_pos1 = 1;
10555 dgst_pos2 = 2;
10556 dgst_pos3 = 3;
10557 break;
10558
10559 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10560 salt_type = SALT_TYPE_EMBEDDED;
10561 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10562 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10563 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10564 dgst_size = DGST_SIZE_4_5;
10565 parse_func = veracrypt_parse_hash_655331;
10566 sort_by_digest = sort_by_digest_4_5;
10567 opti_type = OPTI_TYPE_ZERO_BYTE;
10568 dgst_pos0 = 0;
10569 dgst_pos1 = 1;
10570 dgst_pos2 = 2;
10571 dgst_pos3 = 3;
10572 break;
10573
10574 case 13721: hash_type = HASH_TYPE_SHA512;
10575 salt_type = SALT_TYPE_EMBEDDED;
10576 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10577 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10578 kern_type = KERN_TYPE_TCSHA512_XTS512;
10579 dgst_size = DGST_SIZE_8_8;
10580 parse_func = veracrypt_parse_hash_500000;
10581 sort_by_digest = sort_by_digest_8_8;
10582 opti_type = OPTI_TYPE_ZERO_BYTE
10583 | OPTI_TYPE_USES_BITS_64;
10584 dgst_pos0 = 0;
10585 dgst_pos1 = 1;
10586 dgst_pos2 = 2;
10587 dgst_pos3 = 3;
10588 break;
10589
10590 case 13722: hash_type = HASH_TYPE_SHA512;
10591 salt_type = SALT_TYPE_EMBEDDED;
10592 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10593 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10594 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10595 dgst_size = DGST_SIZE_8_8;
10596 parse_func = veracrypt_parse_hash_500000;
10597 sort_by_digest = sort_by_digest_8_8;
10598 opti_type = OPTI_TYPE_ZERO_BYTE
10599 | OPTI_TYPE_USES_BITS_64;
10600 dgst_pos0 = 0;
10601 dgst_pos1 = 1;
10602 dgst_pos2 = 2;
10603 dgst_pos3 = 3;
10604 break;
10605
10606 case 13723: hash_type = HASH_TYPE_SHA512;
10607 salt_type = SALT_TYPE_EMBEDDED;
10608 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10609 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10610 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10611 dgst_size = DGST_SIZE_8_8;
10612 parse_func = veracrypt_parse_hash_500000;
10613 sort_by_digest = sort_by_digest_8_8;
10614 opti_type = OPTI_TYPE_ZERO_BYTE
10615 | OPTI_TYPE_USES_BITS_64;
10616 dgst_pos0 = 0;
10617 dgst_pos1 = 1;
10618 dgst_pos2 = 2;
10619 dgst_pos3 = 3;
10620 break;
10621
10622 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10623 salt_type = SALT_TYPE_EMBEDDED;
10624 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10625 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10626 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10627 dgst_size = DGST_SIZE_4_8;
10628 parse_func = veracrypt_parse_hash_500000;
10629 sort_by_digest = sort_by_digest_4_8;
10630 opti_type = OPTI_TYPE_ZERO_BYTE;
10631 dgst_pos0 = 0;
10632 dgst_pos1 = 1;
10633 dgst_pos2 = 2;
10634 dgst_pos3 = 3;
10635 break;
10636
10637 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10638 salt_type = SALT_TYPE_EMBEDDED;
10639 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10640 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10641 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10642 dgst_size = DGST_SIZE_4_8;
10643 parse_func = veracrypt_parse_hash_500000;
10644 sort_by_digest = sort_by_digest_4_8;
10645 opti_type = OPTI_TYPE_ZERO_BYTE;
10646 dgst_pos0 = 0;
10647 dgst_pos1 = 1;
10648 dgst_pos2 = 2;
10649 dgst_pos3 = 3;
10650 break;
10651
10652 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10653 salt_type = SALT_TYPE_EMBEDDED;
10654 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10655 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10656 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10657 dgst_size = DGST_SIZE_4_8;
10658 parse_func = veracrypt_parse_hash_500000;
10659 sort_by_digest = sort_by_digest_4_8;
10660 opti_type = OPTI_TYPE_ZERO_BYTE;
10661 dgst_pos0 = 0;
10662 dgst_pos1 = 1;
10663 dgst_pos2 = 2;
10664 dgst_pos3 = 3;
10665 break;
10666
10667 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10668 salt_type = SALT_TYPE_EMBEDDED;
10669 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10670 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10671 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10672 dgst_size = DGST_SIZE_4_5;
10673 parse_func = veracrypt_parse_hash_327661;
10674 sort_by_digest = sort_by_digest_4_5;
10675 opti_type = OPTI_TYPE_ZERO_BYTE;
10676 dgst_pos0 = 0;
10677 dgst_pos1 = 1;
10678 dgst_pos2 = 2;
10679 dgst_pos3 = 3;
10680 break;
10681
10682 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10683 salt_type = SALT_TYPE_EMBEDDED;
10684 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10685 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10686 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10687 dgst_size = DGST_SIZE_4_5;
10688 parse_func = veracrypt_parse_hash_327661;
10689 sort_by_digest = sort_by_digest_4_5;
10690 opti_type = OPTI_TYPE_ZERO_BYTE;
10691 dgst_pos0 = 0;
10692 dgst_pos1 = 1;
10693 dgst_pos2 = 2;
10694 dgst_pos3 = 3;
10695 break;
10696
10697 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10698 salt_type = SALT_TYPE_EMBEDDED;
10699 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10700 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10701 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10702 dgst_size = DGST_SIZE_4_5;
10703 parse_func = veracrypt_parse_hash_327661;
10704 sort_by_digest = sort_by_digest_4_5;
10705 opti_type = OPTI_TYPE_ZERO_BYTE;
10706 dgst_pos0 = 0;
10707 dgst_pos1 = 1;
10708 dgst_pos2 = 2;
10709 dgst_pos3 = 3;
10710 break;
10711
10712 case 13751: hash_type = HASH_TYPE_SHA256;
10713 salt_type = SALT_TYPE_EMBEDDED;
10714 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10715 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10716 kern_type = KERN_TYPE_VCSHA256_XTS512;
10717 dgst_size = DGST_SIZE_4_8;
10718 parse_func = veracrypt_parse_hash_500000;
10719 sort_by_digest = sort_by_digest_4_8;
10720 opti_type = OPTI_TYPE_ZERO_BYTE;
10721 dgst_pos0 = 0;
10722 dgst_pos1 = 1;
10723 dgst_pos2 = 2;
10724 dgst_pos3 = 3;
10725 break;
10726
10727 case 13752: hash_type = HASH_TYPE_SHA256;
10728 salt_type = SALT_TYPE_EMBEDDED;
10729 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10730 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10731 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10732 dgst_size = DGST_SIZE_4_8;
10733 parse_func = veracrypt_parse_hash_500000;
10734 sort_by_digest = sort_by_digest_4_8;
10735 opti_type = OPTI_TYPE_ZERO_BYTE;
10736 dgst_pos0 = 0;
10737 dgst_pos1 = 1;
10738 dgst_pos2 = 2;
10739 dgst_pos3 = 3;
10740 break;
10741
10742 case 13753: hash_type = HASH_TYPE_SHA256;
10743 salt_type = SALT_TYPE_EMBEDDED;
10744 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10745 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10746 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10747 dgst_size = DGST_SIZE_4_8;
10748 parse_func = veracrypt_parse_hash_500000;
10749 sort_by_digest = sort_by_digest_4_8;
10750 opti_type = OPTI_TYPE_ZERO_BYTE;
10751 dgst_pos0 = 0;
10752 dgst_pos1 = 1;
10753 dgst_pos2 = 2;
10754 dgst_pos3 = 3;
10755 break;
10756
10757 case 13761: hash_type = HASH_TYPE_SHA256;
10758 salt_type = SALT_TYPE_EMBEDDED;
10759 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10760 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10761 kern_type = KERN_TYPE_VCSHA256_XTS512;
10762 dgst_size = DGST_SIZE_4_8;
10763 parse_func = veracrypt_parse_hash_200000;
10764 sort_by_digest = sort_by_digest_4_8;
10765 opti_type = OPTI_TYPE_ZERO_BYTE;
10766 dgst_pos0 = 0;
10767 dgst_pos1 = 1;
10768 dgst_pos2 = 2;
10769 dgst_pos3 = 3;
10770 break;
10771
10772 case 13762: hash_type = HASH_TYPE_SHA256;
10773 salt_type = SALT_TYPE_EMBEDDED;
10774 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10775 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10776 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10777 dgst_size = DGST_SIZE_4_8;
10778 parse_func = veracrypt_parse_hash_200000;
10779 sort_by_digest = sort_by_digest_4_8;
10780 opti_type = OPTI_TYPE_ZERO_BYTE;
10781 dgst_pos0 = 0;
10782 dgst_pos1 = 1;
10783 dgst_pos2 = 2;
10784 dgst_pos3 = 3;
10785 break;
10786
10787 case 13763: hash_type = HASH_TYPE_SHA256;
10788 salt_type = SALT_TYPE_EMBEDDED;
10789 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10790 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10791 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10792 dgst_size = DGST_SIZE_4_8;
10793 parse_func = veracrypt_parse_hash_200000;
10794 sort_by_digest = sort_by_digest_4_8;
10795 opti_type = OPTI_TYPE_ZERO_BYTE;
10796 dgst_pos0 = 0;
10797 dgst_pos1 = 1;
10798 dgst_pos2 = 2;
10799 dgst_pos3 = 3;
10800 break;
10801
10802
10803 default: usage_mini_print (PROGNAME); return (-1);
10804 }
10805
10806 /**
10807 * parser
10808 */
10809
10810 data.parse_func = parse_func;
10811
10812 /**
10813 * misc stuff
10814 */
10815
10816 if (hex_salt)
10817 {
10818 if (salt_type == SALT_TYPE_INTERN)
10819 {
10820 opts_type |= OPTS_TYPE_ST_HEX;
10821 }
10822 else
10823 {
10824 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10825
10826 return (-1);
10827 }
10828 }
10829
10830 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10831 | (salt_type == SALT_TYPE_EXTERN)
10832 | (salt_type == SALT_TYPE_EMBEDDED)
10833 | (salt_type == SALT_TYPE_VIRTUAL));
10834
10835 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10836
10837 data.hash_type = hash_type;
10838 data.attack_mode = attack_mode;
10839 data.attack_kern = attack_kern;
10840 data.attack_exec = attack_exec;
10841 data.kern_type = kern_type;
10842 data.opts_type = opts_type;
10843 data.dgst_size = dgst_size;
10844 data.salt_type = salt_type;
10845 data.isSalted = isSalted;
10846 data.sort_by_digest = sort_by_digest;
10847 data.dgst_pos0 = dgst_pos0;
10848 data.dgst_pos1 = dgst_pos1;
10849 data.dgst_pos2 = dgst_pos2;
10850 data.dgst_pos3 = dgst_pos3;
10851
10852 esalt_size = 0;
10853
10854 switch (hash_mode)
10855 {
10856 case 2500: esalt_size = sizeof (wpa_t); break;
10857 case 5300: esalt_size = sizeof (ikepsk_t); break;
10858 case 5400: esalt_size = sizeof (ikepsk_t); break;
10859 case 5500: esalt_size = sizeof (netntlm_t); break;
10860 case 5600: esalt_size = sizeof (netntlm_t); break;
10861 case 6211: esalt_size = sizeof (tc_t); break;
10862 case 6212: esalt_size = sizeof (tc_t); break;
10863 case 6213: esalt_size = sizeof (tc_t); break;
10864 case 6221: esalt_size = sizeof (tc_t); break;
10865 case 6222: esalt_size = sizeof (tc_t); break;
10866 case 6223: esalt_size = sizeof (tc_t); break;
10867 case 6231: esalt_size = sizeof (tc_t); break;
10868 case 6232: esalt_size = sizeof (tc_t); break;
10869 case 6233: esalt_size = sizeof (tc_t); break;
10870 case 6241: esalt_size = sizeof (tc_t); break;
10871 case 6242: esalt_size = sizeof (tc_t); break;
10872 case 6243: esalt_size = sizeof (tc_t); break;
10873 case 6600: esalt_size = sizeof (agilekey_t); break;
10874 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10875 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10876 case 7300: esalt_size = sizeof (rakp_t); break;
10877 case 7500: esalt_size = sizeof (krb5pa_t); break;
10878 case 8200: esalt_size = sizeof (cloudkey_t); break;
10879 case 8800: esalt_size = sizeof (androidfde_t); break;
10880 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10881 case 9400: esalt_size = sizeof (office2007_t); break;
10882 case 9500: esalt_size = sizeof (office2010_t); break;
10883 case 9600: esalt_size = sizeof (office2013_t); break;
10884 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10885 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10886 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10887 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10888 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10889 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10890 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10891 case 10200: esalt_size = sizeof (cram_md5_t); break;
10892 case 10400: esalt_size = sizeof (pdf_t); break;
10893 case 10410: esalt_size = sizeof (pdf_t); break;
10894 case 10420: esalt_size = sizeof (pdf_t); break;
10895 case 10500: esalt_size = sizeof (pdf_t); break;
10896 case 10600: esalt_size = sizeof (pdf_t); break;
10897 case 10700: esalt_size = sizeof (pdf_t); break;
10898 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10899 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10900 case 11400: esalt_size = sizeof (sip_t); break;
10901 case 11600: esalt_size = sizeof (seven_zip_t); break;
10902 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10903 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10904 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10905 case 13000: esalt_size = sizeof (rar5_t); break;
10906 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10907 case 13400: esalt_size = sizeof (keepass_t); break;
10908 case 13500: esalt_size = sizeof (pstoken_t); break;
10909 case 13600: esalt_size = sizeof (zip2_t); break;
10910 case 13711: esalt_size = sizeof (tc_t); break;
10911 case 13712: esalt_size = sizeof (tc_t); break;
10912 case 13713: esalt_size = sizeof (tc_t); break;
10913 case 13721: esalt_size = sizeof (tc_t); break;
10914 case 13722: esalt_size = sizeof (tc_t); break;
10915 case 13723: esalt_size = sizeof (tc_t); break;
10916 case 13731: esalt_size = sizeof (tc_t); break;
10917 case 13732: esalt_size = sizeof (tc_t); break;
10918 case 13733: esalt_size = sizeof (tc_t); break;
10919 case 13741: esalt_size = sizeof (tc_t); break;
10920 case 13742: esalt_size = sizeof (tc_t); break;
10921 case 13743: esalt_size = sizeof (tc_t); break;
10922 case 13751: esalt_size = sizeof (tc_t); break;
10923 case 13752: esalt_size = sizeof (tc_t); break;
10924 case 13753: esalt_size = sizeof (tc_t); break;
10925 case 13761: esalt_size = sizeof (tc_t); break;
10926 case 13762: esalt_size = sizeof (tc_t); break;
10927 case 13763: esalt_size = sizeof (tc_t); break;
10928 }
10929
10930 data.esalt_size = esalt_size;
10931
10932 /**
10933 * choose dictionary parser
10934 */
10935
10936 if (hash_type == HASH_TYPE_LM)
10937 {
10938 get_next_word_func = get_next_word_lm;
10939 }
10940 else if (opts_type & OPTS_TYPE_PT_UPPER)
10941 {
10942 get_next_word_func = get_next_word_uc;
10943 }
10944 else
10945 {
10946 get_next_word_func = get_next_word_std;
10947 }
10948
10949 /**
10950 * dictstat
10951 */
10952
10953 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10954
10955 #ifdef _POSIX
10956 size_t dictstat_nmemb = 0;
10957 #endif
10958
10959 #ifdef _WIN
10960 uint dictstat_nmemb = 0;
10961 #endif
10962
10963 char dictstat[256] = { 0 };
10964
10965 FILE *dictstat_fp = NULL;
10966
10967 if (keyspace == 0)
10968 {
10969 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10970
10971 dictstat_fp = fopen (dictstat, "rb");
10972
10973 if (dictstat_fp)
10974 {
10975 #ifdef _POSIX
10976 struct stat tmpstat;
10977
10978 fstat (fileno (dictstat_fp), &tmpstat);
10979 #endif
10980
10981 #ifdef _WIN
10982 struct stat64 tmpstat;
10983
10984 _fstat64 (fileno (dictstat_fp), &tmpstat);
10985 #endif
10986
10987 if (tmpstat.st_mtime < COMPTIME)
10988 {
10989 /* with v0.15 the format changed so we have to ensure user is using a good version
10990 since there is no version-header in the dictstat file */
10991
10992 fclose (dictstat_fp);
10993
10994 unlink (dictstat);
10995 }
10996 else
10997 {
10998 while (!feof (dictstat_fp))
10999 {
11000 dictstat_t d;
11001
11002 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11003
11004 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11005
11006 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11007 {
11008 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11009
11010 return -1;
11011 }
11012 }
11013
11014 fclose (dictstat_fp);
11015 }
11016 }
11017 }
11018
11019 /**
11020 * potfile
11021 */
11022
11023 char potfile[256] = { 0 };
11024
11025 if (potfile_path == NULL)
11026 {
11027 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11028 }
11029 else
11030 {
11031 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11032 }
11033
11034 data.pot_fp = NULL;
11035
11036 FILE *out_fp = NULL;
11037 FILE *pot_fp = NULL;
11038
11039 if (show == 1 || left == 1)
11040 {
11041 pot_fp = fopen (potfile, "rb");
11042
11043 if (pot_fp == NULL)
11044 {
11045 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11046
11047 return (-1);
11048 }
11049
11050 if (outfile != NULL)
11051 {
11052 if ((out_fp = fopen (outfile, "ab")) == NULL)
11053 {
11054 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11055
11056 fclose (pot_fp);
11057
11058 return (-1);
11059 }
11060 }
11061 else
11062 {
11063 out_fp = stdout;
11064 }
11065 }
11066 else
11067 {
11068 if (potfile_disable == 0)
11069 {
11070 pot_fp = fopen (potfile, "ab");
11071
11072 if (pot_fp == NULL)
11073 {
11074 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11075
11076 return (-1);
11077 }
11078
11079 data.pot_fp = pot_fp;
11080 }
11081 }
11082
11083 pot_t *pot = NULL;
11084
11085 uint pot_cnt = 0;
11086 uint pot_avail = 0;
11087
11088 if (show == 1 || left == 1)
11089 {
11090 SUPPRESS_OUTPUT = 1;
11091
11092 pot_avail = count_lines (pot_fp);
11093
11094 rewind (pot_fp);
11095
11096 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11097
11098 uint pot_hashes_avail = 0;
11099
11100 uint line_num = 0;
11101
11102 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11103
11104 while (!feof (pot_fp))
11105 {
11106 line_num++;
11107
11108 int line_len = fgetl (pot_fp, line_buf);
11109
11110 if (line_len == 0) continue;
11111
11112 char *plain_buf = line_buf + line_len;
11113
11114 pot_t *pot_ptr = &pot[pot_cnt];
11115
11116 hash_t *hashes_buf = &pot_ptr->hash;
11117
11118 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11119 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11120
11121 if (pot_cnt == pot_hashes_avail)
11122 {
11123 uint pos = 0;
11124
11125 for (pos = 0; pos < INCR_POT; pos++)
11126 {
11127 if ((pot_cnt + pos) >= pot_avail) break;
11128
11129 pot_t *tmp_pot = &pot[pot_cnt + pos];
11130
11131 hash_t *tmp_hash = &tmp_pot->hash;
11132
11133 tmp_hash->digest = mymalloc (dgst_size);
11134
11135 if (isSalted)
11136 {
11137 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11138 }
11139
11140 if (esalt_size)
11141 {
11142 tmp_hash->esalt = mymalloc (esalt_size);
11143 }
11144
11145 pot_hashes_avail++;
11146 }
11147 }
11148
11149 int plain_len = 0;
11150
11151 int parser_status;
11152
11153 int iter = MAX_CUT_TRIES;
11154
11155 do
11156 {
11157 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11158 {
11159 if (line_buf[i] == ':')
11160 {
11161 line_len--;
11162
11163 break;
11164 }
11165 }
11166
11167 if (data.hash_mode != 2500)
11168 {
11169 parser_status = parse_func (line_buf, line_len, hashes_buf);
11170 }
11171 else
11172 {
11173 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11174
11175 if (line_len > max_salt_size)
11176 {
11177 parser_status = PARSER_GLOBAL_LENGTH;
11178 }
11179 else
11180 {
11181 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11182
11183 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11184
11185 hashes_buf->salt->salt_len = line_len;
11186
11187 parser_status = PARSER_OK;
11188 }
11189 }
11190
11191 // if NOT parsed without error, we add the ":" to the plain
11192
11193 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11194 {
11195 plain_len++;
11196 plain_buf--;
11197 }
11198
11199 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11200
11201 if (parser_status < PARSER_GLOBAL_ZERO)
11202 {
11203 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11204
11205 continue;
11206 }
11207
11208 if (plain_len >= 255) continue;
11209
11210 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11211
11212 pot_ptr->plain_len = plain_len;
11213
11214 pot_cnt++;
11215 }
11216
11217 myfree (line_buf);
11218
11219 fclose (pot_fp);
11220
11221 SUPPRESS_OUTPUT = 0;
11222
11223 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11224 }
11225
11226 /**
11227 * word len
11228 */
11229
11230 uint pw_min = PW_MIN;
11231 uint pw_max = PW_MAX;
11232
11233 switch (hash_mode)
11234 {
11235 case 125: if (pw_max > 32) pw_max = 32;
11236 break;
11237 case 400: if (pw_max > 40) pw_max = 40;
11238 break;
11239 case 500: if (pw_max > 16) pw_max = 16;
11240 break;
11241 case 1500: if (pw_max > 8) pw_max = 8;
11242 break;
11243 case 1600: if (pw_max > 16) pw_max = 16;
11244 break;
11245 case 1800: if (pw_max > 16) pw_max = 16;
11246 break;
11247 case 2100: if (pw_max > 16) pw_max = 16;
11248 break;
11249 case 2500: if (pw_min < 8) pw_min = 8;
11250 break;
11251 case 3000: if (pw_max > 7) pw_max = 7;
11252 break;
11253 case 5200: if (pw_max > 24) pw_max = 24;
11254 break;
11255 case 5800: if (pw_max > 16) pw_max = 16;
11256 break;
11257 case 6300: if (pw_max > 16) pw_max = 16;
11258 break;
11259 case 7400: if (pw_max > 16) pw_max = 16;
11260 break;
11261 case 7500: if (pw_max > 8) pw_max = 8;
11262 break;
11263 case 7900: if (pw_max > 48) pw_max = 48;
11264 break;
11265 case 8500: if (pw_max > 8) pw_max = 8;
11266 break;
11267 case 8600: if (pw_max > 16) pw_max = 16;
11268 break;
11269 case 9710: pw_min = 5;
11270 pw_max = 5;
11271 break;
11272 case 9810: pw_min = 5;
11273 pw_max = 5;
11274 break;
11275 case 10410: pw_min = 5;
11276 pw_max = 5;
11277 break;
11278 case 10300: if (pw_max < 3) pw_min = 3;
11279 if (pw_max > 40) pw_max = 40;
11280 break;
11281 case 10500: if (pw_max < 3) pw_min = 3;
11282 if (pw_max > 40) pw_max = 40;
11283 break;
11284 case 10700: if (pw_max > 16) pw_max = 16;
11285 break;
11286 case 11300: if (pw_max > 40) pw_max = 40;
11287 break;
11288 case 11600: if (pw_max > 32) pw_max = 32;
11289 break;
11290 case 12500: if (pw_max > 20) pw_max = 20;
11291 break;
11292 case 12800: if (pw_max > 24) pw_max = 24;
11293 break;
11294 }
11295
11296 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11297 {
11298 switch (attack_kern)
11299 {
11300 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11301 break;
11302 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11303 break;
11304 }
11305 }
11306
11307 /**
11308 * charsets : keep them together for more easy maintainnce
11309 */
11310
11311 cs_t mp_sys[6] = { { { 0 }, 0 } };
11312 cs_t mp_usr[4] = { { { 0 }, 0 } };
11313
11314 mp_setup_sys (mp_sys);
11315
11316 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11317 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11318 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11319 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11320
11321 /**
11322 * load hashes, part I: find input mode, count hashes
11323 */
11324
11325 uint hashlist_mode = 0;
11326 uint hashlist_format = HLFMT_HASHCAT;
11327
11328 uint hashes_avail = 0;
11329
11330 if (benchmark == 0)
11331 {
11332 struct stat f;
11333
11334 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11335
11336 if ((hash_mode == 2500) ||
11337 (hash_mode == 5200) ||
11338 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11339 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11340 (hash_mode == 9000))
11341 {
11342 hashlist_mode = HL_MODE_ARG;
11343
11344 char *hashfile = myargv[optind];
11345
11346 data.hashfile = hashfile;
11347
11348 logfile_top_var_string ("target", hashfile);
11349 }
11350
11351 if (hashlist_mode == HL_MODE_ARG)
11352 {
11353 if (hash_mode == 2500)
11354 {
11355 struct stat st;
11356
11357 if (stat (data.hashfile, &st) == -1)
11358 {
11359 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11360
11361 return (-1);
11362 }
11363
11364 hashes_avail = st.st_size / sizeof (hccap_t);
11365 }
11366 else
11367 {
11368 hashes_avail = 1;
11369 }
11370 }
11371 else if (hashlist_mode == HL_MODE_FILE)
11372 {
11373 char *hashfile = myargv[optind];
11374
11375 data.hashfile = hashfile;
11376
11377 logfile_top_var_string ("target", hashfile);
11378
11379 FILE *fp = NULL;
11380
11381 if ((fp = fopen (hashfile, "rb")) == NULL)
11382 {
11383 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11384
11385 return (-1);
11386 }
11387
11388 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11389
11390 hashes_avail = count_lines (fp);
11391
11392 rewind (fp);
11393
11394 if (hashes_avail == 0)
11395 {
11396 log_error ("ERROR: hashfile is empty or corrupt");
11397
11398 fclose (fp);
11399
11400 return (-1);
11401 }
11402
11403 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11404
11405 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11406 {
11407 log_error ("ERROR: remove not supported in native hashfile-format mode");
11408
11409 fclose (fp);
11410
11411 return (-1);
11412 }
11413
11414 fclose (fp);
11415 }
11416 }
11417 else
11418 {
11419 hashlist_mode = HL_MODE_ARG;
11420
11421 hashes_avail = 1;
11422 }
11423
11424 if (hash_mode == 3000) hashes_avail *= 2;
11425
11426 data.hashlist_mode = hashlist_mode;
11427 data.hashlist_format = hashlist_format;
11428
11429 logfile_top_uint (hashlist_mode);
11430 logfile_top_uint (hashlist_format);
11431
11432 /**
11433 * load hashes, part II: allocate required memory, set pointers
11434 */
11435
11436 hash_t *hashes_buf = NULL;
11437 void *digests_buf = NULL;
11438 salt_t *salts_buf = NULL;
11439 void *esalts_buf = NULL;
11440
11441 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11442
11443 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11444
11445 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11446 {
11447 u32 hash_pos;
11448
11449 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11450 {
11451 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11452
11453 hashes_buf[hash_pos].hash_info = hash_info;
11454
11455 if (username && (remove || show || left))
11456 {
11457 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11458 }
11459
11460 if (benchmark)
11461 {
11462 hash_info->orighash = (char *) mymalloc (256);
11463 }
11464 }
11465 }
11466
11467 if (isSalted)
11468 {
11469 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11470
11471 if (esalt_size)
11472 {
11473 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11474 }
11475 }
11476 else
11477 {
11478 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11479 }
11480
11481 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11482 {
11483 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11484
11485 if (isSalted)
11486 {
11487 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11488
11489 if (esalt_size)
11490 {
11491 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11492 }
11493 }
11494 else
11495 {
11496 hashes_buf[hash_pos].salt = &salts_buf[0];
11497 }
11498 }
11499
11500 /**
11501 * load hashes, part III: parse hashes or generate them if benchmark
11502 */
11503
11504 uint hashes_cnt = 0;
11505
11506 if (benchmark == 0)
11507 {
11508 if (keyspace == 1)
11509 {
11510 // useless to read hash file for keyspace, cheat a little bit w/ optind
11511 }
11512 else if (hashes_avail == 0)
11513 {
11514 }
11515 else if (hashlist_mode == HL_MODE_ARG)
11516 {
11517 char *input_buf = myargv[optind];
11518
11519 uint input_len = strlen (input_buf);
11520
11521 logfile_top_var_string ("target", input_buf);
11522
11523 char *hash_buf = NULL;
11524 int hash_len = 0;
11525
11526 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11527
11528 bool hash_fmt_error = 0;
11529
11530 if (hash_len < 1) hash_fmt_error = 1;
11531 if (hash_buf == NULL) hash_fmt_error = 1;
11532
11533 if (hash_fmt_error)
11534 {
11535 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11536 }
11537 else
11538 {
11539 if (opts_type & OPTS_TYPE_HASH_COPY)
11540 {
11541 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11542
11543 hash_info_tmp->orighash = mystrdup (hash_buf);
11544 }
11545
11546 if (isSalted)
11547 {
11548 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11549 }
11550
11551 int parser_status = PARSER_OK;
11552
11553 if (hash_mode == 2500)
11554 {
11555 if (hash_len == 0)
11556 {
11557 log_error ("ERROR: hccap file not specified");
11558
11559 return (-1);
11560 }
11561
11562 hashlist_mode = HL_MODE_FILE;
11563
11564 data.hashlist_mode = hashlist_mode;
11565
11566 FILE *fp = fopen (hash_buf, "rb");
11567
11568 if (fp == NULL)
11569 {
11570 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11571
11572 return (-1);
11573 }
11574
11575 if (hashes_avail < 1)
11576 {
11577 log_error ("ERROR: hccap file is empty or corrupt");
11578
11579 fclose (fp);
11580
11581 return (-1);
11582 }
11583
11584 uint hccap_size = sizeof (hccap_t);
11585
11586 char *in = (char *) mymalloc (hccap_size);
11587
11588 while (!feof (fp))
11589 {
11590 int n = fread (in, hccap_size, 1, fp);
11591
11592 if (n != 1)
11593 {
11594 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11595
11596 break;
11597 }
11598
11599 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11600
11601 if (parser_status != PARSER_OK)
11602 {
11603 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11604
11605 continue;
11606 }
11607
11608 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11609
11610 if ((show == 1) || (left == 1))
11611 {
11612 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11613
11614 char *salt_ptr = (char *) tmp_salt->salt_buf;
11615
11616 int cur_pos = tmp_salt->salt_len;
11617 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11618
11619 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11620
11621 // do the appending task
11622
11623 snprintf (salt_ptr + cur_pos,
11624 rem_len,
11625 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11626 wpa->orig_mac1[0],
11627 wpa->orig_mac1[1],
11628 wpa->orig_mac1[2],
11629 wpa->orig_mac1[3],
11630 wpa->orig_mac1[4],
11631 wpa->orig_mac1[5],
11632 wpa->orig_mac2[0],
11633 wpa->orig_mac2[1],
11634 wpa->orig_mac2[2],
11635 wpa->orig_mac2[3],
11636 wpa->orig_mac2[4],
11637 wpa->orig_mac2[5]);
11638
11639 // memset () the remaining part of the salt
11640
11641 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11642 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11643
11644 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11645
11646 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11647 }
11648
11649 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);
11650 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);
11651
11652 hashes_cnt++;
11653 }
11654
11655 fclose (fp);
11656
11657 myfree (in);
11658 }
11659 else if (hash_mode == 3000)
11660 {
11661 if (hash_len == 32)
11662 {
11663 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11664
11665 hash_t *lm_hash_left = NULL;
11666
11667 if (parser_status == PARSER_OK)
11668 {
11669 lm_hash_left = &hashes_buf[hashes_cnt];
11670
11671 hashes_cnt++;
11672 }
11673 else
11674 {
11675 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11676 }
11677
11678 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11679
11680 hash_t *lm_hash_right = NULL;
11681
11682 if (parser_status == PARSER_OK)
11683 {
11684 lm_hash_right = &hashes_buf[hashes_cnt];
11685
11686 hashes_cnt++;
11687 }
11688 else
11689 {
11690 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11691 }
11692
11693 // show / left
11694
11695 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11696 {
11697 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);
11698 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);
11699 }
11700 }
11701 else
11702 {
11703 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11704
11705 if (parser_status == PARSER_OK)
11706 {
11707 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11708 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11709 }
11710
11711 if (parser_status == PARSER_OK)
11712 {
11713 hashes_cnt++;
11714 }
11715 else
11716 {
11717 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11718 }
11719 }
11720 }
11721 else
11722 {
11723 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11724
11725 if (parser_status == PARSER_OK)
11726 {
11727 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11728 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11729 }
11730
11731 if (parser_status == PARSER_OK)
11732 {
11733 hashes_cnt++;
11734 }
11735 else
11736 {
11737 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11738 }
11739 }
11740 }
11741 }
11742 else if (hashlist_mode == HL_MODE_FILE)
11743 {
11744 char *hashfile = data.hashfile;
11745
11746 FILE *fp;
11747
11748 if ((fp = fopen (hashfile, "rb")) == NULL)
11749 {
11750 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11751
11752 return (-1);
11753 }
11754
11755 uint line_num = 0;
11756
11757 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11758
11759 while (!feof (fp))
11760 {
11761 line_num++;
11762
11763 int line_len = fgetl (fp, line_buf);
11764
11765 if (line_len == 0) continue;
11766
11767 char *hash_buf = NULL;
11768 int hash_len = 0;
11769
11770 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11771
11772 bool hash_fmt_error = 0;
11773
11774 if (hash_len < 1) hash_fmt_error = 1;
11775 if (hash_buf == NULL) hash_fmt_error = 1;
11776
11777 if (hash_fmt_error)
11778 {
11779 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11780
11781 continue;
11782 }
11783
11784 if (username)
11785 {
11786 char *user_buf = NULL;
11787 int user_len = 0;
11788
11789 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11790
11791 if (remove || show)
11792 {
11793 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11794
11795 *user = (user_t *) mymalloc (sizeof (user_t));
11796
11797 user_t *user_ptr = *user;
11798
11799 if (user_buf != NULL)
11800 {
11801 user_ptr->user_name = mystrdup (user_buf);
11802 }
11803 else
11804 {
11805 user_ptr->user_name = mystrdup ("");
11806 }
11807
11808 user_ptr->user_len = user_len;
11809 }
11810 }
11811
11812 if (opts_type & OPTS_TYPE_HASH_COPY)
11813 {
11814 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11815
11816 hash_info_tmp->orighash = mystrdup (hash_buf);
11817 }
11818
11819 if (isSalted)
11820 {
11821 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11822 }
11823
11824 if (hash_mode == 3000)
11825 {
11826 if (hash_len == 32)
11827 {
11828 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11829
11830 if (parser_status < PARSER_GLOBAL_ZERO)
11831 {
11832 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11833
11834 continue;
11835 }
11836
11837 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11838
11839 hashes_cnt++;
11840
11841 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11842
11843 if (parser_status < PARSER_GLOBAL_ZERO)
11844 {
11845 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11846
11847 continue;
11848 }
11849
11850 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11851
11852 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);
11853
11854 hashes_cnt++;
11855
11856 // show / left
11857
11858 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);
11859 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);
11860 }
11861 else
11862 {
11863 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11864
11865 if (parser_status < PARSER_GLOBAL_ZERO)
11866 {
11867 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11868
11869 continue;
11870 }
11871
11872 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);
11873
11874 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11875 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11876
11877 hashes_cnt++;
11878 }
11879 }
11880 else
11881 {
11882 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11883
11884 if (parser_status < PARSER_GLOBAL_ZERO)
11885 {
11886 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11887
11888 continue;
11889 }
11890
11891 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11892
11893 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11894 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11895
11896 hashes_cnt++;
11897 }
11898 }
11899
11900 myfree (line_buf);
11901
11902 fclose (fp);
11903
11904 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11905
11906 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11907 }
11908 }
11909 else
11910 {
11911 if (isSalted)
11912 {
11913 hashes_buf[0].salt->salt_len = 8;
11914
11915 // special salt handling
11916
11917 switch (hash_mode)
11918 {
11919 case 1500: hashes_buf[0].salt->salt_len = 2;
11920 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11921 break;
11922 case 1731: hashes_buf[0].salt->salt_len = 4;
11923 break;
11924 case 2410: hashes_buf[0].salt->salt_len = 4;
11925 break;
11926 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11927 break;
11928 case 3100: hashes_buf[0].salt->salt_len = 1;
11929 break;
11930 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11931 break;
11932 case 5800: hashes_buf[0].salt->salt_len = 16;
11933 break;
11934 case 6800: hashes_buf[0].salt->salt_len = 32;
11935 break;
11936 case 8400: hashes_buf[0].salt->salt_len = 40;
11937 break;
11938 case 8800: hashes_buf[0].salt->salt_len = 16;
11939 break;
11940 case 8900: hashes_buf[0].salt->salt_len = 16;
11941 hashes_buf[0].salt->scrypt_N = 1024;
11942 hashes_buf[0].salt->scrypt_r = 1;
11943 hashes_buf[0].salt->scrypt_p = 1;
11944 break;
11945 case 9100: hashes_buf[0].salt->salt_len = 16;
11946 break;
11947 case 9300: hashes_buf[0].salt->salt_len = 14;
11948 hashes_buf[0].salt->scrypt_N = 16384;
11949 hashes_buf[0].salt->scrypt_r = 1;
11950 hashes_buf[0].salt->scrypt_p = 1;
11951 break;
11952 case 9400: hashes_buf[0].salt->salt_len = 16;
11953 break;
11954 case 9500: hashes_buf[0].salt->salt_len = 16;
11955 break;
11956 case 9600: hashes_buf[0].salt->salt_len = 16;
11957 break;
11958 case 9700: hashes_buf[0].salt->salt_len = 16;
11959 break;
11960 case 9710: hashes_buf[0].salt->salt_len = 16;
11961 break;
11962 case 9720: hashes_buf[0].salt->salt_len = 16;
11963 break;
11964 case 9800: hashes_buf[0].salt->salt_len = 16;
11965 break;
11966 case 9810: hashes_buf[0].salt->salt_len = 16;
11967 break;
11968 case 9820: hashes_buf[0].salt->salt_len = 16;
11969 break;
11970 case 10300: hashes_buf[0].salt->salt_len = 12;
11971 break;
11972 case 11500: hashes_buf[0].salt->salt_len = 4;
11973 break;
11974 case 11600: hashes_buf[0].salt->salt_len = 4;
11975 break;
11976 case 12400: hashes_buf[0].salt->salt_len = 4;
11977 break;
11978 case 12500: hashes_buf[0].salt->salt_len = 8;
11979 break;
11980 case 12600: hashes_buf[0].salt->salt_len = 64;
11981 break;
11982 }
11983
11984 // special esalt handling
11985
11986 switch (hash_mode)
11987 {
11988 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11989 break;
11990 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11991 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11992 break;
11993 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11994 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11995 break;
11996 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11997 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11998 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11999 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12000 break;
12001 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12002 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12003 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12004 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12005 break;
12006 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12007 break;
12008 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12009 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12010 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12011 break;
12012 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12013 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12014 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12015 break;
12016 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12017 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12018 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12019 break;
12020 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12021 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12022 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12023 break;
12024 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12025 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12026 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12027 break;
12028 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12029 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12030 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12031 break;
12032 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12033 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12034 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12035 break;
12036 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12037 break;
12038 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12039 break;
12040 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12041 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12042 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12043 break;
12044 }
12045 }
12046
12047 // set hashfile
12048
12049 switch (hash_mode)
12050 {
12051 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12052 break;
12053 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12054 break;
12055 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12056 break;
12057 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12058 break;
12059 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12060 break;
12061 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12062 break;
12063 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12064 break;
12065 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12066 break;
12067 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12068 break;
12069 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12070 break;
12071 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12072 break;
12073 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12074 break;
12075 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12076 break;
12077 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12078 break;
12079 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12080 break;
12081 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12082 break;
12083 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12084 break;
12085 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12086 break;
12087 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12088 break;
12089 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12090 break;
12091 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12092 break;
12093 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12094 break;
12095 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12096 break;
12097 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12098 break;
12099 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12100 break;
12101 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12102 break;
12103 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12104 break;
12105 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12106 break;
12107 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12108 break;
12109 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12110 break;
12111 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12112 break;
12113 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12114 break;
12115 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12116 break;
12117 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12118 break;
12119 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12120 break;
12121 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12122 break;
12123 }
12124
12125 // set default iterations
12126
12127 switch (hash_mode)
12128 {
12129 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12130 break;
12131 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12132 break;
12133 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12134 break;
12135 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12136 break;
12137 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12138 break;
12139 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12140 break;
12141 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12142 break;
12143 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12144 break;
12145 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12146 break;
12147 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12148 break;
12149 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12150 break;
12151 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12152 break;
12153 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12154 break;
12155 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12156 break;
12157 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12158 break;
12159 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12160 break;
12161 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12162 break;
12163 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12164 break;
12165 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12166 break;
12167 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12168 break;
12169 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12170 break;
12171 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12172 break;
12173 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12174 break;
12175 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12176 break;
12177 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12178 break;
12179 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12180 break;
12181 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12182 break;
12183 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12184 break;
12185 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12186 break;
12187 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12188 break;
12189 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12190 break;
12191 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12192 break;
12193 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12194 break;
12195 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12196 break;
12197 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12198 break;
12199 case 8900: hashes_buf[0].salt->salt_iter = 1;
12200 break;
12201 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12202 break;
12203 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12204 break;
12205 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12206 break;
12207 case 9300: hashes_buf[0].salt->salt_iter = 1;
12208 break;
12209 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12210 break;
12211 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12212 break;
12213 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12214 break;
12215 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12216 break;
12217 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12218 break;
12219 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12220 break;
12221 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12222 break;
12223 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12224 break;
12225 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12226 break;
12227 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12228 break;
12229 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12230 break;
12231 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12232 break;
12233 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12234 break;
12235 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12236 break;
12237 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12238 break;
12239 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12240 break;
12241 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12242 break;
12243 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12244 break;
12245 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12246 break;
12247 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12248 break;
12249 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12250 break;
12251 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12252 break;
12253 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12254 break;
12255 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12256 break;
12257 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12258 break;
12259 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12260 break;
12261 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12262 break;
12263 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12264 break;
12265 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12266 break;
12267 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12268 break;
12269 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12270 break;
12271 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12272 break;
12273 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12274 break;
12275 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12276 break;
12277 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12278 break;
12279 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12280 break;
12281 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12282 break;
12283 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12284 break;
12285 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12286 break;
12287 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12288 break;
12289 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12290 break;
12291 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12292 break;
12293 }
12294
12295 hashes_cnt = 1;
12296 }
12297
12298 if (show == 1 || left == 1)
12299 {
12300 for (uint i = 0; i < pot_cnt; i++)
12301 {
12302 pot_t *pot_ptr = &pot[i];
12303
12304 hash_t *hashes_buf = &pot_ptr->hash;
12305
12306 local_free (hashes_buf->digest);
12307
12308 if (isSalted)
12309 {
12310 local_free (hashes_buf->salt);
12311 }
12312 }
12313
12314 local_free (pot);
12315
12316 if (data.quiet == 0) log_info_nn ("");
12317
12318 return (0);
12319 }
12320
12321 if (keyspace == 0)
12322 {
12323 if (hashes_cnt == 0)
12324 {
12325 log_error ("ERROR: No hashes loaded");
12326
12327 return (-1);
12328 }
12329 }
12330
12331 /**
12332 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12333 */
12334
12335 if (data.outfile != NULL)
12336 {
12337 if (data.hashfile != NULL)
12338 {
12339 #ifdef _POSIX
12340 struct stat tmpstat_outfile;
12341 struct stat tmpstat_hashfile;
12342 #endif
12343
12344 #ifdef _WIN
12345 struct stat64 tmpstat_outfile;
12346 struct stat64 tmpstat_hashfile;
12347 #endif
12348
12349 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12350
12351 if (tmp_outfile_fp)
12352 {
12353 #ifdef _POSIX
12354 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12355 #endif
12356
12357 #ifdef _WIN
12358 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12359 #endif
12360
12361 fclose (tmp_outfile_fp);
12362 }
12363
12364 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12365
12366 if (tmp_hashfile_fp)
12367 {
12368 #ifdef _POSIX
12369 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12370 #endif
12371
12372 #ifdef _WIN
12373 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12374 #endif
12375
12376 fclose (tmp_hashfile_fp);
12377 }
12378
12379 if (tmp_outfile_fp && tmp_outfile_fp)
12380 {
12381 tmpstat_outfile.st_mode = 0;
12382 tmpstat_outfile.st_nlink = 0;
12383 tmpstat_outfile.st_uid = 0;
12384 tmpstat_outfile.st_gid = 0;
12385 tmpstat_outfile.st_rdev = 0;
12386 tmpstat_outfile.st_atime = 0;
12387
12388 tmpstat_hashfile.st_mode = 0;
12389 tmpstat_hashfile.st_nlink = 0;
12390 tmpstat_hashfile.st_uid = 0;
12391 tmpstat_hashfile.st_gid = 0;
12392 tmpstat_hashfile.st_rdev = 0;
12393 tmpstat_hashfile.st_atime = 0;
12394
12395 #ifdef _POSIX
12396 tmpstat_outfile.st_blksize = 0;
12397 tmpstat_outfile.st_blocks = 0;
12398
12399 tmpstat_hashfile.st_blksize = 0;
12400 tmpstat_hashfile.st_blocks = 0;
12401 #endif
12402
12403 #ifdef _POSIX
12404 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12405 {
12406 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12407
12408 return (-1);
12409 }
12410 #endif
12411
12412 #ifdef _WIN
12413 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12414 {
12415 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12416
12417 return (-1);
12418 }
12419 #endif
12420 }
12421 }
12422 }
12423
12424 /**
12425 * Remove duplicates
12426 */
12427
12428 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12429
12430 if (isSalted)
12431 {
12432 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12433 }
12434 else
12435 {
12436 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12437 }
12438
12439 uint hashes_cnt_orig = hashes_cnt;
12440
12441 hashes_cnt = 1;
12442
12443 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12444 {
12445 if (isSalted)
12446 {
12447 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12448 {
12449 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12450 }
12451 }
12452 else
12453 {
12454 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12455 }
12456
12457 if (hashes_pos > hashes_cnt)
12458 {
12459 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12460 }
12461
12462 hashes_cnt++;
12463 }
12464
12465 /**
12466 * Potfile removes
12467 */
12468
12469 uint potfile_remove_cracks = 0;
12470
12471 if (potfile_disable == 0)
12472 {
12473 hash_t hash_buf;
12474
12475 hash_buf.digest = mymalloc (dgst_size);
12476 hash_buf.salt = NULL;
12477 hash_buf.esalt = NULL;
12478 hash_buf.hash_info = NULL;
12479 hash_buf.cracked = 0;
12480
12481 if (isSalted)
12482 {
12483 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12484 }
12485
12486 if (esalt_size)
12487 {
12488 hash_buf.esalt = mymalloc (esalt_size);
12489 }
12490
12491 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12492
12493 // no solution for these special hash types (for instane because they use hashfile in output etc)
12494 if ((hash_mode != 5200) &&
12495 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12496 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12497 (hash_mode != 9000))
12498 {
12499 FILE *fp = fopen (potfile, "rb");
12500
12501 if (fp != NULL)
12502 {
12503 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12504
12505 // to be safe work with a copy (because of line_len loop, i etc)
12506 // moved up here because it's easier to handle continue case
12507 // it's just 64kb
12508
12509 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12510
12511 while (!feof (fp))
12512 {
12513 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12514
12515 if (ptr == NULL) break;
12516
12517 int line_len = strlen (line_buf);
12518
12519 if (line_len == 0) continue;
12520
12521 int iter = MAX_CUT_TRIES;
12522
12523 for (int i = line_len - 1; i && iter; i--, line_len--)
12524 {
12525 if (line_buf[i] != ':') continue;
12526
12527 if (isSalted)
12528 {
12529 memset (hash_buf.salt, 0, sizeof (salt_t));
12530 }
12531
12532 hash_t *found = NULL;
12533
12534 if (hash_mode == 6800)
12535 {
12536 if (i < 64) // 64 = 16 * uint in salt_buf[]
12537 {
12538 // manipulate salt_buf
12539 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12540
12541 hash_buf.salt->salt_len = i;
12542
12543 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12544 }
12545 }
12546 else if (hash_mode == 2500)
12547 {
12548 if (i < 64) // 64 = 16 * uint in salt_buf[]
12549 {
12550 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12551 // manipulate salt_buf
12552
12553 memcpy (line_buf_cpy, line_buf, i);
12554
12555 char *mac2_pos = strrchr (line_buf_cpy, ':');
12556
12557 if (mac2_pos == NULL) continue;
12558
12559 mac2_pos[0] = 0;
12560 mac2_pos++;
12561
12562 if (strlen (mac2_pos) != 12) continue;
12563
12564 char *mac1_pos = strrchr (line_buf_cpy, ':');
12565
12566 if (mac1_pos == NULL) continue;
12567
12568 mac1_pos[0] = 0;
12569 mac1_pos++;
12570
12571 if (strlen (mac1_pos) != 12) continue;
12572
12573 uint essid_length = mac1_pos - line_buf_cpy - 1;
12574
12575 // here we need the ESSID
12576 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12577
12578 hash_buf.salt->salt_len = essid_length;
12579
12580 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12581
12582 if (found)
12583 {
12584 wpa_t *wpa = (wpa_t *) found->esalt;
12585
12586 // compare hex string(s) vs binary MAC address(es)
12587
12588 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12589 {
12590 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12591 {
12592 found = NULL;
12593
12594 break;
12595 }
12596 }
12597
12598 // early skip ;)
12599 if (!found) continue;
12600
12601 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12602 {
12603 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12604 {
12605 found = NULL;
12606
12607 break;
12608 }
12609 }
12610 }
12611 }
12612 }
12613 else
12614 {
12615 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12616
12617 if (parser_status == PARSER_OK)
12618 {
12619 if (isSalted)
12620 {
12621 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12622 }
12623 else
12624 {
12625 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12626 }
12627 }
12628 }
12629
12630 if (found == NULL) continue;
12631
12632 if (!found->cracked) potfile_remove_cracks++;
12633
12634 found->cracked = 1;
12635
12636 if (found) break;
12637
12638 iter--;
12639 }
12640 }
12641
12642 myfree (line_buf_cpy);
12643
12644 myfree (line_buf);
12645
12646 fclose (fp);
12647 }
12648 }
12649
12650 if (esalt_size)
12651 {
12652 local_free (hash_buf.esalt);
12653 }
12654
12655 if (isSalted)
12656 {
12657 local_free (hash_buf.salt);
12658 }
12659
12660 local_free (hash_buf.digest);
12661 }
12662
12663 /**
12664 * Now generate all the buffers required for later
12665 */
12666
12667 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12668
12669 salt_t *salts_buf_new = NULL;
12670 void *esalts_buf_new = NULL;
12671
12672 if (isSalted)
12673 {
12674 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12675
12676 if (esalt_size)
12677 {
12678 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12679 }
12680 }
12681 else
12682 {
12683 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12684 }
12685
12686 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12687
12688 uint digests_cnt = hashes_cnt;
12689 uint digests_done = 0;
12690
12691 size_t size_digests = digests_cnt * dgst_size;
12692 size_t size_shown = digests_cnt * sizeof (uint);
12693
12694 uint *digests_shown = (uint *) mymalloc (size_shown);
12695 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12696
12697 uint salts_cnt = 0;
12698 uint salts_done = 0;
12699
12700 hashinfo_t **hash_info = NULL;
12701
12702 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12703 {
12704 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12705
12706 if (username && (remove || show))
12707 {
12708 uint user_pos;
12709
12710 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12711 {
12712 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12713
12714 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12715 }
12716 }
12717 }
12718
12719 uint *salts_shown = (uint *) mymalloc (size_shown);
12720
12721 salt_t *salt_buf;
12722
12723 {
12724 // copied from inner loop
12725
12726 salt_buf = &salts_buf_new[salts_cnt];
12727
12728 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12729
12730 if (esalt_size)
12731 {
12732 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12733 }
12734
12735 salt_buf->digests_cnt = 0;
12736 salt_buf->digests_done = 0;
12737 salt_buf->digests_offset = 0;
12738
12739 salts_cnt++;
12740 }
12741
12742 if (hashes_buf[0].cracked == 1)
12743 {
12744 digests_shown[0] = 1;
12745
12746 digests_done++;
12747
12748 salt_buf->digests_done++;
12749 }
12750
12751 salt_buf->digests_cnt++;
12752
12753 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12754
12755 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12756 {
12757 hash_info[0] = hashes_buf[0].hash_info;
12758 }
12759
12760 // copy from inner loop
12761
12762 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12763 {
12764 if (isSalted)
12765 {
12766 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12767 {
12768 salt_buf = &salts_buf_new[salts_cnt];
12769
12770 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12771
12772 if (esalt_size)
12773 {
12774 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12775 }
12776
12777 salt_buf->digests_cnt = 0;
12778 salt_buf->digests_done = 0;
12779 salt_buf->digests_offset = hashes_pos;
12780
12781 salts_cnt++;
12782 }
12783 }
12784
12785 if (hashes_buf[hashes_pos].cracked == 1)
12786 {
12787 digests_shown[hashes_pos] = 1;
12788
12789 digests_done++;
12790
12791 salt_buf->digests_done++;
12792 }
12793
12794 salt_buf->digests_cnt++;
12795
12796 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12797
12798 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12799 {
12800 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12801 }
12802 }
12803
12804 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12805 {
12806 salt_t *salt_buf = &salts_buf_new[salt_pos];
12807
12808 if (salt_buf->digests_done == salt_buf->digests_cnt)
12809 {
12810 salts_shown[salt_pos] = 1;
12811
12812 salts_done++;
12813 }
12814
12815 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12816 }
12817
12818 local_free (digests_buf);
12819 local_free (salts_buf);
12820 local_free (esalts_buf);
12821
12822 digests_buf = digests_buf_new;
12823 salts_buf = salts_buf_new;
12824 esalts_buf = esalts_buf_new;
12825
12826 local_free (hashes_buf);
12827
12828 /**
12829 * special modification not set from parser
12830 */
12831
12832 switch (hash_mode)
12833 {
12834 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12835 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12836 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12837 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12838 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12839 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12840 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12841 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12842 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12843 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12844 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12845 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12846 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12847 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12848 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12849 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12850 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12851 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12852 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12853 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12854 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12855 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12856 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12857 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12858 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12859 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12860 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12861 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12862 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12863 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12864 }
12865
12866 if (truecrypt_keyfiles)
12867 {
12868 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12869
12870 char *keyfiles = strdup (truecrypt_keyfiles);
12871
12872 char *keyfile = strtok (keyfiles, ",");
12873
12874 do
12875 {
12876 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12877
12878 } while ((keyfile = strtok (NULL, ",")) != NULL);
12879
12880 free (keyfiles);
12881 }
12882
12883 if (veracrypt_keyfiles)
12884 {
12885 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12886
12887 char *keyfiles = strdup (veracrypt_keyfiles);
12888
12889 char *keyfile = strtok (keyfiles, ",");
12890
12891 do
12892 {
12893 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12894
12895 } while ((keyfile = strtok (NULL, ",")) != NULL);
12896
12897 free (keyfiles);
12898 }
12899
12900 data.digests_cnt = digests_cnt;
12901 data.digests_done = digests_done;
12902 data.digests_buf = digests_buf;
12903 data.digests_shown = digests_shown;
12904 data.digests_shown_tmp = digests_shown_tmp;
12905
12906 data.salts_cnt = salts_cnt;
12907 data.salts_done = salts_done;
12908 data.salts_buf = salts_buf;
12909 data.salts_shown = salts_shown;
12910
12911 data.esalts_buf = esalts_buf;
12912 data.hash_info = hash_info;
12913
12914 /**
12915 * Automatic Optimizers
12916 */
12917
12918 if (salts_cnt == 1)
12919 opti_type |= OPTI_TYPE_SINGLE_SALT;
12920
12921 if (digests_cnt == 1)
12922 opti_type |= OPTI_TYPE_SINGLE_HASH;
12923
12924 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12925 opti_type |= OPTI_TYPE_NOT_ITERATED;
12926
12927 if (attack_mode == ATTACK_MODE_BF)
12928 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12929
12930 data.opti_type = opti_type;
12931
12932 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12933 {
12934 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12935 {
12936 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12937 {
12938 if (opts_type & OPTS_TYPE_ST_ADD80)
12939 {
12940 opts_type &= ~OPTS_TYPE_ST_ADD80;
12941 opts_type |= OPTS_TYPE_PT_ADD80;
12942 }
12943
12944 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12945 {
12946 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12947 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12948 }
12949
12950 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12951 {
12952 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12953 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12954 }
12955 }
12956 }
12957 }
12958
12959 /**
12960 * Some algorithm, like descrypt, can benefit from JIT compilation
12961 */
12962
12963 int force_jit_compilation = -1;
12964
12965 if (hash_mode == 8900)
12966 {
12967 force_jit_compilation = 8900;
12968 }
12969 else if (hash_mode == 9300)
12970 {
12971 force_jit_compilation = 8900;
12972 }
12973 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12974 {
12975 force_jit_compilation = 1500;
12976 }
12977
12978 /**
12979 * generate bitmap tables
12980 */
12981
12982 const uint bitmap_shift1 = 5;
12983 const uint bitmap_shift2 = 13;
12984
12985 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12986
12987 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12988 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12989 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12990 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12991 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12992 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12993 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12994 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12995
12996 uint bitmap_bits;
12997 uint bitmap_nums;
12998 uint bitmap_mask;
12999 uint bitmap_size;
13000
13001 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13002 {
13003 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13004
13005 bitmap_nums = 1 << bitmap_bits;
13006
13007 bitmap_mask = bitmap_nums - 1;
13008
13009 bitmap_size = bitmap_nums * sizeof (uint);
13010
13011 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13012
13013 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;
13014 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;
13015
13016 break;
13017 }
13018
13019 bitmap_nums = 1 << bitmap_bits;
13020
13021 bitmap_mask = bitmap_nums - 1;
13022
13023 bitmap_size = bitmap_nums * sizeof (uint);
13024
13025 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);
13026 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);
13027
13028 /**
13029 * prepare quick rule
13030 */
13031
13032 data.rule_buf_l = rule_buf_l;
13033 data.rule_buf_r = rule_buf_r;
13034
13035 int rule_len_l = (int) strlen (rule_buf_l);
13036 int rule_len_r = (int) strlen (rule_buf_r);
13037
13038 data.rule_len_l = rule_len_l;
13039 data.rule_len_r = rule_len_r;
13040
13041 /**
13042 * load rules
13043 */
13044
13045 uint *all_kernel_rules_cnt = NULL;
13046
13047 kernel_rule_t **all_kernel_rules_buf = NULL;
13048
13049 if (rp_files_cnt)
13050 {
13051 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13052
13053 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13054 }
13055
13056 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13057
13058 int rule_len = 0;
13059
13060 for (uint i = 0; i < rp_files_cnt; i++)
13061 {
13062 uint kernel_rules_avail = 0;
13063
13064 uint kernel_rules_cnt = 0;
13065
13066 kernel_rule_t *kernel_rules_buf = NULL;
13067
13068 char *rp_file = rp_files[i];
13069
13070 char in[BLOCK_SIZE] = { 0 };
13071 char out[BLOCK_SIZE] = { 0 };
13072
13073 FILE *fp = NULL;
13074
13075 uint rule_line = 0;
13076
13077 if ((fp = fopen (rp_file, "rb")) == NULL)
13078 {
13079 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13080
13081 return (-1);
13082 }
13083
13084 while (!feof (fp))
13085 {
13086 memset (rule_buf, 0, HCBUFSIZ);
13087
13088 rule_len = fgetl (fp, rule_buf);
13089
13090 rule_line++;
13091
13092 if (rule_len == 0) continue;
13093
13094 if (rule_buf[0] == '#') continue;
13095
13096 if (kernel_rules_avail == kernel_rules_cnt)
13097 {
13098 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13099
13100 kernel_rules_avail += INCR_RULES;
13101 }
13102
13103 memset (in, 0, BLOCK_SIZE);
13104 memset (out, 0, BLOCK_SIZE);
13105
13106 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13107
13108 if (result == -1)
13109 {
13110 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13111
13112 continue;
13113 }
13114
13115 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13116 {
13117 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13118
13119 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13120
13121 continue;
13122 }
13123
13124 /* its so slow
13125 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13126 {
13127 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13128
13129 continue;
13130 }
13131 */
13132
13133 kernel_rules_cnt++;
13134 }
13135
13136 fclose (fp);
13137
13138 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13139
13140 all_kernel_rules_buf[i] = kernel_rules_buf;
13141 }
13142
13143 /**
13144 * merge rules or automatic rule generator
13145 */
13146
13147 uint kernel_rules_cnt = 0;
13148
13149 kernel_rule_t *kernel_rules_buf = NULL;
13150
13151 if (attack_mode == ATTACK_MODE_STRAIGHT)
13152 {
13153 if (rp_files_cnt)
13154 {
13155 kernel_rules_cnt = 1;
13156
13157 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13158
13159 repeats[0] = kernel_rules_cnt;
13160
13161 for (uint i = 0; i < rp_files_cnt; i++)
13162 {
13163 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13164
13165 repeats[i + 1] = kernel_rules_cnt;
13166 }
13167
13168 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13169
13170 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13171
13172 for (uint i = 0; i < kernel_rules_cnt; i++)
13173 {
13174 uint out_pos = 0;
13175
13176 kernel_rule_t *out = &kernel_rules_buf[i];
13177
13178 for (uint j = 0; j < rp_files_cnt; j++)
13179 {
13180 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13181 uint in_pos;
13182
13183 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13184
13185 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13186 {
13187 if (out_pos == RULES_MAX - 1)
13188 {
13189 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13190
13191 break;
13192 }
13193
13194 out->cmds[out_pos] = in->cmds[in_pos];
13195 }
13196 }
13197 }
13198
13199 local_free (repeats);
13200 }
13201 else if (rp_gen)
13202 {
13203 uint kernel_rules_avail = 0;
13204
13205 while (kernel_rules_cnt < rp_gen)
13206 {
13207 if (kernel_rules_avail == kernel_rules_cnt)
13208 {
13209 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13210
13211 kernel_rules_avail += INCR_RULES;
13212 }
13213
13214 memset (rule_buf, 0, HCBUFSIZ);
13215
13216 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13217
13218 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13219
13220 kernel_rules_cnt++;
13221 }
13222 }
13223 }
13224
13225 myfree (rule_buf);
13226
13227 /**
13228 * generate NOP rules
13229 */
13230
13231 if (kernel_rules_cnt == 0)
13232 {
13233 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13234
13235 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13236
13237 kernel_rules_cnt++;
13238 }
13239
13240 data.kernel_rules_cnt = kernel_rules_cnt;
13241 data.kernel_rules_buf = kernel_rules_buf;
13242
13243 /**
13244 * OpenCL platforms: detect
13245 */
13246
13247 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13248 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13249
13250 cl_uint platforms_cnt = 0;
13251 cl_uint platform_devices_cnt = 0;
13252
13253 if (keyspace == 0)
13254 {
13255 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13256
13257 if (platforms_cnt == 0)
13258 {
13259 log_info ("");
13260 log_info ("ATTENTION! No OpenCL compatible platform found");
13261 log_info ("");
13262 log_info ("You're probably missing the OpenCL runtime installation");
13263 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13264 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13265 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13266 log_info ("");
13267
13268 return (-1);
13269 }
13270
13271 if (opencl_platforms_filter != (uint) -1)
13272 {
13273 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13274
13275 if (opencl_platforms_filter > platform_cnt_mask)
13276 {
13277 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13278
13279 return (-1);
13280 }
13281 }
13282 }
13283
13284 /**
13285 * OpenCL device types:
13286 * 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.
13287 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13288 */
13289
13290 if (opencl_device_types == NULL)
13291 {
13292 cl_device_type device_types_all = 0;
13293
13294 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13295 {
13296 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13297
13298 cl_platform_id platform = platforms[platform_id];
13299
13300 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13301
13302 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13303 {
13304 cl_device_id device = platform_devices[platform_devices_id];
13305
13306 cl_device_type device_type;
13307
13308 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13309
13310 device_types_all |= device_type;
13311 }
13312 }
13313
13314 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13315 {
13316 device_types_filter |= CL_DEVICE_TYPE_CPU;
13317 }
13318 }
13319
13320 /**
13321 * OpenCL devices: simply push all devices from all platforms into the same device array
13322 */
13323
13324 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13325
13326 data.devices_param = devices_param;
13327
13328 uint devices_cnt = 0;
13329
13330 uint devices_active = 0;
13331
13332 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13333 {
13334 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13335
13336 cl_platform_id platform = platforms[platform_id];
13337
13338 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13339
13340 char platform_vendor[INFOSZ] = { 0 };
13341
13342 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13343
13344 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13345 // this causes trouble with vendor id based macros
13346 // we'll assign generic to those without special optimization available
13347
13348 cl_uint platform_vendor_id = 0;
13349
13350 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13351 {
13352 platform_vendor_id = VENDOR_ID_AMD;
13353 }
13354 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13355 {
13356 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13357 }
13358 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13359 {
13360 platform_vendor_id = VENDOR_ID_APPLE;
13361 }
13362 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13363 {
13364 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13365 }
13366 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13367 {
13368 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13369 }
13370 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13371 {
13372 platform_vendor_id = VENDOR_ID_MESA;
13373 }
13374 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13375 {
13376 platform_vendor_id = VENDOR_ID_NV;
13377 }
13378 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13379 {
13380 platform_vendor_id = VENDOR_ID_POCL;
13381 }
13382 else
13383 {
13384 platform_vendor_id = VENDOR_ID_GENERIC;
13385 }
13386
13387 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13388 {
13389 size_t param_value_size = 0;
13390
13391 const uint device_id = devices_cnt;
13392
13393 hc_device_param_t *device_param = &data.devices_param[device_id];
13394
13395 device_param->platform_vendor_id = platform_vendor_id;
13396
13397 device_param->device = platform_devices[platform_devices_id];
13398
13399 device_param->device_id = device_id;
13400
13401 device_param->platform_devices_id = platform_devices_id;
13402
13403 // device_type
13404
13405 cl_device_type device_type;
13406
13407 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13408
13409 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13410
13411 device_param->device_type = device_type;
13412
13413 // device_name
13414
13415 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13416
13417 char *device_name = (char *) mymalloc (param_value_size);
13418
13419 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13420
13421 device_param->device_name = device_name;
13422
13423 // device_vendor
13424
13425 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13426
13427 char *device_vendor = (char *) mymalloc (param_value_size);
13428
13429 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13430
13431 device_param->device_vendor = device_vendor;
13432
13433 cl_uint device_vendor_id = 0;
13434
13435 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13436 {
13437 device_vendor_id = VENDOR_ID_AMD;
13438 }
13439 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13440 {
13441 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13442 }
13443 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13444 {
13445 device_vendor_id = VENDOR_ID_APPLE;
13446 }
13447 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13448 {
13449 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13450 }
13451 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13452 {
13453 device_vendor_id = VENDOR_ID_INTEL_SDK;
13454 }
13455 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13456 {
13457 device_vendor_id = VENDOR_ID_MESA;
13458 }
13459 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13460 {
13461 device_vendor_id = VENDOR_ID_NV;
13462 }
13463 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13464 {
13465 device_vendor_id = VENDOR_ID_POCL;
13466 }
13467 else
13468 {
13469 device_vendor_id = VENDOR_ID_GENERIC;
13470 }
13471
13472 device_param->device_vendor_id = device_vendor_id;
13473
13474 // tuning db
13475
13476 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13477
13478 // device_version
13479
13480 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13481
13482 char *device_version = (char *) mymalloc (param_value_size);
13483
13484 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13485
13486 device_param->device_version = device_version;
13487
13488 // device_opencl_version
13489
13490 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13491
13492 char *device_opencl_version = (char *) mymalloc (param_value_size);
13493
13494 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13495
13496 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13497
13498 myfree (device_opencl_version);
13499
13500 // vector_width
13501
13502 cl_uint vector_width;
13503
13504 if (opencl_vector_width_chgd == 0)
13505 {
13506 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13507 {
13508 if (opti_type & OPTI_TYPE_USES_BITS_64)
13509 {
13510 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13511 }
13512 else
13513 {
13514 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13515 }
13516 }
13517 else
13518 {
13519 vector_width = (cl_uint) tuningdb_entry->vector_width;
13520 }
13521 }
13522 else
13523 {
13524 vector_width = opencl_vector_width;
13525 }
13526
13527 if (vector_width > 16) vector_width = 16;
13528
13529 device_param->vector_width = vector_width;
13530
13531 // max_compute_units
13532
13533 cl_uint device_processors;
13534
13535 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13536
13537 device_param->device_processors = device_processors;
13538
13539 // device_maxmem_alloc
13540 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13541
13542 cl_ulong device_maxmem_alloc;
13543
13544 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13545
13546 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13547
13548 // device_global_mem
13549
13550 cl_ulong device_global_mem;
13551
13552 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13553
13554 device_param->device_global_mem = device_global_mem;
13555
13556 // max_work_group_size
13557
13558 size_t device_maxworkgroup_size;
13559
13560 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13561
13562 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13563
13564 // max_clock_frequency
13565
13566 cl_uint device_maxclock_frequency;
13567
13568 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13569
13570 device_param->device_maxclock_frequency = device_maxclock_frequency;
13571
13572 // device_endian_little
13573
13574 cl_bool device_endian_little;
13575
13576 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13577
13578 if (device_endian_little == CL_FALSE)
13579 {
13580 if (data.quiet == 0) log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13581
13582 device_param->skipped = 1;
13583 }
13584
13585 // device_available
13586
13587 cl_bool device_available;
13588
13589 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13590
13591 if (device_available == CL_FALSE)
13592 {
13593 if (data.quiet == 0) log_info ("Device #%u: WARNING: device not available", device_id + 1);
13594
13595 device_param->skipped = 1;
13596 }
13597
13598 // device_compiler_available
13599
13600 cl_bool device_compiler_available;
13601
13602 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13603
13604 if (device_compiler_available == CL_FALSE)
13605 {
13606 if (data.quiet == 0) log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13607
13608 device_param->skipped = 1;
13609 }
13610
13611 // device_execution_capabilities
13612
13613 cl_device_exec_capabilities device_execution_capabilities;
13614
13615 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13616
13617 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13618 {
13619 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13620
13621 device_param->skipped = 1;
13622 }
13623
13624 // device_extensions
13625
13626 size_t device_extensions_size;
13627
13628 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13629
13630 char *device_extensions = mymalloc (device_extensions_size + 1);
13631
13632 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13633
13634 if (strstr (device_extensions, "base_atomics") == 0)
13635 {
13636 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13637
13638 device_param->skipped = 1;
13639 }
13640
13641 if (strstr (device_extensions, "byte_addressable_store") == 0)
13642 {
13643 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13644
13645 device_param->skipped = 1;
13646 }
13647
13648 myfree (device_extensions);
13649
13650 // device_local_mem_size
13651
13652 cl_ulong device_local_mem_size;
13653
13654 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13655
13656 if (device_local_mem_size < 32768)
13657 {
13658 if (data.quiet == 0) log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13659
13660 device_param->skipped = 1;
13661 }
13662
13663 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13664 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13665 // This results in both utilizing it for 50%
13666 // However, Intel has much better SIMD control over their own hardware
13667 // It makes sense to give them full control over their own hardware
13668
13669 if (device_type & CL_DEVICE_TYPE_CPU)
13670 {
13671 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13672 {
13673 if (data.quiet == 0) log_info ("Device #%u: WARNING: not native intel opencl platform", device_id + 1);
13674
13675 device_param->skipped = 1;
13676 }
13677 }
13678
13679 // skipped
13680
13681 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13682 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13683
13684 // driver_version
13685
13686 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13687
13688 char *driver_version = (char *) mymalloc (param_value_size);
13689
13690 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13691
13692 device_param->driver_version = driver_version;
13693
13694 // device_name_chksum
13695
13696 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13697
13698 #if __x86_64__
13699 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);
13700 #else
13701 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);
13702 #endif
13703
13704 uint device_name_digest[4] = { 0 };
13705
13706 md5_64 ((uint *) device_name_chksum, device_name_digest);
13707
13708 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13709
13710 device_param->device_name_chksum = device_name_chksum;
13711
13712 // device_processor_cores
13713
13714 if (device_type & CL_DEVICE_TYPE_CPU)
13715 {
13716 cl_uint device_processor_cores = 1;
13717
13718 device_param->device_processor_cores = device_processor_cores;
13719 }
13720
13721 if (device_type & CL_DEVICE_TYPE_GPU)
13722 {
13723 if (device_vendor_id == VENDOR_ID_AMD)
13724 {
13725 cl_uint device_processor_cores = 0;
13726
13727 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13728
13729 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13730
13731 device_param->device_processor_cores = device_processor_cores;
13732 }
13733 else if (device_vendor_id == VENDOR_ID_NV)
13734 {
13735 cl_uint kernel_exec_timeout = 0;
13736
13737 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13738
13739 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13740
13741 device_param->kernel_exec_timeout = kernel_exec_timeout;
13742
13743 cl_uint device_processor_cores = 0;
13744
13745 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13746
13747 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13748
13749 device_param->device_processor_cores = device_processor_cores;
13750
13751 cl_uint sm_minor = 0;
13752 cl_uint sm_major = 0;
13753
13754 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13755 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13756
13757 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13758 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13759
13760 device_param->sm_minor = sm_minor;
13761 device_param->sm_major = sm_major;
13762 }
13763 else
13764 {
13765 cl_uint device_processor_cores = 1;
13766
13767 device_param->device_processor_cores = device_processor_cores;
13768 }
13769 }
13770
13771 // display results
13772
13773 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13774 {
13775 if (machine_readable == 0)
13776 {
13777 if (device_param->skipped == 0)
13778 {
13779 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13780 device_id + 1,
13781 device_name,
13782 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13783 (unsigned int) (device_global_mem / 1024 / 1024),
13784 (unsigned int) device_processors);
13785 }
13786 else
13787 {
13788 log_info ("Device #%u: %s, skipped",
13789 device_id + 1,
13790 device_name);
13791 }
13792 }
13793 }
13794
13795 // common driver check
13796
13797 if (device_param->skipped == 0)
13798 {
13799 if (device_type & CL_DEVICE_TYPE_GPU)
13800 {
13801 if (platform_vendor_id == VENDOR_ID_AMD)
13802 {
13803 int catalyst_check = (force == 1) ? 0 : 1;
13804
13805 int catalyst_warn = 0;
13806
13807 int catalyst_broken = 0;
13808
13809 if (catalyst_check == 1)
13810 {
13811 catalyst_warn = 1;
13812
13813 // v14.9 and higher
13814 if (atoi (device_param->driver_version) >= 1573)
13815 {
13816 catalyst_warn = 0;
13817 }
13818
13819 catalyst_check = 0;
13820 }
13821
13822 if (catalyst_broken == 1)
13823 {
13824 log_info ("");
13825 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13826 log_info ("It will pass over cracked hashes and does not report them as cracked");
13827 log_info ("You are STRONGLY encouraged not to use it");
13828 log_info ("You can use --force to override this but do not post error reports if you do so");
13829 log_info ("");
13830
13831 return (-1);
13832 }
13833
13834 if (catalyst_warn == 1)
13835 {
13836 log_info ("");
13837 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13838 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13839 log_info ("See hashcat's homepage for official supported catalyst drivers");
13840 #ifdef _WIN
13841 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13842 #endif
13843 log_info ("You can use --force to override this but do not post error reports if you do so");
13844 log_info ("");
13845
13846 return (-1);
13847 }
13848 }
13849 else if (platform_vendor_id == VENDOR_ID_NV)
13850 {
13851 if (device_param->kernel_exec_timeout != 0)
13852 {
13853 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);
13854 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13855 }
13856 }
13857 }
13858
13859 /* turns out pocl still creates segfaults (because of llvm)
13860 if (device_type & CL_DEVICE_TYPE_CPU)
13861 {
13862 if (platform_vendor_id == VENDOR_ID_AMD)
13863 {
13864 if (force == 0)
13865 {
13866 log_info ("");
13867 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13868 log_info ("You are STRONGLY encouraged not to use it");
13869 log_info ("You can use --force to override this but do not post error reports if you do so");
13870 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13871 log_info ("");
13872
13873 return (-1);
13874 }
13875 }
13876 }
13877 */
13878
13879 /**
13880 * kernel accel and loops tuning db adjustment
13881 */
13882
13883 device_param->kernel_accel_min = 1;
13884 device_param->kernel_accel_max = 1024;
13885
13886 device_param->kernel_loops_min = 1;
13887 device_param->kernel_loops_max = 1024;
13888
13889 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13890
13891 if (tuningdb_entry)
13892 {
13893 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13894 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13895
13896 if (_kernel_accel)
13897 {
13898 device_param->kernel_accel_min = _kernel_accel;
13899 device_param->kernel_accel_max = _kernel_accel;
13900 }
13901
13902 if (_kernel_loops)
13903 {
13904 if (workload_profile == 1)
13905 {
13906 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13907 }
13908 else if (workload_profile == 2)
13909 {
13910 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13911 }
13912
13913 device_param->kernel_loops_min = _kernel_loops;
13914 device_param->kernel_loops_max = _kernel_loops;
13915 }
13916 }
13917
13918 // commandline parameters overwrite tuningdb entries
13919
13920 if (kernel_accel)
13921 {
13922 device_param->kernel_accel_min = kernel_accel;
13923 device_param->kernel_accel_max = kernel_accel;
13924 }
13925
13926 if (kernel_loops)
13927 {
13928 device_param->kernel_loops_min = kernel_loops;
13929 device_param->kernel_loops_max = kernel_loops;
13930 }
13931
13932 /**
13933 * activate device
13934 */
13935
13936 devices_active++;
13937 }
13938
13939 // next please
13940
13941 devices_cnt++;
13942 }
13943 }
13944
13945 if (keyspace == 0 && devices_active == 0)
13946 {
13947 log_error ("ERROR: No devices found/left");
13948
13949 return (-1);
13950 }
13951
13952 // 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)
13953
13954 if (devices_filter != (uint) -1)
13955 {
13956 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13957
13958 if (devices_filter > devices_cnt_mask)
13959 {
13960 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13961
13962 return (-1);
13963 }
13964 }
13965
13966 data.devices_cnt = devices_cnt;
13967
13968 data.devices_active = devices_active;
13969
13970 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13971 {
13972 if (machine_readable == 0)
13973 {
13974 log_info ("");
13975 }
13976 }
13977
13978 /**
13979 * HM devices: init
13980 */
13981
13982 #ifdef HAVE_HWMON
13983 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
13984 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
13985
13986 if (gpu_temp_disable == 0)
13987 {
13988 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13989
13990 if (nvml_init (nvml) == 0)
13991 data.hm_nv = nvml;
13992
13993 if (data.hm_nv)
13994 {
13995 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13996 {
13997 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13998
13999 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
14000
14001 int tmp_out = 0;
14002
14003 for (int i = 0; i < tmp_in; i++)
14004 {
14005 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
14006 }
14007
14008 for (int i = 0; i < tmp_out; i++)
14009 {
14010 unsigned int speed;
14011
14012 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 0, hm_adapters_nv[i].adapter_index.nv, &speed) == NVML_SUCCESS) hm_adapters_nv[i].fan_get_supported = 1;
14013
14014 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14015
14016 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, NVML_GOM_ALL_ON);
14017 }
14018 }
14019 }
14020
14021 data.hm_amd = NULL;
14022
14023 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14024
14025 if (adl_init (adl) == 0)
14026 data.hm_amd = adl;
14027
14028 if (data.hm_amd)
14029 {
14030 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14031 {
14032 // total number of adapters
14033
14034 int hm_adapters_num;
14035
14036 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
14037
14038 // adapter info
14039
14040 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
14041
14042 if (lpAdapterInfo == NULL) return (-1);
14043
14044 // get a list (of ids of) valid/usable adapters
14045
14046 int num_adl_adapters = 0;
14047
14048 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14049
14050 if (num_adl_adapters > 0)
14051 {
14052 hc_thread_mutex_lock (mux_adl);
14053
14054 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
14055
14056 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14057
14058 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14059 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14060
14061 hc_thread_mutex_unlock (mux_adl);
14062 }
14063
14064 myfree (valid_adl_device_list);
14065 myfree (lpAdapterInfo);
14066 }
14067 }
14068
14069 if (data.hm_amd == NULL && data.hm_nv == NULL)
14070 {
14071 gpu_temp_disable = 1;
14072 }
14073 }
14074
14075 /**
14076 * OpenCL devices: allocate buffer for device specific information
14077 */
14078
14079 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14080 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14081
14082 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14083
14084 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14085
14086 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14087
14088 /**
14089 * User-defined GPU temp handling
14090 */
14091
14092 if (gpu_temp_disable == 1)
14093 {
14094 gpu_temp_abort = 0;
14095 gpu_temp_retain = 0;
14096 }
14097
14098 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14099 {
14100 if (gpu_temp_abort < gpu_temp_retain)
14101 {
14102 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14103
14104 return (-1);
14105 }
14106 }
14107
14108 data.gpu_temp_disable = gpu_temp_disable;
14109 data.gpu_temp_abort = gpu_temp_abort;
14110 data.gpu_temp_retain = gpu_temp_retain;
14111 #endif
14112
14113 /**
14114 * enable custom signal handler(s)
14115 */
14116
14117 if (benchmark == 0)
14118 {
14119 hc_signal (sigHandler_default);
14120 }
14121 else
14122 {
14123 hc_signal (sigHandler_benchmark);
14124 }
14125
14126 /**
14127 * inform the user
14128 */
14129
14130 if (data.quiet == 0)
14131 {
14132 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14133
14134 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);
14135
14136 if (attack_mode == ATTACK_MODE_STRAIGHT)
14137 {
14138 log_info ("Rules: %u", kernel_rules_cnt);
14139 }
14140
14141 if (opti_type)
14142 {
14143 log_info ("Applicable Optimizers:");
14144
14145 for (uint i = 0; i < 32; i++)
14146 {
14147 const uint opti_bit = 1u << i;
14148
14149 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14150 }
14151 }
14152
14153 /**
14154 * Watchdog and Temperature balance
14155 */
14156
14157 #ifdef HAVE_HWMON
14158 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
14159 {
14160 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14161 }
14162
14163 if (gpu_temp_abort == 0)
14164 {
14165 log_info ("Watchdog: Temperature abort trigger disabled");
14166 }
14167 else
14168 {
14169 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14170 }
14171
14172 if (gpu_temp_retain == 0)
14173 {
14174 log_info ("Watchdog: Temperature retain trigger disabled");
14175 }
14176 else
14177 {
14178 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14179 }
14180
14181 if (data.quiet == 0) log_info ("");
14182 #endif
14183 }
14184
14185 #ifdef HAVE_HWMON
14186
14187 /**
14188 * HM devices: copy
14189 */
14190
14191 if (gpu_temp_disable == 0)
14192 {
14193 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14194 {
14195 hc_device_param_t *device_param = &data.devices_param[device_id];
14196
14197 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14198
14199 if (device_param->skipped) continue;
14200
14201 const uint platform_devices_id = device_param->platform_devices_id;
14202
14203 if (device_param->device_vendor_id == VENDOR_ID_NV)
14204 {
14205 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14206 }
14207
14208 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14209 {
14210 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14211 }
14212 }
14213 }
14214
14215 /**
14216 * powertune on user request
14217 */
14218
14219 if (powertune_enable == 1)
14220 {
14221 hc_thread_mutex_lock (mux_adl);
14222
14223 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14224 {
14225 hc_device_param_t *device_param = &data.devices_param[device_id];
14226
14227 if (device_param->skipped) continue;
14228
14229 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14230 {
14231 /**
14232 * Temporary fix:
14233 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14234 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14235 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14236 * Driver / ADL bug?
14237 */
14238
14239 if (data.hm_device[device_id].od_version == 6)
14240 {
14241 int ADL_rc;
14242
14243 // check powertune capabilities first, if not available then skip device
14244
14245 int powertune_supported = 0;
14246
14247 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14248 {
14249 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14250
14251 return (-1);
14252 }
14253
14254 // first backup current value, we will restore it later
14255
14256 if (powertune_supported != 0)
14257 {
14258 // powercontrol settings
14259
14260 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14261
14262 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14263 {
14264 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14265 }
14266
14267 if (ADL_rc != ADL_OK)
14268 {
14269 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14270
14271 return (-1);
14272 }
14273
14274 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14275 {
14276 log_error ("ERROR: Failed to set new ADL PowerControl values");
14277
14278 return (-1);
14279 }
14280
14281 // clocks
14282
14283 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14284
14285 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14286
14287 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14288 {
14289 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14290
14291 return (-1);
14292 }
14293
14294 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14295
14296 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14297
14298 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14299 {
14300 log_error ("ERROR: Failed to get ADL device capabilities");
14301
14302 return (-1);
14303 }
14304
14305 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14306 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14307
14308 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14309 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14310
14311 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14312 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14313
14314 // warning if profile has too low max values
14315
14316 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14317 {
14318 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14319 }
14320
14321 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14322 {
14323 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14324 }
14325
14326 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14327
14328 performance_state->iNumberOfPerformanceLevels = 2;
14329
14330 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14331 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14332 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14333 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14334
14335 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14336 {
14337 log_info ("ERROR: Failed to set ADL performance state");
14338
14339 return (-1);
14340 }
14341
14342 local_free (performance_state);
14343 }
14344
14345 // set powertune value only
14346
14347 if (powertune_supported != 0)
14348 {
14349 // powertune set
14350 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14351
14352 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14353 {
14354 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14355
14356 return (-1);
14357 }
14358
14359 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14360 {
14361 log_error ("ERROR: Failed to set new ADL PowerControl values");
14362
14363 return (-1);
14364 }
14365 }
14366 }
14367 }
14368
14369 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14370 {
14371 // first backup current value, we will restore it later
14372
14373 unsigned int limit;
14374
14375 int powertune_supported = 0;
14376
14377 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nv, 0, data.hm_device[device_id].adapter_index.nv, &limit) == NVML_SUCCESS)
14378 {
14379 powertune_supported = 1;
14380 }
14381
14382 // if backup worked, activate the maximum allowed
14383
14384 if (powertune_supported != 0)
14385 {
14386 unsigned int minLimit;
14387 unsigned int maxLimit;
14388
14389 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nv, 0, data.hm_device[device_id].adapter_index.nv, &minLimit, &maxLimit) == NVML_SUCCESS)
14390 {
14391 if (maxLimit > 0)
14392 {
14393 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nv, 0, data.hm_device[device_id].adapter_index.nv, maxLimit) == NVML_SUCCESS)
14394 {
14395 // now we can be sure we need to reset later
14396
14397 nvml_power_limit[device_id] = limit;
14398 }
14399 }
14400 }
14401 }
14402 }
14403 }
14404
14405 hc_thread_mutex_unlock (mux_adl);
14406 }
14407
14408 #endif // HAVE_HWMON
14409
14410 #ifdef DEBUG
14411 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14412 #endif
14413
14414 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14415
14416 uint kernel_power_all = 0;
14417
14418 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14419 {
14420 /**
14421 * host buffer
14422 */
14423
14424 hc_device_param_t *device_param = &data.devices_param[device_id];
14425
14426 if (device_param->skipped) continue;
14427
14428 /**
14429 * device properties
14430 */
14431
14432 const char *device_name_chksum = device_param->device_name_chksum;
14433 const u32 device_processors = device_param->device_processors;
14434 const u32 device_processor_cores = device_param->device_processor_cores;
14435
14436 /**
14437 * create context for each device
14438 */
14439
14440 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14441
14442 /**
14443 * create command-queue
14444 */
14445
14446 // not supported with NV
14447 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14448
14449 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14450
14451 /**
14452 * kernel threads: some algorithms need a fixed kernel-threads count
14453 * because of shared memory usage or bitslice
14454 * there needs to be some upper limit, otherwise there's too much overhead
14455 */
14456
14457 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14458
14459 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14460 {
14461 kernel_threads = KERNEL_THREADS_MAX_CPU;
14462 }
14463
14464 if (hash_mode == 1500) kernel_threads = 64; // DES
14465 if (hash_mode == 3000) kernel_threads = 64; // DES
14466 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14467 if (hash_mode == 7500) kernel_threads = 64; // RC4
14468 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14469 if (hash_mode == 9700) kernel_threads = 64; // RC4
14470 if (hash_mode == 9710) kernel_threads = 64; // RC4
14471 if (hash_mode == 9800) kernel_threads = 64; // RC4
14472 if (hash_mode == 9810) kernel_threads = 64; // RC4
14473 if (hash_mode == 10400) kernel_threads = 64; // RC4
14474 if (hash_mode == 10410) kernel_threads = 64; // RC4
14475 if (hash_mode == 10500) kernel_threads = 64; // RC4
14476 if (hash_mode == 13100) kernel_threads = 64; // RC4
14477
14478 /**
14479 * create input buffers on device : calculate size of fixed memory buffers
14480 */
14481
14482 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14483 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14484
14485 device_param->size_root_css = size_root_css;
14486 device_param->size_markov_css = size_markov_css;
14487
14488 size_t size_results = sizeof (uint);
14489
14490 device_param->size_results = size_results;
14491
14492 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14493 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14494
14495 size_t size_plains = digests_cnt * sizeof (plain_t);
14496 size_t size_salts = salts_cnt * sizeof (salt_t);
14497 size_t size_esalts = salts_cnt * esalt_size;
14498
14499 device_param->size_plains = size_plains;
14500 device_param->size_digests = size_digests;
14501 device_param->size_shown = size_shown;
14502 device_param->size_salts = size_salts;
14503
14504 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14505 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14506 size_t size_tm = 32 * sizeof (bs_word_t);
14507
14508 // scryptV stuff
14509
14510 size_t size_scryptV = 1;
14511
14512 if ((hash_mode == 8900) || (hash_mode == 9300))
14513 {
14514 uint tmto_start = 0;
14515 uint tmto_stop = 10;
14516
14517 if (scrypt_tmto)
14518 {
14519 tmto_start = scrypt_tmto;
14520 }
14521 else
14522 {
14523 // in case the user did not specify the tmto manually
14524 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14525 // but set the lower end only in case the user has a device with too less memory
14526
14527 if (hash_mode == 8900)
14528 {
14529 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14530 {
14531 tmto_start = 1;
14532 }
14533 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14534 {
14535 tmto_start = 2;
14536 }
14537 }
14538 else if (hash_mode == 9300)
14539 {
14540 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14541 {
14542 tmto_start = 2;
14543 }
14544 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14545 {
14546 tmto_start = 2;
14547 }
14548 }
14549 }
14550
14551 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14552 {
14553 // TODO: in theory the following calculation needs to be done per salt, not global
14554 // we assume all hashes have the same scrypt settings
14555
14556 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14557
14558 size_scryptV /= 1 << tmto;
14559
14560 size_scryptV *= device_processors * device_processor_cores;
14561
14562 if (size_scryptV > device_param->device_maxmem_alloc)
14563 {
14564 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14565
14566 continue;
14567 }
14568
14569 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14570 {
14571 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14572 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14573 }
14574
14575 break;
14576 }
14577
14578 if (data.salts_buf[0].scrypt_phy == 0)
14579 {
14580 log_error ("ERROR: can't allocate enough device memory");
14581
14582 return -1;
14583 }
14584
14585 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14586 }
14587
14588 /**
14589 * some algorithms need a fixed kernel-loops count
14590 */
14591
14592 if (hash_mode == 1500)
14593 {
14594 const u32 kernel_loops_fixed = 1024;
14595
14596 device_param->kernel_loops_min = kernel_loops_fixed;
14597 device_param->kernel_loops_max = kernel_loops_fixed;
14598 }
14599
14600 if (hash_mode == 3000)
14601 {
14602 const u32 kernel_loops_fixed = 1024;
14603
14604 device_param->kernel_loops_min = kernel_loops_fixed;
14605 device_param->kernel_loops_max = kernel_loops_fixed;
14606 }
14607
14608 if (hash_mode == 8900)
14609 {
14610 const u32 kernel_loops_fixed = 1;
14611
14612 device_param->kernel_loops_min = kernel_loops_fixed;
14613 device_param->kernel_loops_max = kernel_loops_fixed;
14614 }
14615
14616 if (hash_mode == 9300)
14617 {
14618 const u32 kernel_loops_fixed = 1;
14619
14620 device_param->kernel_loops_min = kernel_loops_fixed;
14621 device_param->kernel_loops_max = kernel_loops_fixed;
14622 }
14623
14624 if (hash_mode == 12500)
14625 {
14626 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14627
14628 device_param->kernel_loops_min = kernel_loops_fixed;
14629 device_param->kernel_loops_max = kernel_loops_fixed;
14630 }
14631
14632 /**
14633 * some algorithms have a maximum kernel-loops count
14634 */
14635
14636 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14637 {
14638 u32 innerloop_cnt = 0;
14639
14640 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14641 {
14642 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14643 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14644 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14645 }
14646 else
14647 {
14648 innerloop_cnt = data.salts_buf[0].salt_iter;
14649 }
14650
14651 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14652 (innerloop_cnt <= device_param->kernel_loops_max))
14653 {
14654 device_param->kernel_loops_max = innerloop_cnt;
14655 }
14656 }
14657
14658 u32 kernel_accel_min = device_param->kernel_accel_min;
14659 u32 kernel_accel_max = device_param->kernel_accel_max;
14660
14661 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14662
14663 size_t size_pws = 4;
14664 size_t size_tmps = 4;
14665 size_t size_hooks = 4;
14666
14667 while (kernel_accel_max >= kernel_accel_min)
14668 {
14669 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14670
14671 // size_pws
14672
14673 size_pws = kernel_power_max * sizeof (pw_t);
14674
14675 // size_tmps
14676
14677 switch (hash_mode)
14678 {
14679 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14680 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14681 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14682 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14683 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14684 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14685 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14686 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14687 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14688 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14689 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14690 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14691 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14692 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14693 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14694 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14695 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14696 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14697 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14698 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14699 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14700 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14701 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14702 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14703 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14704 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14705 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14706 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14707 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14708 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14709 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14710 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14711 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14712 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14713 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14714 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14715 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14716 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14717 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14718 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14719 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14720 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14721 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14722 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14723 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14724 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14725 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14726 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14727 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14728 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14729 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14730 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14731 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14732 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14733 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14734 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14735 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14736 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14737 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14738 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14739 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14740 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14741 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14742 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14743 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14744 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14745 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14746 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14747 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14748 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14749 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14750 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14751 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14752 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14753 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14754 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14755 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14756 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14757 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14758 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14759 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14760 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14761 };
14762
14763 // size_hooks
14764
14765 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14766 {
14767 // none yet
14768 }
14769
14770 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14771 // if not, decrease amplifier and try again
14772
14773 int skip = 0;
14774
14775 const u64 size_total
14776 = bitmap_size
14777 + bitmap_size
14778 + bitmap_size
14779 + bitmap_size
14780 + bitmap_size
14781 + bitmap_size
14782 + bitmap_size
14783 + bitmap_size
14784 + size_bfs
14785 + size_combs
14786 + size_digests
14787 + size_esalts
14788 + size_hooks
14789 + size_markov_css
14790 + size_plains
14791 + size_pws
14792 + size_pws // not a bug
14793 + size_results
14794 + size_root_css
14795 + size_rules
14796 + size_rules_c
14797 + size_salts
14798 + size_scryptV
14799 + size_shown
14800 + size_tm
14801 + size_tmps;
14802
14803 // Don't ask me, ask AMD!
14804
14805 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14806 if (size_total > device_param->device_global_mem) skip = 1;
14807
14808 if (skip == 1)
14809 {
14810 kernel_accel_max--;
14811
14812 continue;
14813 }
14814
14815 break;
14816 }
14817
14818 /*
14819 if (kernel_accel_max == 0)
14820 {
14821 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14822
14823 return -1;
14824 }
14825 */
14826
14827 device_param->kernel_accel_min = kernel_accel_min;
14828 device_param->kernel_accel_max = kernel_accel_max;
14829
14830 /*
14831 if (kernel_accel_max < kernel_accel)
14832 {
14833 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14834
14835 device_param->kernel_accel = kernel_accel_max;
14836 }
14837 */
14838
14839 device_param->size_bfs = size_bfs;
14840 device_param->size_combs = size_combs;
14841 device_param->size_rules = size_rules;
14842 device_param->size_rules_c = size_rules_c;
14843 device_param->size_pws = size_pws;
14844 device_param->size_tmps = size_tmps;
14845 device_param->size_hooks = size_hooks;
14846
14847 // do not confuse kernel_accel_max with kernel_accel here
14848
14849 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14850
14851 device_param->kernel_threads = kernel_threads;
14852 device_param->kernel_power_user = kernel_power;
14853
14854 kernel_power_all += kernel_power;
14855
14856 /**
14857 * default building options
14858 */
14859
14860 char build_opts[1024] = { 0 };
14861
14862 // we don't have sm_* on vendors not NV but it doesn't matter
14863
14864 #if _WIN
14865 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);
14866 #else
14867 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);
14868 #endif
14869
14870 char build_opts_new[1024] = { 0 };
14871
14872 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);
14873
14874 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14875
14876 /*
14877 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14878 {
14879 // we do vectorizing much better than the auto-vectorizer
14880
14881 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14882
14883 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14884 }
14885 */
14886
14887 #ifdef DEBUG
14888 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14889 #endif
14890
14891 /**
14892 * main kernel
14893 */
14894
14895 {
14896 /**
14897 * kernel source filename
14898 */
14899
14900 char source_file[256] = { 0 };
14901
14902 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14903
14904 struct stat sst;
14905
14906 if (stat (source_file, &sst) == -1)
14907 {
14908 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14909
14910 return -1;
14911 }
14912
14913 /**
14914 * kernel cached filename
14915 */
14916
14917 char cached_file[256] = { 0 };
14918
14919 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14920
14921 int cached = 1;
14922
14923 struct stat cst;
14924
14925 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14926 {
14927 cached = 0;
14928 }
14929
14930 /**
14931 * kernel compile or load
14932 */
14933
14934 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14935
14936 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14937
14938 if (force_jit_compilation == -1)
14939 {
14940 if (cached == 0)
14941 {
14942 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14943
14944 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14945
14946 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14947
14948 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14949
14950 #ifdef DEBUG
14951 size_t build_log_size = 0;
14952
14953 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14954
14955 if (build_log_size > 1)
14956 {
14957 char *build_log = (char *) malloc (build_log_size + 1);
14958
14959 memset (build_log, 0, build_log_size + 1);
14960
14961 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14962
14963 puts (build_log);
14964
14965 free (build_log);
14966 }
14967 #endif
14968
14969 if (rc != 0)
14970 {
14971 device_param->skipped = true;
14972
14973 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14974
14975 continue;
14976 }
14977
14978 size_t binary_size;
14979
14980 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14981
14982 u8 *binary = (u8 *) mymalloc (binary_size);
14983
14984 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14985
14986 writeProgramBin (cached_file, binary, binary_size);
14987
14988 local_free (binary);
14989 }
14990 else
14991 {
14992 #ifdef DEBUG
14993 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14994 #endif
14995
14996 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14997
14998 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14999
15000 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15001 }
15002 }
15003 else
15004 {
15005 #ifdef DEBUG
15006 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15007 #endif
15008
15009 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15010
15011 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15012
15013 char build_opts_update[1024] = { 0 };
15014
15015 if (force_jit_compilation == 1500)
15016 {
15017 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15018 }
15019 else if (force_jit_compilation == 8900)
15020 {
15021 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);
15022 }
15023 else
15024 {
15025 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15026 }
15027
15028 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15029
15030 #ifdef DEBUG
15031 size_t build_log_size = 0;
15032
15033 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15034
15035 if (build_log_size > 1)
15036 {
15037 char *build_log = (char *) malloc (build_log_size + 1);
15038
15039 memset (build_log, 0, build_log_size + 1);
15040
15041 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15042
15043 puts (build_log);
15044
15045 free (build_log);
15046 }
15047 #endif
15048
15049 if (rc != 0)
15050 {
15051 device_param->skipped = true;
15052
15053 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15054 }
15055 }
15056
15057 local_free (kernel_lengths);
15058 local_free (kernel_sources[0]);
15059 local_free (kernel_sources);
15060 }
15061
15062 /**
15063 * word generator kernel
15064 */
15065
15066 if (attack_mode != ATTACK_MODE_STRAIGHT)
15067 {
15068 /**
15069 * kernel mp source filename
15070 */
15071
15072 char source_file[256] = { 0 };
15073
15074 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15075
15076 struct stat sst;
15077
15078 if (stat (source_file, &sst) == -1)
15079 {
15080 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15081
15082 return -1;
15083 }
15084
15085 /**
15086 * kernel mp cached filename
15087 */
15088
15089 char cached_file[256] = { 0 };
15090
15091 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15092
15093 int cached = 1;
15094
15095 struct stat cst;
15096
15097 if (stat (cached_file, &cst) == -1)
15098 {
15099 cached = 0;
15100 }
15101
15102 /**
15103 * kernel compile or load
15104 */
15105
15106 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15107
15108 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15109
15110 if (cached == 0)
15111 {
15112 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15113 if (quiet == 0) log_info ("");
15114
15115 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15116
15117 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15118
15119 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15120
15121 if (rc != 0)
15122 {
15123 device_param->skipped = true;
15124
15125 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15126
15127 continue;
15128 }
15129
15130 size_t binary_size;
15131
15132 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15133
15134 u8 *binary = (u8 *) mymalloc (binary_size);
15135
15136 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15137
15138 writeProgramBin (cached_file, binary, binary_size);
15139
15140 local_free (binary);
15141 }
15142 else
15143 {
15144 #ifdef DEBUG
15145 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15146 #endif
15147
15148 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15149
15150 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15151
15152 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15153 }
15154
15155 local_free (kernel_lengths);
15156 local_free (kernel_sources[0]);
15157 local_free (kernel_sources);
15158 }
15159
15160 /**
15161 * amplifier kernel
15162 */
15163
15164 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15165 {
15166
15167 }
15168 else
15169 {
15170 /**
15171 * kernel amp source filename
15172 */
15173
15174 char source_file[256] = { 0 };
15175
15176 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15177
15178 struct stat sst;
15179
15180 if (stat (source_file, &sst) == -1)
15181 {
15182 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15183
15184 return -1;
15185 }
15186
15187 /**
15188 * kernel amp cached filename
15189 */
15190
15191 char cached_file[256] = { 0 };
15192
15193 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15194
15195 int cached = 1;
15196
15197 struct stat cst;
15198
15199 if (stat (cached_file, &cst) == -1)
15200 {
15201 cached = 0;
15202 }
15203
15204 /**
15205 * kernel compile or load
15206 */
15207
15208 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15209
15210 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15211
15212 if (cached == 0)
15213 {
15214 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15215 if (quiet == 0) log_info ("");
15216
15217 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15218
15219 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15220
15221 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15222
15223 if (rc != 0)
15224 {
15225 device_param->skipped = true;
15226
15227 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15228
15229 continue;
15230 }
15231
15232 size_t binary_size;
15233
15234 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15235
15236 u8 *binary = (u8 *) mymalloc (binary_size);
15237
15238 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15239
15240 writeProgramBin (cached_file, binary, binary_size);
15241
15242 local_free (binary);
15243 }
15244 else
15245 {
15246 #ifdef DEBUG
15247 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15248 #endif
15249
15250 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15251
15252 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15253
15254 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15255 }
15256
15257 local_free (kernel_lengths);
15258 local_free (kernel_sources[0]);
15259 local_free (kernel_sources);
15260 }
15261
15262 // some algorithm collide too fast, make that impossible
15263
15264 if (benchmark == 1)
15265 {
15266 ((uint *) digests_buf)[0] = -1;
15267 ((uint *) digests_buf)[1] = -1;
15268 ((uint *) digests_buf)[2] = -1;
15269 ((uint *) digests_buf)[3] = -1;
15270 }
15271
15272 /**
15273 * global buffers
15274 */
15275
15276 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15277 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15278 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15279 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15280 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15281 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15282 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15283 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15284 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15285 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15286 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15287 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15288 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15289 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15290 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15291 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15292 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15293 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15294
15295 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);
15296 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);
15297 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);
15298 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);
15299 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);
15300 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);
15301 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);
15302 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);
15303 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15304 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15305 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15306
15307 /**
15308 * special buffers
15309 */
15310
15311 if (attack_kern == ATTACK_KERN_STRAIGHT)
15312 {
15313 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15314 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15315
15316 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15317 }
15318 else if (attack_kern == ATTACK_KERN_COMBI)
15319 {
15320 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15321 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15322 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15323 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15324 }
15325 else if (attack_kern == ATTACK_KERN_BF)
15326 {
15327 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15328 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15329 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15330 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15331 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15332 }
15333
15334 if (size_esalts)
15335 {
15336 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15337
15338 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15339 }
15340
15341 /**
15342 * main host data
15343 */
15344
15345 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15346
15347 device_param->pws_buf = pws_buf;
15348
15349 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15350
15351 device_param->combs_buf = combs_buf;
15352
15353 void *hooks_buf = mymalloc (size_hooks);
15354
15355 device_param->hooks_buf = hooks_buf;
15356
15357 /**
15358 * kernel args
15359 */
15360
15361 device_param->kernel_params_buf32[21] = bitmap_mask;
15362 device_param->kernel_params_buf32[22] = bitmap_shift1;
15363 device_param->kernel_params_buf32[23] = bitmap_shift2;
15364 device_param->kernel_params_buf32[24] = 0; // salt_pos
15365 device_param->kernel_params_buf32[25] = 0; // loop_pos
15366 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15367 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15368 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15369 device_param->kernel_params_buf32[29] = 0; // digests_offset
15370 device_param->kernel_params_buf32[30] = 0; // combs_mode
15371 device_param->kernel_params_buf32[31] = 0; // gid_max
15372
15373 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15374 ? &device_param->d_pws_buf
15375 : &device_param->d_pws_amp_buf;
15376 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15377 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15378 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15379 device_param->kernel_params[ 4] = &device_param->d_tmps;
15380 device_param->kernel_params[ 5] = &device_param->d_hooks;
15381 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15382 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15383 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15384 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15385 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15386 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15387 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15388 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15389 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15390 device_param->kernel_params[15] = &device_param->d_digests_buf;
15391 device_param->kernel_params[16] = &device_param->d_digests_shown;
15392 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15393 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15394 device_param->kernel_params[19] = &device_param->d_result;
15395 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15396 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15397 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15398 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15399 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15400 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15401 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15402 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15403 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15404 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15405 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15406 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15407
15408 device_param->kernel_params_mp_buf64[3] = 0;
15409 device_param->kernel_params_mp_buf32[4] = 0;
15410 device_param->kernel_params_mp_buf32[5] = 0;
15411 device_param->kernel_params_mp_buf32[6] = 0;
15412 device_param->kernel_params_mp_buf32[7] = 0;
15413 device_param->kernel_params_mp_buf32[8] = 0;
15414
15415 device_param->kernel_params_mp[0] = NULL;
15416 device_param->kernel_params_mp[1] = NULL;
15417 device_param->kernel_params_mp[2] = NULL;
15418 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15419 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15420 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15421 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15422 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15423 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15424
15425 device_param->kernel_params_mp_l_buf64[3] = 0;
15426 device_param->kernel_params_mp_l_buf32[4] = 0;
15427 device_param->kernel_params_mp_l_buf32[5] = 0;
15428 device_param->kernel_params_mp_l_buf32[6] = 0;
15429 device_param->kernel_params_mp_l_buf32[7] = 0;
15430 device_param->kernel_params_mp_l_buf32[8] = 0;
15431 device_param->kernel_params_mp_l_buf32[9] = 0;
15432
15433 device_param->kernel_params_mp_l[0] = NULL;
15434 device_param->kernel_params_mp_l[1] = NULL;
15435 device_param->kernel_params_mp_l[2] = NULL;
15436 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15437 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15438 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15439 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15440 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15441 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15442 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15443
15444 device_param->kernel_params_mp_r_buf64[3] = 0;
15445 device_param->kernel_params_mp_r_buf32[4] = 0;
15446 device_param->kernel_params_mp_r_buf32[5] = 0;
15447 device_param->kernel_params_mp_r_buf32[6] = 0;
15448 device_param->kernel_params_mp_r_buf32[7] = 0;
15449 device_param->kernel_params_mp_r_buf32[8] = 0;
15450
15451 device_param->kernel_params_mp_r[0] = NULL;
15452 device_param->kernel_params_mp_r[1] = NULL;
15453 device_param->kernel_params_mp_r[2] = NULL;
15454 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15455 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15456 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15457 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15458 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15459 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15460
15461 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15462 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15463
15464 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15465 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15466 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15467 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15468 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15469 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15470 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15471
15472 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15473 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15474
15475 device_param->kernel_params_memset_buf32[1] = 0; // value
15476 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15477
15478 device_param->kernel_params_memset[0] = NULL;
15479 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15480 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15481
15482 /**
15483 * kernel name
15484 */
15485
15486 size_t kernel_wgs_tmp;
15487
15488 char kernel_name[64] = { 0 };
15489
15490 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15491 {
15492 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15493 {
15494 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15495
15496 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15497
15498 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15499
15500 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15501
15502 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15503
15504 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15505 }
15506 else
15507 {
15508 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15509
15510 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15511
15512 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15513
15514 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15515
15516 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15517
15518 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15519 }
15520
15521 if (data.attack_mode == ATTACK_MODE_BF)
15522 {
15523 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15524 {
15525 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15526
15527 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15528
15529 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);
15530 }
15531 }
15532 }
15533 else
15534 {
15535 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15536
15537 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15538
15539 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15540
15541 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15542
15543 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15544
15545 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15546
15547 if (opts_type & OPTS_TYPE_HOOK12)
15548 {
15549 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15550
15551 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15552
15553 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);
15554 }
15555
15556 if (opts_type & OPTS_TYPE_HOOK23)
15557 {
15558 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15559
15560 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15561
15562 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);
15563 }
15564 }
15565
15566 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);
15567 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);
15568 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);
15569
15570 for (uint i = 0; i <= 20; i++)
15571 {
15572 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15573 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15574 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15575
15576 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15577 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15578 }
15579
15580 for (uint i = 21; i <= 31; i++)
15581 {
15582 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15583 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15584 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15585
15586 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15587 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15588 }
15589
15590 // GPU memset
15591
15592 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15593
15594 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);
15595
15596 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15597 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15598 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15599
15600 // MP start
15601
15602 if (attack_mode == ATTACK_MODE_BF)
15603 {
15604 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15605 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15606
15607 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);
15608 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);
15609
15610 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15611 {
15612 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15613 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15614 }
15615 }
15616 else if (attack_mode == ATTACK_MODE_HYBRID1)
15617 {
15618 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15619
15620 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);
15621 }
15622 else if (attack_mode == ATTACK_MODE_HYBRID2)
15623 {
15624 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15625
15626 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);
15627 }
15628
15629 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15630 {
15631 // nothing to do
15632 }
15633 else
15634 {
15635 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15636
15637 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);
15638 }
15639
15640 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15641 {
15642 // nothing to do
15643 }
15644 else
15645 {
15646 for (uint i = 0; i < 5; i++)
15647 {
15648 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15649 }
15650
15651 for (uint i = 5; i < 7; i++)
15652 {
15653 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15654 }
15655 }
15656
15657 // maybe this has been updated by clGetKernelWorkGroupInfo()
15658 // value can only be decreased, so we don't need to reallocate buffers
15659
15660 device_param->kernel_threads = kernel_threads;
15661
15662 // zero some data buffers
15663
15664 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15665 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15666 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15667 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15668 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15669 run_kernel_bzero (device_param, device_param->d_result, size_results);
15670
15671 /**
15672 * special buffers
15673 */
15674
15675 if (attack_kern == ATTACK_KERN_STRAIGHT)
15676 {
15677 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15678 }
15679 else if (attack_kern == ATTACK_KERN_COMBI)
15680 {
15681 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15682 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15683 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15684 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15685 }
15686 else if (attack_kern == ATTACK_KERN_BF)
15687 {
15688 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15689 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15690 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15691 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15692 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15693 }
15694
15695 #if defined(HAVE_HWMON)
15696
15697 /**
15698 * Store thermal target temperature so we can send a notice to user
15699 */
15700
15701 if (gpu_temp_disable == 0)
15702 {
15703 const int gpu_temp_threshold_slowdown = hm_get_threshold_slowdown_with_device_id (device_id);
15704 const int gpu_temp_threshold_shutdown = hm_get_threshold_slowdown_with_device_id (device_id);
15705
15706 data.hm_device[device_id].gpu_temp_threshold_slowdown = (gpu_temp_threshold_slowdown > 0) ? gpu_temp_threshold_slowdown : 10000;
15707 data.hm_device[device_id].gpu_temp_threshold_shutdown = (gpu_temp_threshold_shutdown > 0) ? gpu_temp_threshold_shutdown : 10000;
15708
15709 // we could use those numbers for gpu_temp_retain and gpu_temp_abort, too
15710 }
15711
15712 /**
15713 * Store initial fanspeed if gpu_temp_retain is enabled
15714 */
15715
15716 if (gpu_temp_disable == 0)
15717 {
15718 if (gpu_temp_retain != 0)
15719 {
15720 hc_thread_mutex_lock (mux_adl);
15721
15722 if (data.hm_device[device_id].fan_get_supported == 1)
15723 {
15724 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
15725 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
15726
15727 temp_retain_fanspeed_value[device_id] = fanspeed;
15728 temp_retain_fanpolicy_value[device_id] = fanpolicy;
15729
15730 // we also set it to tell the OS we take control over the fan and it's automatic controller
15731 // if it was set to automatic. we do not control user-defined fanspeeds.
15732
15733 if (fanpolicy == 1)
15734 {
15735 data.hm_device[device_id].fan_set_supported = 1;
15736
15737 int rc = -1;
15738
15739 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15740 {
15741 rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed, 1);
15742 }
15743 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15744 {
15745
15746 }
15747
15748 if (rc == 0)
15749 {
15750 data.hm_device[device_id].fan_set_supported = 1;
15751 }
15752 else
15753 {
15754 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
15755
15756 data.hm_device[device_id].fan_set_supported = 0;
15757 }
15758 }
15759 else
15760 {
15761 data.hm_device[device_id].fan_set_supported = 0;
15762 }
15763 }
15764
15765 hc_thread_mutex_unlock (mux_adl);
15766 }
15767 }
15768
15769 #endif // HAVE_HWMON
15770 }
15771
15772 data.kernel_power_all = kernel_power_all;
15773
15774 if (data.quiet == 0) log_info_nn ("");
15775
15776 /**
15777 * In benchmark-mode, inform user which algorithm is checked
15778 */
15779
15780 if (benchmark == 1)
15781 {
15782 if (machine_readable == 0)
15783 {
15784 quiet = 0;
15785
15786 data.quiet = quiet;
15787
15788 char *hash_type = strhashtype (data.hash_mode); // not a bug
15789
15790 log_info ("Hashtype: %s", hash_type);
15791 log_info ("");
15792 }
15793 }
15794
15795 /**
15796 * keep track of the progress
15797 */
15798
15799 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15800 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15801 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15802
15803 /**
15804 * open filehandles
15805 */
15806
15807 #if _WIN
15808 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15809 {
15810 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15811
15812 return (-1);
15813 }
15814
15815 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15816 {
15817 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15818
15819 return (-1);
15820 }
15821
15822 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15823 {
15824 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15825
15826 return (-1);
15827 }
15828 #endif
15829
15830 /**
15831 * dictionary pad
15832 */
15833
15834 segment_size *= (1024 * 1024);
15835
15836 data.segment_size = segment_size;
15837
15838 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15839
15840 wl_data->buf = (char *) mymalloc (segment_size);
15841 wl_data->avail = segment_size;
15842 wl_data->incr = segment_size;
15843 wl_data->cnt = 0;
15844 wl_data->pos = 0;
15845
15846 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15847
15848 data.wordlist_mode = wordlist_mode;
15849
15850 cs_t *css_buf = NULL;
15851 uint css_cnt = 0;
15852 uint dictcnt = 0;
15853 uint maskcnt = 1;
15854 char **masks = NULL;
15855 char **dictfiles = NULL;
15856
15857 uint mask_from_file = 0;
15858
15859 if (attack_mode == ATTACK_MODE_STRAIGHT)
15860 {
15861 if (wordlist_mode == WL_MODE_FILE)
15862 {
15863 int wls_left = myargc - (optind + 1);
15864
15865 for (int i = 0; i < wls_left; i++)
15866 {
15867 char *l0_filename = myargv[optind + 1 + i];
15868
15869 struct stat l0_stat;
15870
15871 if (stat (l0_filename, &l0_stat) == -1)
15872 {
15873 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15874
15875 return (-1);
15876 }
15877
15878 uint is_dir = S_ISDIR (l0_stat.st_mode);
15879
15880 if (is_dir == 0)
15881 {
15882 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15883
15884 dictcnt++;
15885
15886 dictfiles[dictcnt - 1] = l0_filename;
15887 }
15888 else
15889 {
15890 // do not allow --keyspace w/ a directory
15891
15892 if (keyspace == 1)
15893 {
15894 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15895
15896 return (-1);
15897 }
15898
15899 char **dictionary_files = NULL;
15900
15901 dictionary_files = scan_directory (l0_filename);
15902
15903 if (dictionary_files != NULL)
15904 {
15905 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15906
15907 for (int d = 0; dictionary_files[d] != NULL; d++)
15908 {
15909 char *l1_filename = dictionary_files[d];
15910
15911 struct stat l1_stat;
15912
15913 if (stat (l1_filename, &l1_stat) == -1)
15914 {
15915 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15916
15917 return (-1);
15918 }
15919
15920 if (S_ISREG (l1_stat.st_mode))
15921 {
15922 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15923
15924 dictcnt++;
15925
15926 dictfiles[dictcnt - 1] = strdup (l1_filename);
15927 }
15928 }
15929 }
15930
15931 local_free (dictionary_files);
15932 }
15933 }
15934
15935 if (dictcnt < 1)
15936 {
15937 log_error ("ERROR: No usable dictionary file found.");
15938
15939 return (-1);
15940 }
15941 }
15942 else if (wordlist_mode == WL_MODE_STDIN)
15943 {
15944 dictcnt = 1;
15945 }
15946 }
15947 else if (attack_mode == ATTACK_MODE_COMBI)
15948 {
15949 // display
15950
15951 char *dictfile1 = myargv[optind + 1 + 0];
15952 char *dictfile2 = myargv[optind + 1 + 1];
15953
15954 // find the bigger dictionary and use as base
15955
15956 FILE *fp1 = NULL;
15957 FILE *fp2 = NULL;
15958
15959 struct stat tmp_stat;
15960
15961 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15962 {
15963 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15964
15965 return (-1);
15966 }
15967
15968 if (stat (dictfile1, &tmp_stat) == -1)
15969 {
15970 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15971
15972 fclose (fp1);
15973
15974 return (-1);
15975 }
15976
15977 if (S_ISDIR (tmp_stat.st_mode))
15978 {
15979 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15980
15981 fclose (fp1);
15982
15983 return (-1);
15984 }
15985
15986 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15987 {
15988 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15989
15990 fclose (fp1);
15991
15992 return (-1);
15993 }
15994
15995 if (stat (dictfile2, &tmp_stat) == -1)
15996 {
15997 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15998
15999 fclose (fp1);
16000 fclose (fp2);
16001
16002 return (-1);
16003 }
16004
16005 if (S_ISDIR (tmp_stat.st_mode))
16006 {
16007 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16008
16009 fclose (fp1);
16010 fclose (fp2);
16011
16012 return (-1);
16013 }
16014
16015 data.combs_cnt = 1;
16016
16017 data.quiet = 1;
16018
16019 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16020
16021 data.quiet = quiet;
16022
16023 if (words1_cnt == 0)
16024 {
16025 log_error ("ERROR: %s: empty file", dictfile1);
16026
16027 fclose (fp1);
16028 fclose (fp2);
16029
16030 return (-1);
16031 }
16032
16033 data.combs_cnt = 1;
16034
16035 data.quiet = 1;
16036
16037 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16038
16039 data.quiet = quiet;
16040
16041 if (words2_cnt == 0)
16042 {
16043 log_error ("ERROR: %s: empty file", dictfile2);
16044
16045 fclose (fp1);
16046 fclose (fp2);
16047
16048 return (-1);
16049 }
16050
16051 fclose (fp1);
16052 fclose (fp2);
16053
16054 data.dictfile = dictfile1;
16055 data.dictfile2 = dictfile2;
16056
16057 if (words1_cnt >= words2_cnt)
16058 {
16059 data.combs_cnt = words2_cnt;
16060 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16061
16062 dictfiles = &data.dictfile;
16063
16064 dictcnt = 1;
16065 }
16066 else
16067 {
16068 data.combs_cnt = words1_cnt;
16069 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16070
16071 dictfiles = &data.dictfile2;
16072
16073 dictcnt = 1;
16074
16075 // we also have to switch wordlist related rules!
16076
16077 char *tmpc = data.rule_buf_l;
16078
16079 data.rule_buf_l = data.rule_buf_r;
16080 data.rule_buf_r = tmpc;
16081
16082 int tmpi = data.rule_len_l;
16083
16084 data.rule_len_l = data.rule_len_r;
16085 data.rule_len_r = tmpi;
16086 }
16087 }
16088 else if (attack_mode == ATTACK_MODE_BF)
16089 {
16090 char *mask = NULL;
16091
16092 maskcnt = 0;
16093
16094 if (benchmark == 0)
16095 {
16096 mask = myargv[optind + 1];
16097
16098 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16099
16100 if ((optind + 2) <= myargc)
16101 {
16102 struct stat file_stat;
16103
16104 if (stat (mask, &file_stat) == -1)
16105 {
16106 maskcnt = 1;
16107
16108 masks[maskcnt - 1] = mystrdup (mask);
16109 }
16110 else
16111 {
16112 int wls_left = myargc - (optind + 1);
16113
16114 uint masks_avail = INCR_MASKS;
16115
16116 for (int i = 0; i < wls_left; i++)
16117 {
16118 if (i != 0)
16119 {
16120 mask = myargv[optind + 1 + i];
16121
16122 if (stat (mask, &file_stat) == -1)
16123 {
16124 log_error ("ERROR: %s: %s", mask, strerror (errno));
16125
16126 return (-1);
16127 }
16128 }
16129
16130 uint is_file = S_ISREG (file_stat.st_mode);
16131
16132 if (is_file == 1)
16133 {
16134 FILE *mask_fp;
16135
16136 if ((mask_fp = fopen (mask, "r")) == NULL)
16137 {
16138 log_error ("ERROR: %s: %s", mask, strerror (errno));
16139
16140 return (-1);
16141 }
16142
16143 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16144
16145 while (!feof (mask_fp))
16146 {
16147 memset (line_buf, 0, HCBUFSIZ);
16148
16149 int line_len = fgetl (mask_fp, line_buf);
16150
16151 if (line_len == 0) continue;
16152
16153 if (line_buf[0] == '#') continue;
16154
16155 if (masks_avail == maskcnt)
16156 {
16157 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16158
16159 masks_avail += INCR_MASKS;
16160 }
16161
16162 masks[maskcnt] = mystrdup (line_buf);
16163
16164 maskcnt++;
16165 }
16166
16167 myfree (line_buf);
16168
16169 fclose (mask_fp);
16170 }
16171 else
16172 {
16173 log_error ("ERROR: %s: unsupported file-type", mask);
16174
16175 return (-1);
16176 }
16177 }
16178
16179 mask_from_file = 1;
16180 }
16181 }
16182 else
16183 {
16184 custom_charset_1 = (char *) "?l?d?u";
16185 custom_charset_2 = (char *) "?l?d";
16186 custom_charset_3 = (char *) "?l?d*!$@_";
16187
16188 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16189 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16190 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16191
16192 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16193
16194 wordlist_mode = WL_MODE_MASK;
16195
16196 data.wordlist_mode = wordlist_mode;
16197
16198 increment = 1;
16199
16200 maskcnt = 1;
16201 }
16202 }
16203 else
16204 {
16205 /**
16206 * generate full masks and charsets
16207 */
16208
16209 masks = (char **) mymalloc (sizeof (char *));
16210
16211 switch (hash_mode)
16212 {
16213 case 1731: pw_min = 5;
16214 pw_max = 5;
16215 mask = mystrdup ("?b?b?b?b?b");
16216 break;
16217 case 12500: pw_min = 5;
16218 pw_max = 5;
16219 mask = mystrdup ("?b?b?b?b?b");
16220 break;
16221 default: pw_min = 7;
16222 pw_max = 7;
16223 mask = mystrdup ("?b?b?b?b?b?b?b");
16224 break;
16225 }
16226
16227 maskcnt = 1;
16228
16229 masks[maskcnt - 1] = mystrdup (mask);
16230
16231 wordlist_mode = WL_MODE_MASK;
16232
16233 data.wordlist_mode = wordlist_mode;
16234
16235 increment = 1;
16236 }
16237
16238 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16239
16240 if (increment)
16241 {
16242 if (increment_min > pw_min) pw_min = increment_min;
16243
16244 if (increment_max < pw_max) pw_max = increment_max;
16245 }
16246 }
16247 else if (attack_mode == ATTACK_MODE_HYBRID1)
16248 {
16249 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16250
16251 // display
16252
16253 char *mask = myargv[myargc - 1];
16254
16255 maskcnt = 0;
16256
16257 masks = (char **) mymalloc (1 * sizeof (char *));
16258
16259 // mod
16260
16261 struct stat file_stat;
16262
16263 if (stat (mask, &file_stat) == -1)
16264 {
16265 maskcnt = 1;
16266
16267 masks[maskcnt - 1] = mystrdup (mask);
16268 }
16269 else
16270 {
16271 uint is_file = S_ISREG (file_stat.st_mode);
16272
16273 if (is_file == 1)
16274 {
16275 FILE *mask_fp;
16276
16277 if ((mask_fp = fopen (mask, "r")) == NULL)
16278 {
16279 log_error ("ERROR: %s: %s", mask, strerror (errno));
16280
16281 return (-1);
16282 }
16283
16284 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16285
16286 uint masks_avail = 1;
16287
16288 while (!feof (mask_fp))
16289 {
16290 memset (line_buf, 0, HCBUFSIZ);
16291
16292 int line_len = fgetl (mask_fp, line_buf);
16293
16294 if (line_len == 0) continue;
16295
16296 if (line_buf[0] == '#') continue;
16297
16298 if (masks_avail == maskcnt)
16299 {
16300 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16301
16302 masks_avail += INCR_MASKS;
16303 }
16304
16305 masks[maskcnt] = mystrdup (line_buf);
16306
16307 maskcnt++;
16308 }
16309
16310 myfree (line_buf);
16311
16312 fclose (mask_fp);
16313
16314 mask_from_file = 1;
16315 }
16316 else
16317 {
16318 maskcnt = 1;
16319
16320 masks[maskcnt - 1] = mystrdup (mask);
16321 }
16322 }
16323
16324 // base
16325
16326 int wls_left = myargc - (optind + 2);
16327
16328 for (int i = 0; i < wls_left; i++)
16329 {
16330 char *filename = myargv[optind + 1 + i];
16331
16332 struct stat file_stat;
16333
16334 if (stat (filename, &file_stat) == -1)
16335 {
16336 log_error ("ERROR: %s: %s", filename, strerror (errno));
16337
16338 return (-1);
16339 }
16340
16341 uint is_dir = S_ISDIR (file_stat.st_mode);
16342
16343 if (is_dir == 0)
16344 {
16345 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16346
16347 dictcnt++;
16348
16349 dictfiles[dictcnt - 1] = filename;
16350 }
16351 else
16352 {
16353 // do not allow --keyspace w/ a directory
16354
16355 if (keyspace == 1)
16356 {
16357 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16358
16359 return (-1);
16360 }
16361
16362 char **dictionary_files = NULL;
16363
16364 dictionary_files = scan_directory (filename);
16365
16366 if (dictionary_files != NULL)
16367 {
16368 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16369
16370 for (int d = 0; dictionary_files[d] != NULL; d++)
16371 {
16372 char *l1_filename = dictionary_files[d];
16373
16374 struct stat l1_stat;
16375
16376 if (stat (l1_filename, &l1_stat) == -1)
16377 {
16378 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16379
16380 return (-1);
16381 }
16382
16383 if (S_ISREG (l1_stat.st_mode))
16384 {
16385 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16386
16387 dictcnt++;
16388
16389 dictfiles[dictcnt - 1] = strdup (l1_filename);
16390 }
16391 }
16392 }
16393
16394 local_free (dictionary_files);
16395 }
16396 }
16397
16398 if (dictcnt < 1)
16399 {
16400 log_error ("ERROR: No usable dictionary file found.");
16401
16402 return (-1);
16403 }
16404
16405 if (increment)
16406 {
16407 maskcnt = 0;
16408
16409 uint mask_min = increment_min; // we can't reject smaller masks here
16410 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16411
16412 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16413 {
16414 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16415
16416 if (cur_mask == NULL) break;
16417
16418 masks[maskcnt] = cur_mask;
16419
16420 maskcnt++;
16421
16422 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16423 }
16424 }
16425 }
16426 else if (attack_mode == ATTACK_MODE_HYBRID2)
16427 {
16428 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16429
16430 // display
16431
16432 char *mask = myargv[optind + 1 + 0];
16433
16434 maskcnt = 0;
16435
16436 masks = (char **) mymalloc (1 * sizeof (char *));
16437
16438 // mod
16439
16440 struct stat file_stat;
16441
16442 if (stat (mask, &file_stat) == -1)
16443 {
16444 maskcnt = 1;
16445
16446 masks[maskcnt - 1] = mystrdup (mask);
16447 }
16448 else
16449 {
16450 uint is_file = S_ISREG (file_stat.st_mode);
16451
16452 if (is_file == 1)
16453 {
16454 FILE *mask_fp;
16455
16456 if ((mask_fp = fopen (mask, "r")) == NULL)
16457 {
16458 log_error ("ERROR: %s: %s", mask, strerror (errno));
16459
16460 return (-1);
16461 }
16462
16463 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16464
16465 uint masks_avail = 1;
16466
16467 while (!feof (mask_fp))
16468 {
16469 memset (line_buf, 0, HCBUFSIZ);
16470
16471 int line_len = fgetl (mask_fp, line_buf);
16472
16473 if (line_len == 0) continue;
16474
16475 if (line_buf[0] == '#') continue;
16476
16477 if (masks_avail == maskcnt)
16478 {
16479 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16480
16481 masks_avail += INCR_MASKS;
16482 }
16483
16484 masks[maskcnt] = mystrdup (line_buf);
16485
16486 maskcnt++;
16487 }
16488
16489 myfree (line_buf);
16490
16491 fclose (mask_fp);
16492
16493 mask_from_file = 1;
16494 }
16495 else
16496 {
16497 maskcnt = 1;
16498
16499 masks[maskcnt - 1] = mystrdup (mask);
16500 }
16501 }
16502
16503 // base
16504
16505 int wls_left = myargc - (optind + 2);
16506
16507 for (int i = 0; i < wls_left; i++)
16508 {
16509 char *filename = myargv[optind + 2 + i];
16510
16511 struct stat file_stat;
16512
16513 if (stat (filename, &file_stat) == -1)
16514 {
16515 log_error ("ERROR: %s: %s", filename, strerror (errno));
16516
16517 return (-1);
16518 }
16519
16520 uint is_dir = S_ISDIR (file_stat.st_mode);
16521
16522 if (is_dir == 0)
16523 {
16524 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16525
16526 dictcnt++;
16527
16528 dictfiles[dictcnt - 1] = filename;
16529 }
16530 else
16531 {
16532 // do not allow --keyspace w/ a directory
16533
16534 if (keyspace == 1)
16535 {
16536 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16537
16538 return (-1);
16539 }
16540
16541 char **dictionary_files = NULL;
16542
16543 dictionary_files = scan_directory (filename);
16544
16545 if (dictionary_files != NULL)
16546 {
16547 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16548
16549 for (int d = 0; dictionary_files[d] != NULL; d++)
16550 {
16551 char *l1_filename = dictionary_files[d];
16552
16553 struct stat l1_stat;
16554
16555 if (stat (l1_filename, &l1_stat) == -1)
16556 {
16557 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16558
16559 return (-1);
16560 }
16561
16562 if (S_ISREG (l1_stat.st_mode))
16563 {
16564 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16565
16566 dictcnt++;
16567
16568 dictfiles[dictcnt - 1] = strdup (l1_filename);
16569 }
16570 }
16571 }
16572
16573 local_free (dictionary_files);
16574 }
16575 }
16576
16577 if (dictcnt < 1)
16578 {
16579 log_error ("ERROR: No usable dictionary file found.");
16580
16581 return (-1);
16582 }
16583
16584 if (increment)
16585 {
16586 maskcnt = 0;
16587
16588 uint mask_min = increment_min; // we can't reject smaller masks here
16589 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16590
16591 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16592 {
16593 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16594
16595 if (cur_mask == NULL) break;
16596
16597 masks[maskcnt] = cur_mask;
16598
16599 maskcnt++;
16600
16601 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16602 }
16603 }
16604 }
16605
16606 data.pw_min = pw_min;
16607 data.pw_max = pw_max;
16608
16609 /**
16610 * weak hash check
16611 */
16612
16613 if (weak_hash_threshold >= salts_cnt)
16614 {
16615 hc_device_param_t *device_param = NULL;
16616
16617 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16618 {
16619 device_param = &data.devices_param[device_id];
16620
16621 if (device_param->skipped) continue;
16622
16623 break;
16624 }
16625
16626 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16627
16628 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16629 {
16630 weak_hash_check (device_param, salt_pos);
16631 }
16632
16633 // Display hack, guarantee that there is at least one \r before real start
16634
16635 //if (data.quiet == 0) log_info ("");
16636 }
16637
16638 /**
16639 * status and monitor threads
16640 */
16641
16642 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16643
16644 hc_thread_t i_thread = 0;
16645
16646 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16647 {
16648 hc_thread_create (i_thread, thread_keypress, &benchmark);
16649 }
16650
16651 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16652
16653 uint ni_threads_cnt = 0;
16654
16655 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16656
16657 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16658
16659 ni_threads_cnt++;
16660
16661 /**
16662 * Outfile remove
16663 */
16664
16665 if (keyspace == 0)
16666 {
16667 if (outfile_check_timer != 0)
16668 {
16669 if (data.outfile_check_directory != NULL)
16670 {
16671 if ((hash_mode != 5200) &&
16672 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16673 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16674 (hash_mode != 9000))
16675 {
16676 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16677
16678 ni_threads_cnt++;
16679 }
16680 else
16681 {
16682 outfile_check_timer = 0;
16683 }
16684 }
16685 else
16686 {
16687 outfile_check_timer = 0;
16688 }
16689 }
16690 }
16691
16692 /**
16693 * Inform the user if we got some hashes remove because of the pot file remove feature
16694 */
16695
16696 if (data.quiet == 0)
16697 {
16698 if (potfile_remove_cracks > 0)
16699 {
16700 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16701 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16702 }
16703 }
16704
16705 data.outfile_check_timer = outfile_check_timer;
16706
16707 /**
16708 * main loop
16709 */
16710
16711 char **induction_dictionaries = NULL;
16712
16713 int induction_dictionaries_cnt = 0;
16714
16715 hcstat_table_t *root_table_buf = NULL;
16716 hcstat_table_t *markov_table_buf = NULL;
16717
16718 uint initial_restore_done = 0;
16719
16720 data.maskcnt = maskcnt;
16721
16722 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16723 {
16724 if (data.devices_status == STATUS_CRACKED) break;
16725
16726 data.devices_status = STATUS_INIT;
16727
16728 if (maskpos > rd->maskpos)
16729 {
16730 rd->dictpos = 0;
16731 }
16732
16733 rd->maskpos = maskpos;
16734 data.maskpos = maskpos;
16735
16736 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16737 {
16738 char *mask = masks[maskpos];
16739
16740 if (mask_from_file == 1)
16741 {
16742 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16743
16744 char *str_ptr;
16745 uint str_pos;
16746
16747 uint mask_offset = 0;
16748
16749 uint separator_cnt;
16750
16751 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16752 {
16753 str_ptr = strstr (mask + mask_offset, ",");
16754
16755 if (str_ptr == NULL) break;
16756
16757 str_pos = str_ptr - mask;
16758
16759 // escaped separator, i.e. "\,"
16760
16761 if (str_pos > 0)
16762 {
16763 if (mask[str_pos - 1] == '\\')
16764 {
16765 separator_cnt --;
16766
16767 mask_offset = str_pos + 1;
16768
16769 continue;
16770 }
16771 }
16772
16773 // reset the offset
16774
16775 mask_offset = 0;
16776
16777 mask[str_pos] = '\0';
16778
16779 switch (separator_cnt)
16780 {
16781 case 0:
16782 mp_reset_usr (mp_usr, 0);
16783
16784 custom_charset_1 = mask;
16785 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16786 break;
16787
16788 case 1:
16789 mp_reset_usr (mp_usr, 1);
16790
16791 custom_charset_2 = mask;
16792 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16793 break;
16794
16795 case 2:
16796 mp_reset_usr (mp_usr, 2);
16797
16798 custom_charset_3 = mask;
16799 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16800 break;
16801
16802 case 3:
16803 mp_reset_usr (mp_usr, 3);
16804
16805 custom_charset_4 = mask;
16806 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16807 break;
16808 }
16809
16810 mask = mask + str_pos + 1;
16811 }
16812 }
16813
16814 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16815 {
16816 if (maskpos > 0)
16817 {
16818 local_free (css_buf);
16819 local_free (data.root_css_buf);
16820 local_free (data.markov_css_buf);
16821
16822 local_free (masks[maskpos - 1]);
16823 }
16824
16825 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16826
16827 data.mask = mask;
16828 data.css_cnt = css_cnt;
16829 data.css_buf = css_buf;
16830
16831 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16832
16833 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16834
16835 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16836 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16837
16838 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16839
16840 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16841
16842 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16843 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16844
16845 data.root_css_buf = root_css_buf;
16846 data.markov_css_buf = markov_css_buf;
16847
16848 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16849
16850 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16851
16852 local_free (root_table_buf);
16853 local_free (markov_table_buf);
16854
16855 // args
16856
16857 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16858 {
16859 hc_device_param_t *device_param = &data.devices_param[device_id];
16860
16861 if (device_param->skipped) continue;
16862
16863 device_param->kernel_params_mp[0] = &device_param->d_combs;
16864 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16865 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16866
16867 device_param->kernel_params_mp_buf64[3] = 0;
16868 device_param->kernel_params_mp_buf32[4] = css_cnt;
16869 device_param->kernel_params_mp_buf32[5] = 0;
16870 device_param->kernel_params_mp_buf32[6] = 0;
16871 device_param->kernel_params_mp_buf32[7] = 0;
16872
16873 if (attack_mode == ATTACK_MODE_HYBRID1)
16874 {
16875 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16876 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16877 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16878 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16879 }
16880 else if (attack_mode == ATTACK_MODE_HYBRID2)
16881 {
16882 device_param->kernel_params_mp_buf32[5] = 0;
16883 device_param->kernel_params_mp_buf32[6] = 0;
16884 device_param->kernel_params_mp_buf32[7] = 0;
16885 }
16886
16887 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]);
16888 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]);
16889 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]);
16890
16891 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);
16892 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);
16893 }
16894 }
16895 else if (attack_mode == ATTACK_MODE_BF)
16896 {
16897 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16898
16899 if (increment)
16900 {
16901 for (uint i = 0; i < dictcnt; i++)
16902 {
16903 local_free (dictfiles[i]);
16904 }
16905
16906 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16907 {
16908 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16909
16910 if (l1_filename == NULL) break;
16911
16912 dictcnt++;
16913
16914 dictfiles[dictcnt - 1] = l1_filename;
16915 }
16916 }
16917 else
16918 {
16919 dictcnt++;
16920
16921 dictfiles[dictcnt - 1] = mask;
16922 }
16923
16924 if (dictcnt == 0)
16925 {
16926 log_error ("ERROR: Mask is too small");
16927
16928 return (-1);
16929 }
16930 }
16931 }
16932
16933 free (induction_dictionaries);
16934
16935 // induction_dictionaries_cnt = 0; // implied
16936
16937 if (attack_mode != ATTACK_MODE_BF)
16938 {
16939 if (keyspace == 0)
16940 {
16941 induction_dictionaries = scan_directory (induction_directory);
16942
16943 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16944 }
16945 }
16946
16947 if (induction_dictionaries_cnt)
16948 {
16949 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16950 }
16951
16952 /**
16953 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16954 */
16955 if (keyspace == 1)
16956 {
16957 if ((maskcnt > 1) || (dictcnt > 1))
16958 {
16959 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16960
16961 return (-1);
16962 }
16963 }
16964
16965 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16966 {
16967 char *subid = logfile_generate_subid ();
16968
16969 data.subid = subid;
16970
16971 logfile_sub_msg ("START");
16972
16973 data.devices_status = STATUS_INIT;
16974
16975 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16976 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16977 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16978
16979 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16980
16981 data.cpt_pos = 0;
16982
16983 data.cpt_start = time (NULL);
16984
16985 data.cpt_total = 0;
16986
16987 if (data.restore == 0)
16988 {
16989 rd->words_cur = skip;
16990
16991 skip = 0;
16992
16993 data.skip = 0;
16994 }
16995
16996 data.ms_paused = 0;
16997
16998 data.words_cur = rd->words_cur;
16999
17000 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17001 {
17002 hc_device_param_t *device_param = &data.devices_param[device_id];
17003
17004 if (device_param->skipped) continue;
17005
17006 device_param->speed_pos = 0;
17007
17008 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17009 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17010
17011 device_param->exec_pos = 0;
17012
17013 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17014
17015 device_param->kernel_power = device_param->kernel_power_user;
17016
17017 device_param->outerloop_pos = 0;
17018 device_param->outerloop_left = 0;
17019 device_param->innerloop_pos = 0;
17020 device_param->innerloop_left = 0;
17021
17022 // some more resets:
17023
17024 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17025
17026 device_param->pws_cnt = 0;
17027
17028 device_param->words_off = 0;
17029 device_param->words_done = 0;
17030 }
17031
17032 data.kernel_power_div = 0;
17033
17034 // figure out some workload
17035
17036 if (attack_mode == ATTACK_MODE_STRAIGHT)
17037 {
17038 if (data.wordlist_mode == WL_MODE_FILE)
17039 {
17040 char *dictfile = NULL;
17041
17042 if (induction_dictionaries_cnt)
17043 {
17044 dictfile = induction_dictionaries[0];
17045 }
17046 else
17047 {
17048 dictfile = dictfiles[dictpos];
17049 }
17050
17051 data.dictfile = dictfile;
17052
17053 logfile_sub_string (dictfile);
17054
17055 for (uint i = 0; i < rp_files_cnt; i++)
17056 {
17057 logfile_sub_var_string ("rulefile", rp_files[i]);
17058 }
17059
17060 FILE *fd2 = fopen (dictfile, "rb");
17061
17062 if (fd2 == NULL)
17063 {
17064 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17065
17066 return (-1);
17067 }
17068
17069 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17070
17071 fclose (fd2);
17072
17073 if (data.words_cnt == 0)
17074 {
17075 if (data.devices_status == STATUS_CRACKED) break;
17076 if (data.devices_status == STATUS_ABORTED) break;
17077
17078 dictpos++;
17079
17080 continue;
17081 }
17082 }
17083 }
17084 else if (attack_mode == ATTACK_MODE_COMBI)
17085 {
17086 char *dictfile = data.dictfile;
17087 char *dictfile2 = data.dictfile2;
17088
17089 logfile_sub_string (dictfile);
17090 logfile_sub_string (dictfile2);
17091
17092 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17093 {
17094 FILE *fd2 = fopen (dictfile, "rb");
17095
17096 if (fd2 == NULL)
17097 {
17098 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17099
17100 return (-1);
17101 }
17102
17103 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17104
17105 fclose (fd2);
17106 }
17107 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17108 {
17109 FILE *fd2 = fopen (dictfile2, "rb");
17110
17111 if (fd2 == NULL)
17112 {
17113 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17114
17115 return (-1);
17116 }
17117
17118 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17119
17120 fclose (fd2);
17121 }
17122
17123 if (data.words_cnt == 0)
17124 {
17125 if (data.devices_status == STATUS_CRACKED) break;
17126 if (data.devices_status == STATUS_ABORTED) break;
17127
17128 dictpos++;
17129
17130 continue;
17131 }
17132 }
17133 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17134 {
17135 char *dictfile = NULL;
17136
17137 if (induction_dictionaries_cnt)
17138 {
17139 dictfile = induction_dictionaries[0];
17140 }
17141 else
17142 {
17143 dictfile = dictfiles[dictpos];
17144 }
17145
17146 data.dictfile = dictfile;
17147
17148 char *mask = data.mask;
17149
17150 logfile_sub_string (dictfile);
17151 logfile_sub_string (mask);
17152
17153 FILE *fd2 = fopen (dictfile, "rb");
17154
17155 if (fd2 == NULL)
17156 {
17157 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17158
17159 return (-1);
17160 }
17161
17162 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17163
17164 fclose (fd2);
17165
17166 if (data.words_cnt == 0)
17167 {
17168 if (data.devices_status == STATUS_CRACKED) break;
17169 if (data.devices_status == STATUS_ABORTED) break;
17170
17171 dictpos++;
17172
17173 continue;
17174 }
17175 }
17176 else if (attack_mode == ATTACK_MODE_BF)
17177 {
17178 local_free (css_buf);
17179 local_free (data.root_css_buf);
17180 local_free (data.markov_css_buf);
17181
17182 char *mask = dictfiles[dictpos];
17183
17184 logfile_sub_string (mask);
17185
17186 // base
17187
17188 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17189
17190 if (opts_type & OPTS_TYPE_PT_UNICODE)
17191 {
17192 uint css_cnt_unicode = css_cnt * 2;
17193
17194 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17195
17196 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17197 {
17198 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17199
17200 css_buf_unicode[j + 1].cs_buf[0] = 0;
17201 css_buf_unicode[j + 1].cs_len = 1;
17202 }
17203
17204 free (css_buf);
17205
17206 css_buf = css_buf_unicode;
17207 css_cnt = css_cnt_unicode;
17208 }
17209
17210 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17211
17212 uint mask_min = pw_min;
17213 uint mask_max = pw_max;
17214
17215 if (opts_type & OPTS_TYPE_PT_UNICODE)
17216 {
17217 mask_min *= 2;
17218 mask_max *= 2;
17219 }
17220
17221 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17222 {
17223 if (css_cnt < mask_min)
17224 {
17225 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17226 }
17227
17228 if (css_cnt > mask_max)
17229 {
17230 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17231 }
17232
17233 // skip to next mask
17234
17235 dictpos++;
17236
17237 rd->dictpos = dictpos;
17238
17239 logfile_sub_msg ("STOP");
17240
17241 continue;
17242 }
17243
17244 uint save_css_cnt = css_cnt;
17245
17246 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17247 {
17248 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17249 {
17250 uint salt_len = (uint) data.salts_buf[0].salt_len;
17251 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17252
17253 uint css_cnt_salt = css_cnt + salt_len;
17254
17255 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17256
17257 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17258
17259 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17260 {
17261 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17262 css_buf_salt[j].cs_len = 1;
17263 }
17264
17265 free (css_buf);
17266
17267 css_buf = css_buf_salt;
17268 css_cnt = css_cnt_salt;
17269 }
17270 }
17271
17272 data.mask = mask;
17273 data.css_cnt = css_cnt;
17274 data.css_buf = css_buf;
17275
17276 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17277
17278 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17279
17280 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17281
17282 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17283 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17284
17285 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17286
17287 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17288
17289 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17290 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17291
17292 data.root_css_buf = root_css_buf;
17293 data.markov_css_buf = markov_css_buf;
17294
17295 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17296
17297 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17298
17299 local_free (root_table_buf);
17300 local_free (markov_table_buf);
17301
17302 // copy + args
17303
17304 uint css_cnt_l = css_cnt;
17305 uint css_cnt_r;
17306
17307 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17308 {
17309 if (save_css_cnt < 6)
17310 {
17311 css_cnt_r = 1;
17312 }
17313 else if (save_css_cnt == 6)
17314 {
17315 css_cnt_r = 2;
17316 }
17317 else
17318 {
17319 if (opts_type & OPTS_TYPE_PT_UNICODE)
17320 {
17321 if (save_css_cnt == 8 || save_css_cnt == 10)
17322 {
17323 css_cnt_r = 2;
17324 }
17325 else
17326 {
17327 css_cnt_r = 4;
17328 }
17329 }
17330 else
17331 {
17332 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17333 {
17334 css_cnt_r = 3;
17335 }
17336 else
17337 {
17338 css_cnt_r = 4;
17339 }
17340 }
17341 }
17342 }
17343 else
17344 {
17345 css_cnt_r = 1;
17346
17347 /* unfinished code?
17348 int sum = css_buf[css_cnt_r - 1].cs_len;
17349
17350 for (uint i = 1; i < 4 && i < css_cnt; i++)
17351 {
17352 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17353
17354 css_cnt_r++;
17355
17356 sum *= css_buf[css_cnt_r - 1].cs_len;
17357 }
17358 */
17359 }
17360
17361 css_cnt_l -= css_cnt_r;
17362
17363 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17364
17365 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17366 {
17367 hc_device_param_t *device_param = &data.devices_param[device_id];
17368
17369 if (device_param->skipped) continue;
17370
17371 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17372 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17373 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17374
17375 device_param->kernel_params_mp_l_buf64[3] = 0;
17376 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17377 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17378 device_param->kernel_params_mp_l_buf32[6] = 0;
17379 device_param->kernel_params_mp_l_buf32[7] = 0;
17380 device_param->kernel_params_mp_l_buf32[8] = 0;
17381
17382 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17383 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17384 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17385 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17386
17387 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17388 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17389 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17390
17391 device_param->kernel_params_mp_r_buf64[3] = 0;
17392 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17393 device_param->kernel_params_mp_r_buf32[5] = 0;
17394 device_param->kernel_params_mp_r_buf32[6] = 0;
17395 device_param->kernel_params_mp_r_buf32[7] = 0;
17396
17397 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]);
17398 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]);
17399 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]);
17400
17401 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]);
17402 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]);
17403 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]);
17404
17405 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);
17406 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);
17407 }
17408 }
17409
17410 u64 words_base = data.words_cnt;
17411
17412 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17413 {
17414 if (data.kernel_rules_cnt)
17415 {
17416 words_base /= data.kernel_rules_cnt;
17417 }
17418 }
17419 else if (data.attack_kern == ATTACK_KERN_COMBI)
17420 {
17421 if (data.combs_cnt)
17422 {
17423 words_base /= data.combs_cnt;
17424 }
17425 }
17426 else if (data.attack_kern == ATTACK_KERN_BF)
17427 {
17428 if (data.bfs_cnt)
17429 {
17430 words_base /= data.bfs_cnt;
17431 }
17432 }
17433
17434 data.words_base = words_base;
17435
17436 if (keyspace == 1)
17437 {
17438 log_info ("%llu", (unsigned long long int) words_base);
17439
17440 return (0);
17441 }
17442
17443 if (data.words_cur > data.words_base)
17444 {
17445 log_error ("ERROR: restore value greater keyspace");
17446
17447 return (-1);
17448 }
17449
17450 if (data.words_cur)
17451 {
17452 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17453 {
17454 for (uint i = 0; i < data.salts_cnt; i++)
17455 {
17456 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17457 }
17458 }
17459 else if (data.attack_kern == ATTACK_KERN_COMBI)
17460 {
17461 for (uint i = 0; i < data.salts_cnt; i++)
17462 {
17463 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17464 }
17465 }
17466 else if (data.attack_kern == ATTACK_KERN_BF)
17467 {
17468 for (uint i = 0; i < data.salts_cnt; i++)
17469 {
17470 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17471 }
17472 }
17473 }
17474
17475 /*
17476 * Inform user about possible slow speeds
17477 */
17478
17479 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17480 {
17481 if (data.words_base < kernel_power_all)
17482 {
17483 if (quiet == 0)
17484 {
17485 log_info ("ATTENTION!");
17486 log_info (" The wordlist or mask you are using is too small.");
17487 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17488 log_info (" The cracking speed will drop.");
17489 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17490 log_info ("");
17491 }
17492 }
17493 }
17494
17495 /*
17496 * Update loopback file
17497 */
17498
17499 if (loopback == 1)
17500 {
17501 time_t now;
17502
17503 time (&now);
17504
17505 uint random_num = get_random_num (0, 9999);
17506
17507 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17508
17509 data.loopback_file = loopback_file;
17510 }
17511
17512 /*
17513 * Update dictionary statistic
17514 */
17515
17516 if (keyspace == 0)
17517 {
17518 dictstat_fp = fopen (dictstat, "wb");
17519
17520 if (dictstat_fp)
17521 {
17522 lock_file (dictstat_fp);
17523
17524 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17525
17526 fclose (dictstat_fp);
17527 }
17528 }
17529
17530 data.devices_status = STATUS_RUNNING;
17531
17532 if (initial_restore_done == 0)
17533 {
17534 if (data.restore_disable == 0) cycle_restore ();
17535
17536 initial_restore_done = 1;
17537 }
17538
17539 hc_timer_set (&data.timer_running);
17540
17541 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17542 {
17543 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17544 {
17545 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17546 if (quiet == 0) fflush (stdout);
17547 }
17548 }
17549 else if (wordlist_mode == WL_MODE_STDIN)
17550 {
17551 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17552 if (data.quiet == 0) log_info ("");
17553 }
17554
17555 time_t runtime_start;
17556
17557 time (&runtime_start);
17558
17559 data.runtime_start = runtime_start;
17560
17561 /**
17562 * create cracker threads
17563 */
17564
17565 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17566
17567 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17568 {
17569 hc_device_param_t *device_param = &devices_param[device_id];
17570
17571 if (wordlist_mode == WL_MODE_STDIN)
17572 {
17573 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17574 }
17575 else
17576 {
17577 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17578 }
17579 }
17580
17581 // wait for crack threads to exit
17582
17583 hc_thread_wait (data.devices_cnt, c_threads);
17584
17585 local_free (c_threads);
17586
17587 data.restore = 0;
17588
17589 // finalize task
17590
17591 logfile_sub_var_uint ("status-after-work", data.devices_status);
17592
17593 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17594
17595 if (data.devices_status == STATUS_CRACKED) break;
17596 if (data.devices_status == STATUS_ABORTED) break;
17597
17598 if (data.devices_status == STATUS_BYPASS)
17599 {
17600 data.devices_status = STATUS_RUNNING;
17601 }
17602
17603 if (induction_dictionaries_cnt)
17604 {
17605 unlink (induction_dictionaries[0]);
17606 }
17607
17608 free (induction_dictionaries);
17609
17610 if (attack_mode != ATTACK_MODE_BF)
17611 {
17612 induction_dictionaries = scan_directory (induction_directory);
17613
17614 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17615 }
17616
17617 if (benchmark == 0)
17618 {
17619 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17620 {
17621 if (quiet == 0) clear_prompt ();
17622
17623 if (quiet == 0) log_info ("");
17624
17625 if (status == 1)
17626 {
17627 status_display ();
17628 }
17629 else
17630 {
17631 if (quiet == 0) status_display ();
17632 }
17633
17634 if (quiet == 0) log_info ("");
17635 }
17636 }
17637
17638 if (attack_mode == ATTACK_MODE_BF)
17639 {
17640 dictpos++;
17641
17642 rd->dictpos = dictpos;
17643 }
17644 else
17645 {
17646 if (induction_dictionaries_cnt)
17647 {
17648 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17649 }
17650 else
17651 {
17652 dictpos++;
17653
17654 rd->dictpos = dictpos;
17655 }
17656 }
17657
17658 time_t runtime_stop;
17659
17660 time (&runtime_stop);
17661
17662 data.runtime_stop = runtime_stop;
17663
17664 logfile_sub_uint (runtime_start);
17665 logfile_sub_uint (runtime_stop);
17666
17667 logfile_sub_msg ("STOP");
17668
17669 global_free (subid);
17670 }
17671
17672 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17673
17674 if (data.devices_status == STATUS_CRACKED) break;
17675 if (data.devices_status == STATUS_ABORTED) break;
17676 if (data.devices_status == STATUS_QUIT) break;
17677
17678 if (data.devices_status == STATUS_BYPASS)
17679 {
17680 data.devices_status = STATUS_RUNNING;
17681 }
17682 }
17683
17684 // 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
17685
17686 if (attack_mode == ATTACK_MODE_STRAIGHT)
17687 {
17688 if (data.wordlist_mode == WL_MODE_FILE)
17689 {
17690 if (data.dictfile == NULL)
17691 {
17692 if (dictfiles != NULL)
17693 {
17694 data.dictfile = dictfiles[0];
17695
17696 hc_timer_set (&data.timer_running);
17697 }
17698 }
17699 }
17700 }
17701 // NOTE: combi is okay because it is already set beforehand
17702 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17703 {
17704 if (data.dictfile == NULL)
17705 {
17706 if (dictfiles != NULL)
17707 {
17708 hc_timer_set (&data.timer_running);
17709
17710 data.dictfile = dictfiles[0];
17711 }
17712 }
17713 }
17714 else if (attack_mode == ATTACK_MODE_BF)
17715 {
17716 if (data.mask == NULL)
17717 {
17718 hc_timer_set (&data.timer_running);
17719
17720 data.mask = masks[0];
17721 }
17722 }
17723
17724 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17725 {
17726 data.devices_status = STATUS_EXHAUSTED;
17727 }
17728
17729 // if cracked / aborted remove last induction dictionary
17730
17731 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17732 {
17733 struct stat induct_stat;
17734
17735 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17736 {
17737 unlink (induction_dictionaries[file_pos]);
17738 }
17739 }
17740
17741 // wait for non-interactive threads
17742
17743 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17744 {
17745 hc_thread_wait (1, &ni_threads[thread_idx]);
17746 }
17747
17748 local_free (ni_threads);
17749
17750 // wait for interactive threads
17751
17752 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17753 {
17754 hc_thread_wait (1, &i_thread);
17755 }
17756
17757 // we dont need restore file anymore
17758 if (data.restore_disable == 0)
17759 {
17760 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17761 {
17762 unlink (eff_restore_file);
17763 unlink (new_restore_file);
17764 }
17765 else
17766 {
17767 cycle_restore ();
17768 }
17769 }
17770
17771 // finally save left hashes
17772
17773 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17774 {
17775 save_hash ();
17776 }
17777
17778 /**
17779 * Clean up
17780 */
17781
17782 if (benchmark == 1)
17783 {
17784 status_benchmark ();
17785
17786 if (machine_readable == 0)
17787 {
17788 log_info ("");
17789 }
17790 }
17791 else
17792 {
17793 if (quiet == 0) clear_prompt ();
17794
17795 if (quiet == 0) log_info ("");
17796
17797 if (status == 1)
17798 {
17799 status_display ();
17800 }
17801 else
17802 {
17803 if (quiet == 0) status_display ();
17804 }
17805
17806 if (quiet == 0) log_info ("");
17807 }
17808
17809 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17810 {
17811 hc_device_param_t *device_param = &data.devices_param[device_id];
17812
17813 if (device_param->skipped) continue;
17814
17815 local_free (device_param->combs_buf);
17816
17817 local_free (device_param->hooks_buf);
17818
17819 local_free (device_param->device_name);
17820
17821 local_free (device_param->device_name_chksum);
17822
17823 local_free (device_param->device_version);
17824
17825 local_free (device_param->driver_version);
17826
17827 if (device_param->pws_buf) myfree (device_param->pws_buf);
17828 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17829 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17830 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17831 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17832 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17833 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17834 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17835 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17836 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17837 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17838 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17839 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17840 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17841 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17842 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17843 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17844 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17845 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17846 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17847 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17848 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17849 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17850 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17851 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17852 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17853 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17854 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17855 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17856
17857 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17858 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17859 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17860 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17861 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17862 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17863 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17864 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17865 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17866 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17867 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17868
17869 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17870 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17871 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17872
17873 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17874 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17875 }
17876
17877 // reset default fan speed
17878
17879 #ifdef HAVE_HWMON
17880 if (gpu_temp_disable == 0)
17881 {
17882 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17883 {
17884 hc_thread_mutex_lock (mux_adl);
17885
17886 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17887 {
17888 hc_device_param_t *device_param = &data.devices_param[device_id];
17889
17890 if (device_param->skipped) continue;
17891
17892 if (data.hm_device[device_id].fan_set_supported == 1)
17893 {
17894 int fanspeed = temp_retain_fanspeed_value[device_id];
17895 int fanpolicy = temp_retain_fanpolicy_value[device_id];
17896
17897 if (fanpolicy == 1)
17898 {
17899 int rc = -1;
17900
17901 if (device_param->device_vendor_id == VENDOR_ID_AMD)
17902 {
17903 rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed, 0);
17904 }
17905 else if (device_param->device_vendor_id == VENDOR_ID_NV)
17906 {
17907
17908 }
17909
17910 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
17911 }
17912 }
17913 }
17914
17915 hc_thread_mutex_unlock (mux_adl);
17916 }
17917 }
17918
17919 // reset power tuning
17920
17921 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17922 {
17923 hc_thread_mutex_lock (mux_adl);
17924
17925 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17926 {
17927 hc_device_param_t *device_param = &data.devices_param[device_id];
17928
17929 if (device_param->skipped) continue;
17930
17931 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
17932 {
17933 if (data.hm_device[device_id].od_version == 6)
17934 {
17935 // check powertune capabilities first, if not available then skip device
17936
17937 int powertune_supported = 0;
17938
17939 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17940 {
17941 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17942
17943 return (-1);
17944 }
17945
17946 if (powertune_supported != 0)
17947 {
17948 // powercontrol settings
17949
17950 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, od_power_control_status[device_id])) != ADL_OK)
17951 {
17952 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17953
17954 return (-1);
17955 }
17956
17957 // clocks
17958
17959 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17960
17961 performance_state->iNumberOfPerformanceLevels = 2;
17962
17963 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17964 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17965 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17966 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17967
17968 if ((hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
17969 {
17970 log_info ("ERROR: Failed to restore ADL performance state");
17971
17972 return (-1);
17973 }
17974
17975 local_free (performance_state);
17976 }
17977 }
17978 }
17979
17980 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
17981 {
17982 unsigned int limit = nvml_power_limit[device_id];
17983
17984 if (limit > 0)
17985 {
17986 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nv, 0, data.hm_device[device_id].adapter_index.nv, limit);
17987 }
17988 }
17989 }
17990
17991 hc_thread_mutex_unlock (mux_adl);
17992 }
17993
17994 if (gpu_temp_disable == 0)
17995 {
17996 if (data.hm_nv)
17997 {
17998 hm_NVML_nvmlShutdown (data.hm_nv);
17999
18000 nvml_close (data.hm_nv);
18001
18002 data.hm_nv = NULL;
18003 }
18004
18005 if (data.hm_amd)
18006 {
18007 hm_ADL_Main_Control_Destroy (data.hm_amd);
18008
18009 adl_close (data.hm_amd);
18010
18011 data.hm_amd = NULL;
18012 }
18013 }
18014 #endif // HAVE_HWMON
18015
18016 // free memory
18017
18018 local_free (masks);
18019
18020 local_free (dictstat_base);
18021
18022 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18023 {
18024 pot_t *pot_ptr = &pot[pot_pos];
18025
18026 hash_t *hash = &pot_ptr->hash;
18027
18028 local_free (hash->digest);
18029
18030 if (isSalted)
18031 {
18032 local_free (hash->salt);
18033 }
18034 }
18035
18036 local_free (pot);
18037
18038 local_free (all_kernel_rules_cnt);
18039 local_free (all_kernel_rules_buf);
18040
18041 local_free (wl_data->buf);
18042 local_free (wl_data);
18043
18044 local_free (bitmap_s1_a);
18045 local_free (bitmap_s1_b);
18046 local_free (bitmap_s1_c);
18047 local_free (bitmap_s1_d);
18048 local_free (bitmap_s2_a);
18049 local_free (bitmap_s2_b);
18050 local_free (bitmap_s2_c);
18051 local_free (bitmap_s2_d);
18052
18053 #ifdef HAVE_HWMON
18054 local_free (temp_retain_fanspeed_value);
18055 local_free (od_clock_mem_status);
18056 local_free (od_power_control_status);
18057 local_free (nvml_power_limit);
18058 #endif
18059
18060 global_free (devices_param);
18061
18062 global_free (kernel_rules_buf);
18063
18064 global_free (root_css_buf);
18065 global_free (markov_css_buf);
18066
18067 global_free (digests_buf);
18068 global_free (digests_shown);
18069 global_free (digests_shown_tmp);
18070
18071 global_free (salts_buf);
18072 global_free (salts_shown);
18073
18074 global_free (esalts_buf);
18075
18076 global_free (words_progress_done);
18077 global_free (words_progress_rejected);
18078 global_free (words_progress_restored);
18079
18080 if (pot_fp) fclose (pot_fp);
18081
18082 if (data.devices_status == STATUS_QUIT) break;
18083 }
18084
18085 // destroy others mutex
18086
18087 hc_thread_mutex_delete (mux_dispatcher);
18088 hc_thread_mutex_delete (mux_counter);
18089 hc_thread_mutex_delete (mux_display);
18090 hc_thread_mutex_delete (mux_adl);
18091
18092 // free memory
18093
18094 local_free (eff_restore_file);
18095 local_free (new_restore_file);
18096
18097 local_free (rd);
18098
18099 // tuning db
18100
18101 tuning_db_destroy (tuning_db);
18102
18103 // loopback
18104
18105 local_free (loopback_file);
18106
18107 if (loopback == 1) unlink (loopback_file);
18108
18109 // induction directory
18110
18111 if (induction_dir == NULL)
18112 {
18113 if (attack_mode != ATTACK_MODE_BF)
18114 {
18115 if (rmdir (induction_directory) == -1)
18116 {
18117 if (errno == ENOENT)
18118 {
18119 // good, we can ignore
18120 }
18121 else if (errno == ENOTEMPTY)
18122 {
18123 // good, we can ignore
18124 }
18125 else
18126 {
18127 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18128
18129 return (-1);
18130 }
18131 }
18132
18133 local_free (induction_directory);
18134 }
18135 }
18136
18137 // outfile-check directory
18138
18139 if (outfile_check_dir == NULL)
18140 {
18141 if (rmdir (outfile_check_directory) == -1)
18142 {
18143 if (errno == ENOENT)
18144 {
18145 // good, we can ignore
18146 }
18147 else if (errno == ENOTEMPTY)
18148 {
18149 // good, we can ignore
18150 }
18151 else
18152 {
18153 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18154
18155 return (-1);
18156 }
18157 }
18158
18159 local_free (outfile_check_directory);
18160 }
18161
18162 time_t proc_stop;
18163
18164 time (&proc_stop);
18165
18166 logfile_top_uint (proc_start);
18167 logfile_top_uint (proc_stop);
18168
18169 logfile_top_msg ("STOP");
18170
18171 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18172 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18173
18174 if (data.ocl) ocl_close (data.ocl);
18175
18176 if (data.devices_status == STATUS_ABORTED) return 2;
18177 if (data.devices_status == STATUS_QUIT) return 2;
18178 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18179 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18180 if (data.devices_status == STATUS_CRACKED) return 0;
18181
18182 return -1;
18183 }
Hashcat additions to support pwdhash