projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Finally got rid of NvAPI on Windows, replace with NVML
[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 automatic power tuning (AMD OverDrive 6 only) |",
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 // not working
1551 //const int num_throttle = hm_get_throttle_with_device_id (device_id);
1552
1553 char output_buf[256] = { 0 };
1554
1555 int output_len = 0;
1556
1557 if (num_temperature >= 0)
1558 {
1559 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1560
1561 output_len = strlen (output_buf);
1562 }
1563
1564 if (num_fanspeed >= 0)
1565 {
1566 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1567
1568 output_len = strlen (output_buf);
1569 }
1570
1571 if (num_utilization >= 0)
1572 {
1573 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1574
1575 output_len = strlen (output_buf);
1576 }
1577
1578 if (num_corespeed >= 0)
1579 {
1580 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1581
1582 output_len = strlen (output_buf);
1583 }
1584
1585 if (num_memoryspeed >= 0)
1586 {
1587 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1588
1589 output_len = strlen (output_buf);
1590 }
1591
1592 if (num_buslanes >= 0)
1593 {
1594 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1595
1596 output_len = strlen (output_buf);
1597 }
1598
1599 /*
1600 if (num_throttle >= 0)
1601 {
1602 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Throttle:%u", num_throttle);
1603
1604 output_len = strlen (output_buf);
1605 }
1606 */
1607
1608 if (output_len == 0)
1609 {
1610 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1611
1612 output_len = strlen (output_buf);
1613 }
1614
1615 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1616 }
1617
1618 hc_thread_mutex_unlock (mux_adl);
1619 }
1620 #endif // HAVE_HWMON
1621 }
1622
1623 static void status_benchmark_automate ()
1624 {
1625 u64 speed_cnt[DEVICES_MAX] = { 0 };
1626 double speed_ms[DEVICES_MAX] = { 0 };
1627
1628 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1629 {
1630 hc_device_param_t *device_param = &data.devices_param[device_id];
1631
1632 if (device_param->skipped) continue;
1633
1634 speed_cnt[device_id] = device_param->speed_cnt[0];
1635 speed_ms[device_id] = device_param->speed_ms[0];
1636 }
1637
1638 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1639
1640 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1641 {
1642 hc_device_param_t *device_param = &data.devices_param[device_id];
1643
1644 if (device_param->skipped) continue;
1645
1646 hashes_dev_ms[device_id] = 0;
1647
1648 if (speed_ms[device_id])
1649 {
1650 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1651 }
1652 }
1653
1654 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1655 {
1656 hc_device_param_t *device_param = &data.devices_param[device_id];
1657
1658 if (device_param->skipped) continue;
1659
1660 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1661 }
1662 }
1663
1664 static void status_benchmark ()
1665 {
1666 if (data.devices_status == STATUS_INIT) return;
1667 if (data.devices_status == STATUS_STARTING) return;
1668 if (data.devices_status == STATUS_BYPASS) return;
1669
1670 if (data.machine_readable == 1)
1671 {
1672 status_benchmark_automate ();
1673
1674 return;
1675 }
1676
1677 u64 speed_cnt[DEVICES_MAX] = { 0 };
1678 double speed_ms[DEVICES_MAX] = { 0 };
1679
1680 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1681 {
1682 hc_device_param_t *device_param = &data.devices_param[device_id];
1683
1684 if (device_param->skipped) continue;
1685
1686 speed_cnt[device_id] = device_param->speed_cnt[0];
1687 speed_ms[device_id] = device_param->speed_ms[0];
1688 }
1689
1690 double hashes_all_ms = 0;
1691
1692 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1693
1694 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1695 {
1696 hc_device_param_t *device_param = &data.devices_param[device_id];
1697
1698 if (device_param->skipped) continue;
1699
1700 hashes_dev_ms[device_id] = 0;
1701
1702 if (speed_ms[device_id])
1703 {
1704 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1705
1706 hashes_all_ms += hashes_dev_ms[device_id];
1707 }
1708 }
1709
1710 /**
1711 * exec time
1712 */
1713
1714 double exec_all_ms[DEVICES_MAX] = { 0 };
1715
1716 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1717 {
1718 hc_device_param_t *device_param = &data.devices_param[device_id];
1719
1720 if (device_param->skipped) continue;
1721
1722 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1723
1724 exec_all_ms[device_id] = exec_ms_avg;
1725 }
1726
1727 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1728 {
1729 hc_device_param_t *device_param = &data.devices_param[device_id];
1730
1731 if (device_param->skipped) continue;
1732
1733 char display_dev_cur[16] = { 0 };
1734
1735 strncpy (display_dev_cur, "0.00", 4);
1736
1737 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1738
1739 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1740 }
1741
1742 char display_all_cur[16] = { 0 };
1743
1744 strncpy (display_all_cur, "0.00", 4);
1745
1746 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1747
1748 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1749 }
1750
1751 /**
1752 * hashcat -only- functions
1753 */
1754
1755 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1756 {
1757 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1758 {
1759 if (attack_kern == ATTACK_KERN_STRAIGHT)
1760 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1761 else if (attack_kern == ATTACK_KERN_COMBI)
1762 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1763 else if (attack_kern == ATTACK_KERN_BF)
1764 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1765 }
1766 else
1767 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1768 }
1769
1770 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)
1771 {
1772 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1773 {
1774 if (attack_kern == ATTACK_KERN_STRAIGHT)
1775 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1776 else if (attack_kern == ATTACK_KERN_COMBI)
1777 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1778 else if (attack_kern == ATTACK_KERN_BF)
1779 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1780 }
1781 else
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1784 }
1785 }
1786
1787 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1788 {
1789 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1790 {
1791 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1792 }
1793 else
1794 {
1795 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1796 }
1797 }
1798
1799 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)
1800 {
1801 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1802 {
1803 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1804 }
1805 else
1806 {
1807 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1808 }
1809 }
1810
1811 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1812 {
1813 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1814 }
1815
1816 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1817 {
1818 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1819 }
1820
1821 static uint convert_from_hex (char *line_buf, const uint line_len)
1822 {
1823 if (line_len & 1) return (line_len); // not in hex
1824
1825 if (data.hex_wordlist == 1)
1826 {
1827 uint i;
1828 uint j;
1829
1830 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1831 {
1832 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1833 }
1834
1835 memset (line_buf + i, 0, line_len - i);
1836
1837 return (i);
1838 }
1839 else if (line_len >= 6) // $HEX[] = 6
1840 {
1841 if (line_buf[0] != '$') return (line_len);
1842 if (line_buf[1] != 'H') return (line_len);
1843 if (line_buf[2] != 'E') return (line_len);
1844 if (line_buf[3] != 'X') return (line_len);
1845 if (line_buf[4] != '[') return (line_len);
1846 if (line_buf[line_len - 1] != ']') return (line_len);
1847
1848 uint i;
1849 uint j;
1850
1851 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1852 {
1853 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1854 }
1855
1856 memset (line_buf + i, 0, line_len - i);
1857
1858 return (i);
1859 }
1860
1861 return (line_len);
1862 }
1863
1864 static void clear_prompt ()
1865 {
1866 fputc ('\r', stdout);
1867
1868 for (size_t i = 0; i < strlen (PROMPT); i++)
1869 {
1870 fputc (' ', stdout);
1871 }
1872
1873 fputc ('\r', stdout);
1874
1875 fflush (stdout);
1876 }
1877
1878 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1879 {
1880 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);
1881 }
1882
1883 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1884 {
1885 char *outfile = data.outfile;
1886 uint quiet = data.quiet;
1887 FILE *pot_fp = data.pot_fp;
1888 uint loopback = data.loopback;
1889 uint debug_mode = data.debug_mode;
1890 char *debug_file = data.debug_file;
1891
1892 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1893 int debug_rule_len = 0; // -1 error
1894 uint debug_plain_len = 0;
1895
1896 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1897
1898 // hash
1899
1900 char out_buf[HCBUFSIZ] = { 0 };
1901
1902 const u32 salt_pos = plain->salt_pos;
1903 const u32 digest_pos = plain->digest_pos; // relative
1904 const u32 gidvid = plain->gidvid;
1905 const u32 il_pos = plain->il_pos;
1906
1907 ascii_digest (out_buf, salt_pos, digest_pos);
1908
1909 // plain
1910
1911 u64 crackpos = device_param->words_off;
1912
1913 uint plain_buf[16] = { 0 };
1914
1915 u8 *plain_ptr = (u8 *) plain_buf;
1916
1917 unsigned int plain_len = 0;
1918
1919 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1920 {
1921 pw_t pw;
1922
1923 gidd_to_pw_t (device_param, gidvid, &pw);
1924
1925 for (int i = 0; i < 16; i++)
1926 {
1927 plain_buf[i] = pw.i[i];
1928 }
1929
1930 plain_len = pw.pw_len;
1931
1932 const uint off = device_param->innerloop_pos + il_pos;
1933
1934 if (debug_mode > 0)
1935 {
1936 debug_rule_len = 0;
1937
1938 // save rule
1939 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1940 {
1941 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1942
1943 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1944 }
1945
1946 // save plain
1947 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1948 {
1949 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1950
1951 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1952
1953 debug_plain_len = plain_len;
1954 }
1955 }
1956
1957 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1958
1959 crackpos += gidvid;
1960 crackpos *= data.kernel_rules_cnt;
1961 crackpos += device_param->innerloop_pos + il_pos;
1962
1963 if (plain_len > data.pw_max) plain_len = data.pw_max;
1964 }
1965 else if (data.attack_mode == ATTACK_MODE_COMBI)
1966 {
1967 pw_t pw;
1968
1969 gidd_to_pw_t (device_param, gidvid, &pw);
1970
1971 for (int i = 0; i < 16; i++)
1972 {
1973 plain_buf[i] = pw.i[i];
1974 }
1975
1976 plain_len = pw.pw_len;
1977
1978 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1979 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1980
1981 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1982 {
1983 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1984 }
1985 else
1986 {
1987 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1988
1989 memcpy (plain_ptr, comb_buf, comb_len);
1990 }
1991
1992 plain_len += comb_len;
1993
1994 crackpos += gidvid;
1995 crackpos *= data.combs_cnt;
1996 crackpos += device_param->innerloop_pos + il_pos;
1997
1998 if (data.pw_max != PW_DICTMAX1)
1999 {
2000 if (plain_len > data.pw_max) plain_len = data.pw_max;
2001 }
2002 }
2003 else if (data.attack_mode == ATTACK_MODE_BF)
2004 {
2005 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2006 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2007
2008 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2009 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2010
2011 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2012 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2013
2014 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2015 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2016
2017 plain_len = data.css_cnt;
2018
2019 crackpos += gidvid;
2020 crackpos *= data.bfs_cnt;
2021 crackpos += device_param->innerloop_pos + il_pos;
2022 }
2023 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2024 {
2025 pw_t pw;
2026
2027 gidd_to_pw_t (device_param, gidvid, &pw);
2028
2029 for (int i = 0; i < 16; i++)
2030 {
2031 plain_buf[i] = pw.i[i];
2032 }
2033
2034 plain_len = pw.pw_len;
2035
2036 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2037
2038 uint start = 0;
2039 uint stop = device_param->kernel_params_mp_buf32[4];
2040
2041 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2042
2043 plain_len += start + stop;
2044
2045 crackpos += gidvid;
2046 crackpos *= data.combs_cnt;
2047 crackpos += device_param->innerloop_pos + il_pos;
2048
2049 if (data.pw_max != PW_DICTMAX1)
2050 {
2051 if (plain_len > data.pw_max) plain_len = data.pw_max;
2052 }
2053 }
2054 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2055 {
2056 pw_t pw;
2057
2058 gidd_to_pw_t (device_param, gidvid, &pw);
2059
2060 for (int i = 0; i < 16; i++)
2061 {
2062 plain_buf[i] = pw.i[i];
2063 }
2064
2065 plain_len = pw.pw_len;
2066
2067 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2068
2069 uint start = 0;
2070 uint stop = device_param->kernel_params_mp_buf32[4];
2071
2072 memmove (plain_ptr + stop, plain_ptr, plain_len);
2073
2074 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2075
2076 plain_len += start + stop;
2077
2078 crackpos += gidvid;
2079 crackpos *= data.combs_cnt;
2080 crackpos += device_param->innerloop_pos + il_pos;
2081
2082 if (data.pw_max != PW_DICTMAX1)
2083 {
2084 if (plain_len > data.pw_max) plain_len = data.pw_max;
2085 }
2086 }
2087
2088 if (data.attack_mode == ATTACK_MODE_BF)
2089 {
2090 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2091 {
2092 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2093 {
2094 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2095 {
2096 plain_len = plain_len - data.salts_buf[0].salt_len;
2097 }
2098 }
2099
2100 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2101 {
2102 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2103 {
2104 plain_ptr[j] = plain_ptr[i];
2105 }
2106
2107 plain_len = plain_len / 2;
2108 }
2109 }
2110 }
2111
2112 // if enabled, update also the potfile
2113
2114 if (pot_fp)
2115 {
2116 lock_file (pot_fp);
2117
2118 fprintf (pot_fp, "%s:", out_buf);
2119
2120 format_plain (pot_fp, plain_ptr, plain_len, 1);
2121
2122 fputc ('\n', pot_fp);
2123
2124 fflush (pot_fp);
2125
2126 unlock_file (pot_fp);
2127 }
2128
2129 // outfile
2130
2131 FILE *out_fp = NULL;
2132
2133 if (outfile != NULL)
2134 {
2135 if ((out_fp = fopen (outfile, "ab")) == NULL)
2136 {
2137 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2138
2139 out_fp = stdout;
2140 }
2141
2142 lock_file (out_fp);
2143 }
2144 else
2145 {
2146 out_fp = stdout;
2147
2148 if (quiet == 0) clear_prompt ();
2149 }
2150
2151 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2152
2153 if (outfile != NULL)
2154 {
2155 if (out_fp != stdout)
2156 {
2157 fclose (out_fp);
2158 }
2159 }
2160 else
2161 {
2162 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2163 {
2164 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2165 {
2166 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2167 if (quiet == 0) fflush (stdout);
2168 }
2169 }
2170 }
2171
2172 // loopback
2173
2174 if (loopback)
2175 {
2176 char *loopback_file = data.loopback_file;
2177
2178 FILE *fb_fp = NULL;
2179
2180 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2181 {
2182 lock_file (fb_fp);
2183
2184 format_plain (fb_fp, plain_ptr, plain_len, 1);
2185
2186 fputc ('\n', fb_fp);
2187
2188 fclose (fb_fp);
2189 }
2190 }
2191
2192 // (rule) debug mode
2193
2194 // the next check implies that:
2195 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2196 // - debug_mode > 0
2197
2198 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2199 {
2200 if (debug_rule_len < 0) debug_rule_len = 0;
2201
2202 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2203
2204 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2205
2206 if ((quiet == 0) && (debug_file == NULL))
2207 {
2208 fprintf (stdout, "%s", PROMPT);
2209
2210 fflush (stdout);
2211 }
2212 }
2213 }
2214
2215 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2216 {
2217 salt_t *salt_buf = &data.salts_buf[salt_pos];
2218
2219 u32 num_cracked;
2220
2221 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2222
2223 if (num_cracked)
2224 {
2225 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2226
2227 log_info_nn ("");
2228
2229 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2230
2231 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);
2232
2233 uint cpt_cracked = 0;
2234
2235 for (uint i = 0; i < num_cracked; i++)
2236 {
2237 const uint hash_pos = cracked[i].hash_pos;
2238
2239 if (data.digests_shown[hash_pos] == 1) continue;
2240
2241 hc_thread_mutex_lock (mux_display);
2242
2243 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2244 {
2245 data.digests_shown[hash_pos] = 1;
2246
2247 data.digests_done++;
2248
2249 cpt_cracked++;
2250
2251 salt_buf->digests_done++;
2252
2253 if (salt_buf->digests_done == salt_buf->digests_cnt)
2254 {
2255 data.salts_shown[salt_pos] = 1;
2256
2257 data.salts_done++;
2258 }
2259 }
2260
2261 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2262
2263 hc_thread_mutex_unlock (mux_display);
2264
2265 check_hash (device_param, &cracked[i]);
2266 }
2267
2268 myfree (cracked);
2269
2270 if (cpt_cracked > 0)
2271 {
2272 hc_thread_mutex_lock (mux_display);
2273
2274 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2275 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2276
2277 data.cpt_pos++;
2278
2279 data.cpt_total += cpt_cracked;
2280
2281 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2282
2283 hc_thread_mutex_unlock (mux_display);
2284 }
2285
2286 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2287 {
2288 // we need to reset cracked state on the device
2289 // otherwise host thinks again and again the hash was cracked
2290 // and returns invalid password each time
2291
2292 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2293
2294 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);
2295 }
2296
2297 num_cracked = 0;
2298
2299 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2300 }
2301 }
2302
2303 static void save_hash ()
2304 {
2305 char *hashfile = data.hashfile;
2306
2307 char new_hashfile[256] = { 0 };
2308 char old_hashfile[256] = { 0 };
2309
2310 snprintf (new_hashfile, 255, "%s.new", hashfile);
2311 snprintf (old_hashfile, 255, "%s.old", hashfile);
2312
2313 unlink (new_hashfile);
2314
2315 char separator = data.separator;
2316
2317 FILE *fp = fopen (new_hashfile, "wb");
2318
2319 if (fp == NULL)
2320 {
2321 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2322
2323 exit (-1);
2324 }
2325
2326 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2327 {
2328 if (data.salts_shown[salt_pos] == 1) continue;
2329
2330 salt_t *salt_buf = &data.salts_buf[salt_pos];
2331
2332 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2333 {
2334 uint idx = salt_buf->digests_offset + digest_pos;
2335
2336 if (data.digests_shown[idx] == 1) continue;
2337
2338 if (data.hash_mode != 2500)
2339 {
2340 char out_buf[HCBUFSIZ] = { 0 };
2341
2342 if (data.username == 1)
2343 {
2344 user_t *user = data.hash_info[idx]->user;
2345
2346 uint i;
2347
2348 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2349
2350 fputc (separator, fp);
2351 }
2352
2353 ascii_digest (out_buf, salt_pos, digest_pos);
2354
2355 fputs (out_buf, fp);
2356
2357 log_out (fp, "");
2358 }
2359 else
2360 {
2361 hccap_t hccap;
2362
2363 to_hccap_t (&hccap, salt_pos, digest_pos);
2364
2365 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2366 }
2367 }
2368 }
2369
2370 fflush (fp);
2371
2372 fclose (fp);
2373
2374 unlink (old_hashfile);
2375
2376 if (rename (hashfile, old_hashfile) != 0)
2377 {
2378 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2379
2380 exit (-1);
2381 }
2382
2383 unlink (hashfile);
2384
2385 if (rename (new_hashfile, hashfile) != 0)
2386 {
2387 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2388
2389 exit (-1);
2390 }
2391
2392 unlink (old_hashfile);
2393 }
2394
2395 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2396 {
2397 // function called only in case kernel_power_all > words_left
2398
2399 float kernel_power_div = (float) (total_left) / kernel_power_all;
2400
2401 kernel_power_div += kernel_power_div / 100;
2402
2403 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2404
2405 while (kernel_power_new < total_left)
2406 {
2407 kernel_power_div += kernel_power_div / 100;
2408
2409 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2410 }
2411
2412 if (data.quiet == 0)
2413 {
2414 clear_prompt ();
2415
2416 //log_info ("");
2417
2418 log_info ("INFO: approaching final keyspace, workload adjusted");
2419 log_info ("");
2420
2421 fprintf (stdout, "%s", PROMPT);
2422
2423 fflush (stdout);
2424 }
2425
2426 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2427
2428 return kernel_power_div;
2429 }
2430
2431 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2432 {
2433 uint num_elements = num;
2434
2435 device_param->kernel_params_buf32[30] = data.combs_mode;
2436 device_param->kernel_params_buf32[31] = num;
2437
2438 uint kernel_threads = device_param->kernel_threads;
2439
2440 while (num_elements % kernel_threads) num_elements++;
2441
2442 cl_kernel kernel = NULL;
2443
2444 switch (kern_run)
2445 {
2446 case KERN_RUN_1: kernel = device_param->kernel1; break;
2447 case KERN_RUN_12: kernel = device_param->kernel12; break;
2448 case KERN_RUN_2: kernel = device_param->kernel2; break;
2449 case KERN_RUN_23: kernel = device_param->kernel23; break;
2450 case KERN_RUN_3: kernel = device_param->kernel3; break;
2451 }
2452
2453 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2454 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2455 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2456 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2457 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2458 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2459 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2460 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2461 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2462 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2463 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2464
2465 cl_event event;
2466
2467 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2468 {
2469 const size_t global_work_size[3] = { num_elements, 32, 1 };
2470 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2471
2472 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2473 }
2474 else
2475 {
2476 if (kern_run == KERN_RUN_2)
2477 {
2478 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2479 {
2480 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2481 }
2482 }
2483
2484 while (num_elements % kernel_threads) num_elements++;
2485
2486 const size_t global_work_size[3] = { num_elements, 1, 1 };
2487 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2488
2489 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2490 }
2491
2492 hc_clFlush (data.ocl, device_param->command_queue);
2493
2494 hc_clWaitForEvents (data.ocl, 1, &event);
2495
2496 if (event_update)
2497 {
2498 cl_ulong time_start;
2499 cl_ulong time_end;
2500
2501 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2502 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2503
2504 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2505
2506 uint exec_pos = device_param->exec_pos;
2507
2508 device_param->exec_ms[exec_pos] = exec_time;
2509
2510 exec_pos++;
2511
2512 if (exec_pos == EXEC_CACHE)
2513 {
2514 exec_pos = 0;
2515 }
2516
2517 device_param->exec_pos = exec_pos;
2518 }
2519
2520 hc_clReleaseEvent (data.ocl, event);
2521
2522 hc_clFinish (data.ocl, device_param->command_queue);
2523 }
2524
2525 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2526 {
2527 uint num_elements = num;
2528
2529 switch (kern_run)
2530 {
2531 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2532 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2533 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2534 }
2535
2536 // causes problems with special threads like in bcrypt
2537 // const uint kernel_threads = device_param->kernel_threads;
2538
2539 uint kernel_threads = device_param->kernel_threads;
2540
2541 while (num_elements % kernel_threads) num_elements++;
2542
2543 cl_kernel kernel = NULL;
2544
2545 switch (kern_run)
2546 {
2547 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2548 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2549 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2550 }
2551
2552 switch (kern_run)
2553 {
2554 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2555 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2556 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2557 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2558 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2559 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2560 break;
2561 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2562 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2563 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2564 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2565 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2566 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2567 break;
2568 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2569 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2570 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2571 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2572 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2573 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2574 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2575 break;
2576 }
2577
2578 const size_t global_work_size[3] = { num_elements, 1, 1 };
2579 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2580
2581 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2582
2583 hc_clFlush (data.ocl, device_param->command_queue);
2584
2585 hc_clFinish (data.ocl, device_param->command_queue);
2586 }
2587
2588 static void run_kernel_tm (hc_device_param_t *device_param)
2589 {
2590 const uint num_elements = 1024; // fixed
2591
2592 uint kernel_threads = 32;
2593
2594 cl_kernel kernel = device_param->kernel_tm;
2595
2596 const size_t global_work_size[3] = { num_elements, 1, 1 };
2597 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2598
2599 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2600
2601 hc_clFlush (data.ocl, device_param->command_queue);
2602
2603 hc_clFinish (data.ocl, device_param->command_queue);
2604 }
2605
2606 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2607 {
2608 uint num_elements = num;
2609
2610 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2611 device_param->kernel_params_amp_buf32[6] = num_elements;
2612
2613 // causes problems with special threads like in bcrypt
2614 // const uint kernel_threads = device_param->kernel_threads;
2615
2616 uint kernel_threads = device_param->kernel_threads;
2617
2618 while (num_elements % kernel_threads) num_elements++;
2619
2620 cl_kernel kernel = device_param->kernel_amp;
2621
2622 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2623 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2624
2625 const size_t global_work_size[3] = { num_elements, 1, 1 };
2626 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2627
2628 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2629
2630 hc_clFlush (data.ocl, device_param->command_queue);
2631
2632 hc_clFinish (data.ocl, device_param->command_queue);
2633 }
2634
2635 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2636 {
2637 const u32 num16d = num / 16;
2638 const u32 num16m = num % 16;
2639
2640 if (num16d)
2641 {
2642 device_param->kernel_params_memset_buf32[1] = value;
2643 device_param->kernel_params_memset_buf32[2] = num16d;
2644
2645 uint kernel_threads = device_param->kernel_threads;
2646
2647 uint num_elements = num16d;
2648
2649 while (num_elements % kernel_threads) num_elements++;
2650
2651 cl_kernel kernel = device_param->kernel_memset;
2652
2653 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2654 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2655 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2656
2657 const size_t global_work_size[3] = { num_elements, 1, 1 };
2658 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2659
2660 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2661
2662 hc_clFlush (data.ocl, device_param->command_queue);
2663
2664 hc_clFinish (data.ocl, device_param->command_queue);
2665 }
2666
2667 if (num16m)
2668 {
2669 u32 tmp[4];
2670
2671 tmp[0] = value;
2672 tmp[1] = value;
2673 tmp[2] = value;
2674 tmp[3] = value;
2675
2676 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2677 }
2678 }
2679
2680 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2681 {
2682 run_kernel_memset (device_param, buf, 0, size);
2683
2684 /*
2685 int rc = -1;
2686
2687 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2688 {
2689 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2690
2691 const cl_uchar zero = 0;
2692
2693 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2694 }
2695
2696 if (rc != 0)
2697 {
2698 // NOTE: clEnqueueFillBuffer () always fails with -59
2699 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2700 // How's that possible, OpenCL 1.2 support is advertised??
2701 // We need to workaround...
2702
2703 #define FILLSZ 0x100000
2704
2705 char *tmp = (char *) mymalloc (FILLSZ);
2706
2707 for (size_t i = 0; i < size; i += FILLSZ)
2708 {
2709 const size_t left = size - i;
2710
2711 const size_t fillsz = MIN (FILLSZ, left);
2712
2713 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2714 }
2715
2716 myfree (tmp);
2717 }
2718 */
2719 }
2720
2721 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)
2722 {
2723 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2724 {
2725 if (attack_mode == ATTACK_MODE_BF)
2726 {
2727 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2728 {
2729 const uint size_tm = 32 * sizeof (bs_word_t);
2730
2731 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2732
2733 run_kernel_tm (device_param);
2734
2735 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);
2736 }
2737 }
2738
2739 if (highest_pw_len < 16)
2740 {
2741 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2742 }
2743 else if (highest_pw_len < 32)
2744 {
2745 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2746 }
2747 else
2748 {
2749 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2750 }
2751 }
2752 else
2753 {
2754 run_kernel_amp (device_param, pws_cnt);
2755
2756 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2757
2758 if (opts_type & OPTS_TYPE_HOOK12)
2759 {
2760 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2761 }
2762
2763 uint iter = salt_buf->salt_iter;
2764
2765 uint loop_step = device_param->kernel_loops;
2766
2767 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2768 {
2769 uint loop_left = iter - loop_pos;
2770
2771 loop_left = MIN (loop_left, loop_step);
2772
2773 device_param->kernel_params_buf32[25] = loop_pos;
2774 device_param->kernel_params_buf32[26] = loop_left;
2775
2776 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2777
2778 if (data.devices_status == STATUS_CRACKED) break;
2779 if (data.devices_status == STATUS_ABORTED) break;
2780 if (data.devices_status == STATUS_QUIT) break;
2781
2782 /**
2783 * speed
2784 */
2785
2786 const float iter_part = (float) (loop_pos + loop_left) / iter;
2787
2788 const u64 perf_sum_all = pws_cnt * iter_part;
2789
2790 double speed_ms;
2791
2792 hc_timer_get (device_param->timer_speed, speed_ms);
2793
2794 const u32 speed_pos = device_param->speed_pos;
2795
2796 device_param->speed_cnt[speed_pos] = perf_sum_all;
2797
2798 device_param->speed_ms[speed_pos] = speed_ms;
2799
2800 if (data.benchmark == 1)
2801 {
2802 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2803 }
2804 }
2805
2806 if (opts_type & OPTS_TYPE_HOOK23)
2807 {
2808 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2809
2810 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);
2811
2812 // do something with data
2813
2814 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);
2815 }
2816
2817 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2818 }
2819 }
2820
2821 static int run_rule_engine (const int rule_len, const char *rule_buf)
2822 {
2823 if (rule_len == 0)
2824 {
2825 return 0;
2826 }
2827 else if (rule_len == 1)
2828 {
2829 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2830 }
2831
2832 return 1;
2833 }
2834
2835 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2836 {
2837 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2838 {
2839 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);
2840 }
2841 else if (data.attack_kern == ATTACK_KERN_COMBI)
2842 {
2843 if (data.attack_mode == ATTACK_MODE_COMBI)
2844 {
2845 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2846 {
2847 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2848 {
2849 for (u32 i = 0; i < pws_cnt; i++)
2850 {
2851 const u32 pw_len = device_param->pws_buf[i].pw_len;
2852
2853 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2854
2855 ptr[pw_len] = 0x01;
2856 }
2857 }
2858 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2859 {
2860 for (u32 i = 0; i < pws_cnt; i++)
2861 {
2862 const u32 pw_len = device_param->pws_buf[i].pw_len;
2863
2864 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2865
2866 ptr[pw_len] = 0x80;
2867 }
2868 }
2869 }
2870 }
2871 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2872 {
2873 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2874 {
2875 for (u32 i = 0; i < pws_cnt; i++)
2876 {
2877 const u32 pw_len = device_param->pws_buf[i].pw_len;
2878
2879 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2880
2881 ptr[pw_len] = 0x01;
2882 }
2883 }
2884 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2885 {
2886 for (u32 i = 0; i < pws_cnt; i++)
2887 {
2888 const u32 pw_len = device_param->pws_buf[i].pw_len;
2889
2890 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2891
2892 ptr[pw_len] = 0x80;
2893 }
2894 }
2895 }
2896
2897 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);
2898 }
2899 else if (data.attack_kern == ATTACK_KERN_BF)
2900 {
2901 const u64 off = device_param->words_off;
2902
2903 device_param->kernel_params_mp_l_buf64[3] = off;
2904
2905 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2906 }
2907 }
2908
2909 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2910 {
2911 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2912
2913 device_param->kernel_params_buf32[25] = 0;
2914 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2915 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2916
2917 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2918 {
2919 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2920 }
2921 else
2922 {
2923 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2924 }
2925
2926 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2927
2928 return exec_ms_prev;
2929 }
2930
2931 static void autotune (hc_device_param_t *device_param)
2932 {
2933 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2934
2935 const u32 kernel_accel_min = device_param->kernel_accel_min;
2936 const u32 kernel_accel_max = device_param->kernel_accel_max;
2937
2938 const u32 kernel_loops_min = device_param->kernel_loops_min;
2939 const u32 kernel_loops_max = device_param->kernel_loops_max;
2940
2941 u32 kernel_accel = kernel_accel_min;
2942 u32 kernel_loops = kernel_loops_min;
2943
2944 // in this case the user specified a fixed -u and -n on the commandline
2945 // no way to tune anything
2946 // but we need to run a few caching rounds
2947
2948 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2949 {
2950 try_run (device_param, kernel_accel, kernel_loops);
2951 try_run (device_param, kernel_accel, kernel_loops);
2952 try_run (device_param, kernel_accel, kernel_loops);
2953 try_run (device_param, kernel_accel, kernel_loops);
2954
2955 device_param->kernel_accel = kernel_accel;
2956 device_param->kernel_loops = kernel_loops;
2957
2958 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2959
2960 device_param->kernel_power = kernel_power;
2961
2962 return;
2963 }
2964
2965 // from here it's clear we are allowed to autotune
2966 // so let's init some fake words
2967
2968 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2969
2970 if (data.attack_kern == ATTACK_KERN_BF)
2971 {
2972 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2973 }
2974 else
2975 {
2976 for (u32 i = 0; i < kernel_power_max; i++)
2977 {
2978 device_param->pws_buf[i].i[0] = i;
2979 device_param->pws_buf[i].i[1] = 0x01234567;
2980 device_param->pws_buf[i].pw_len = 7 + (i & 7);
2981 }
2982
2983 if (data.kernel_rules_cnt > 1)
2984 {
2985 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);
2986 }
2987
2988 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);
2989 }
2990
2991 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2992 {
2993 run_kernel_amp (device_param, kernel_power_max);
2994 }
2995
2996 #define VERIFIER_CNT 1
2997
2998 // first find out highest kernel-loops that stays below target_ms
2999
3000 if (kernel_loops_min < kernel_loops_max)
3001 {
3002 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3003 {
3004 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3005
3006 for (int i = 0; i < VERIFIER_CNT; i++)
3007 {
3008 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3009
3010 exec_ms = MIN (exec_ms, exec_ms_v);
3011 }
3012
3013 if (exec_ms < target_ms) break;
3014 }
3015 }
3016
3017 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3018
3019 #define STEPS_CNT 10
3020
3021 if (kernel_accel_min < kernel_accel_max)
3022 {
3023 for (int i = 0; i < STEPS_CNT; i++)
3024 {
3025 const u32 kernel_accel_try = 1 << i;
3026
3027 if (kernel_accel_try < kernel_accel_min) continue;
3028 if (kernel_accel_try > kernel_accel_max) break;
3029
3030 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3031
3032 for (int i = 0; i < VERIFIER_CNT; i++)
3033 {
3034 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3035
3036 exec_ms = MIN (exec_ms, exec_ms_v);
3037 }
3038
3039 if (exec_ms > target_ms) break;
3040
3041 kernel_accel = kernel_accel_try;
3042 }
3043 }
3044
3045 // at this point we want to know the actual runtime for the following reason:
3046 // we need a reference for the balancing loop following up, and this
3047 // the balancing loop can have an effect that the creates a new opportunity, for example:
3048 // if the target is 95 ms and the current runtime is 48ms the above loop
3049 // stopped the execution because the previous exec_ms was > 95ms
3050 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3051 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3052
3053 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3054
3055 for (int i = 0; i < VERIFIER_CNT; i++)
3056 {
3057 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3058
3059 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3060 }
3061
3062 u32 diff = kernel_loops - kernel_accel;
3063
3064 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3065 {
3066 u32 kernel_accel_orig = kernel_accel;
3067 u32 kernel_loops_orig = kernel_loops;
3068
3069 for (u32 f = 1; f < 1024; f++)
3070 {
3071 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3072 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3073
3074 if (kernel_accel_try > kernel_accel_max) break;
3075 if (kernel_loops_try < kernel_loops_min) break;
3076
3077 u32 diff_new = kernel_loops_try - kernel_accel_try;
3078
3079 if (diff_new > diff) break;
3080
3081 diff_new = diff;
3082
3083 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3084
3085 for (int i = 0; i < VERIFIER_CNT; i++)
3086 {
3087 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3088
3089 exec_ms = MIN (exec_ms, exec_ms_v);
3090 }
3091
3092 if (exec_ms < exec_ms_pre_final)
3093 {
3094 exec_ms_pre_final = exec_ms;
3095
3096 kernel_accel = kernel_accel_try;
3097 kernel_loops = kernel_loops_try;
3098 }
3099 }
3100 }
3101
3102 const double exec_left = target_ms / exec_ms_pre_final;
3103
3104 const double accel_left = kernel_accel_max / kernel_accel;
3105
3106 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3107
3108 if (exec_accel_min >= 1.0)
3109 {
3110 // this is safe to not overflow kernel_accel_max because of accel_left
3111
3112 kernel_accel = (double) kernel_accel * exec_accel_min;
3113 }
3114
3115 // reset them fake words
3116
3117 /*
3118 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3119
3120 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);
3121 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);
3122 */
3123
3124 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3125
3126 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3127 {
3128 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3129 }
3130
3131 // reset timer
3132
3133 device_param->exec_pos = 0;
3134
3135 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3136
3137 // store
3138
3139 device_param->kernel_accel = kernel_accel;
3140 device_param->kernel_loops = kernel_loops;
3141
3142 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3143
3144 device_param->kernel_power = kernel_power;
3145
3146 #ifdef DEBUG
3147
3148 if (data.quiet == 0)
3149 {
3150 clear_prompt ();
3151
3152 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3153 "Device #%u: autotuned kernel-loops to %u\n",
3154 device_param->device_id + 1, kernel_accel,
3155 device_param->device_id + 1, kernel_loops);
3156
3157 fprintf (stdout, "%s", PROMPT);
3158
3159 fflush (stdout);
3160 }
3161
3162 #endif
3163 }
3164
3165 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3166 {
3167 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3168
3169 // init speed timer
3170
3171 uint speed_pos = device_param->speed_pos;
3172
3173 #ifdef _POSIX
3174 if (device_param->timer_speed.tv_sec == 0)
3175 {
3176 hc_timer_set (&device_param->timer_speed);
3177 }
3178 #endif
3179
3180 #ifdef _WIN
3181 if (device_param->timer_speed.QuadPart == 0)
3182 {
3183 hc_timer_set (&device_param->timer_speed);
3184 }
3185 #endif
3186
3187 // find higest password length, this is for optimization stuff
3188
3189 uint highest_pw_len = 0;
3190
3191 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3192 {
3193 }
3194 else if (data.attack_kern == ATTACK_KERN_COMBI)
3195 {
3196 }
3197 else if (data.attack_kern == ATTACK_KERN_BF)
3198 {
3199 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3200 + device_param->kernel_params_mp_l_buf32[5];
3201 }
3202
3203 // iteration type
3204
3205 uint innerloop_step = 0;
3206 uint innerloop_cnt = 0;
3207
3208 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3209 else innerloop_step = 1;
3210
3211 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3212 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3213 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3214
3215 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3216
3217 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3218 {
3219 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3220
3221 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3222
3223 if (data.devices_status == STATUS_CRACKED) break;
3224 if (data.devices_status == STATUS_ABORTED) break;
3225 if (data.devices_status == STATUS_QUIT) break;
3226 if (data.devices_status == STATUS_BYPASS) break;
3227
3228 salt_t *salt_buf = &data.salts_buf[salt_pos];
3229
3230 device_param->kernel_params_buf32[24] = salt_pos;
3231 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3232 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3233
3234 FILE *combs_fp = device_param->combs_fp;
3235
3236 if (data.attack_mode == ATTACK_MODE_COMBI)
3237 {
3238 rewind (combs_fp);
3239 }
3240
3241 // innerloops
3242
3243 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3244 {
3245 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3246
3247 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3248
3249 if (data.devices_status == STATUS_CRACKED) break;
3250 if (data.devices_status == STATUS_ABORTED) break;
3251 if (data.devices_status == STATUS_QUIT) break;
3252 if (data.devices_status == STATUS_BYPASS) break;
3253
3254 uint innerloop_left = innerloop_cnt - innerloop_pos;
3255
3256 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3257
3258 device_param->innerloop_pos = innerloop_pos;
3259 device_param->innerloop_left = innerloop_left;
3260
3261 device_param->kernel_params_buf32[27] = innerloop_left;
3262
3263 // i think we can get rid of this
3264 if (innerloop_left == 0)
3265 {
3266 puts ("bug, how should this happen????\n");
3267
3268 continue;
3269 }
3270
3271 if (data.salts_shown[salt_pos] == 1)
3272 {
3273 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3274
3275 continue;
3276 }
3277
3278 // initialize amplifiers
3279
3280 if (data.attack_mode == ATTACK_MODE_COMBI)
3281 {
3282 uint i = 0;
3283
3284 while (i < innerloop_left)
3285 {
3286 if (feof (combs_fp)) break;
3287
3288 int line_len = fgetl (combs_fp, line_buf);
3289
3290 if (line_len >= PW_MAX1) continue;
3291
3292 line_len = convert_from_hex (line_buf, line_len);
3293
3294 char *line_buf_new = line_buf;
3295
3296 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3297 {
3298 char rule_buf_out[BLOCK_SIZE] = { 0 };
3299
3300 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3301
3302 if (rule_len_out < 0)
3303 {
3304 data.words_progress_rejected[salt_pos] += pws_cnt;
3305
3306 continue;
3307 }
3308
3309 line_len = rule_len_out;
3310
3311 line_buf_new = rule_buf_out;
3312 }
3313
3314 line_len = MIN (line_len, PW_DICTMAX);
3315
3316 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3317
3318 memcpy (ptr, line_buf_new, line_len);
3319
3320 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3321
3322 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3323 {
3324 uppercase (ptr, line_len);
3325 }
3326
3327 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3328 {
3329 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3330 {
3331 ptr[line_len] = 0x80;
3332 }
3333
3334 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3335 {
3336 ptr[line_len] = 0x01;
3337 }
3338 }
3339
3340 device_param->combs_buf[i].pw_len = line_len;
3341
3342 i++;
3343 }
3344
3345 for (uint j = i; j < innerloop_left; j++)
3346 {
3347 device_param->combs_buf[j].i[0] = 0;
3348 device_param->combs_buf[j].i[1] = 0;
3349 device_param->combs_buf[j].i[2] = 0;
3350 device_param->combs_buf[j].i[3] = 0;
3351 device_param->combs_buf[j].i[4] = 0;
3352 device_param->combs_buf[j].i[5] = 0;
3353 device_param->combs_buf[j].i[6] = 0;
3354 device_param->combs_buf[j].i[7] = 0;
3355
3356 device_param->combs_buf[j].pw_len = 0;
3357 }
3358
3359 innerloop_left = i;
3360 }
3361 else if (data.attack_mode == ATTACK_MODE_BF)
3362 {
3363 u64 off = innerloop_pos;
3364
3365 device_param->kernel_params_mp_r_buf64[3] = off;
3366
3367 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3368 }
3369 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3370 {
3371 u64 off = innerloop_pos;
3372
3373 device_param->kernel_params_mp_buf64[3] = off;
3374
3375 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3376 }
3377 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3378 {
3379 u64 off = innerloop_pos;
3380
3381 device_param->kernel_params_mp_buf64[3] = off;
3382
3383 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3384 }
3385
3386 // copy amplifiers
3387
3388 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3389 {
3390 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);
3391 }
3392 else if (data.attack_mode == ATTACK_MODE_COMBI)
3393 {
3394 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);
3395 }
3396 else if (data.attack_mode == ATTACK_MODE_BF)
3397 {
3398 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);
3399 }
3400 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3401 {
3402 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);
3403 }
3404 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3405 {
3406 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);
3407 }
3408
3409 if (data.benchmark == 1)
3410 {
3411 hc_timer_set (&device_param->timer_speed);
3412 }
3413
3414 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3415
3416 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3417
3418 if (data.devices_status == STATUS_CRACKED) break;
3419 if (data.devices_status == STATUS_ABORTED) break;
3420 if (data.devices_status == STATUS_QUIT) break;
3421
3422 /**
3423 * result
3424 */
3425
3426 check_cracked (device_param, salt_pos);
3427
3428 /**
3429 * progress
3430 */
3431
3432 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3433
3434 hc_thread_mutex_lock (mux_counter);
3435
3436 data.words_progress_done[salt_pos] += perf_sum_all;
3437
3438 hc_thread_mutex_unlock (mux_counter);
3439
3440 /**
3441 * speed
3442 */
3443
3444 double speed_ms;
3445
3446 hc_timer_get (device_param->timer_speed, speed_ms);
3447
3448 hc_timer_set (&device_param->timer_speed);
3449
3450 // current speed
3451
3452 //hc_thread_mutex_lock (mux_display);
3453
3454 device_param->speed_cnt[speed_pos] = perf_sum_all;
3455
3456 device_param->speed_ms[speed_pos] = speed_ms;
3457
3458 //hc_thread_mutex_unlock (mux_display);
3459
3460 speed_pos++;
3461
3462 if (speed_pos == SPEED_CACHE)
3463 {
3464 speed_pos = 0;
3465 }
3466
3467 /**
3468 * benchmark
3469 */
3470
3471 if (data.benchmark == 1) break;
3472 }
3473 }
3474
3475 device_param->speed_pos = speed_pos;
3476
3477 myfree (line_buf);
3478 }
3479
3480 static void load_segment (wl_data_t *wl_data, FILE *fd)
3481 {
3482 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3483
3484 wl_data->pos = 0;
3485
3486 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3487
3488 wl_data->buf[wl_data->cnt] = 0;
3489
3490 if (wl_data->cnt == 0) return;
3491
3492 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3493
3494 while (!feof (fd))
3495 {
3496 if (wl_data->cnt == wl_data->avail)
3497 {
3498 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3499
3500 wl_data->avail += wl_data->incr;
3501 }
3502
3503 const int c = fgetc (fd);
3504
3505 if (c == EOF) break;
3506
3507 wl_data->buf[wl_data->cnt] = (char) c;
3508
3509 wl_data->cnt++;
3510
3511 if (c == '\n') break;
3512 }
3513
3514 // ensure stream ends with a newline
3515
3516 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3517 {
3518 wl_data->cnt++;
3519
3520 wl_data->buf[wl_data->cnt - 1] = '\n';
3521 }
3522
3523 return;
3524 }
3525
3526 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3527 {
3528 char *ptr = buf;
3529
3530 for (u32 i = 0; i < sz; i++, ptr++)
3531 {
3532 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3533
3534 if (i == 7)
3535 {
3536 *off = i;
3537 *len = i;
3538
3539 return;
3540 }
3541
3542 if (*ptr != '\n') continue;
3543
3544 *off = i + 1;
3545
3546 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3547
3548 *len = i;
3549
3550 return;
3551 }
3552
3553 *off = sz;
3554 *len = sz;
3555 }
3556
3557 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3558 {
3559 char *ptr = buf;
3560
3561 for (u32 i = 0; i < sz; i++, ptr++)
3562 {
3563 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3564
3565 if (*ptr != '\n') continue;
3566
3567 *off = i + 1;
3568
3569 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3570
3571 *len = i;
3572
3573 return;
3574 }
3575
3576 *off = sz;
3577 *len = sz;
3578 }
3579
3580 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3581 {
3582 char *ptr = buf;
3583
3584 for (u32 i = 0; i < sz; i++, ptr++)
3585 {
3586 if (*ptr != '\n') continue;
3587
3588 *off = i + 1;
3589
3590 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3591
3592 *len = i;
3593
3594 return;
3595 }
3596
3597 *off = sz;
3598 *len = sz;
3599 }
3600
3601 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3602 {
3603 while (wl_data->pos < wl_data->cnt)
3604 {
3605 uint off;
3606 uint len;
3607
3608 char *ptr = wl_data->buf + wl_data->pos;
3609
3610 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3611
3612 wl_data->pos += off;
3613
3614 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3615 {
3616 char rule_buf_out[BLOCK_SIZE] = { 0 };
3617
3618 int rule_len_out = -1;
3619
3620 if (len < BLOCK_SIZE)
3621 {
3622 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3623 }
3624
3625 if (rule_len_out < 0)
3626 {
3627 continue;
3628 }
3629
3630 if (rule_len_out > PW_MAX)
3631 {
3632 continue;
3633 }
3634 }
3635 else
3636 {
3637 if (len > PW_MAX)
3638 {
3639 continue;
3640 }
3641 }
3642
3643 *out_buf = ptr;
3644 *out_len = len;
3645
3646 return;
3647 }
3648
3649 if (feof (fd))
3650 {
3651 fprintf (stderr, "BUG feof()!!\n");
3652
3653 return;
3654 }
3655
3656 load_segment (wl_data, fd);
3657
3658 get_next_word (wl_data, fd, out_buf, out_len);
3659 }
3660
3661 #ifdef _POSIX
3662 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3663 #endif
3664
3665 #ifdef _WIN
3666 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3667 #endif
3668 {
3669 hc_signal (NULL);
3670
3671 dictstat_t d;
3672
3673 d.cnt = 0;
3674
3675 #ifdef _POSIX
3676 fstat (fileno (fd), &d.stat);
3677 #endif
3678
3679 #ifdef _WIN
3680 _fstat64 (fileno (fd), &d.stat);
3681 #endif
3682
3683 d.stat.st_mode = 0;
3684 d.stat.st_nlink = 0;
3685 d.stat.st_uid = 0;
3686 d.stat.st_gid = 0;
3687 d.stat.st_rdev = 0;
3688 d.stat.st_atime = 0;
3689
3690 #ifdef _POSIX
3691 d.stat.st_blksize = 0;
3692 d.stat.st_blocks = 0;
3693 #endif
3694
3695 if (d.stat.st_size == 0) return 0;
3696
3697 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3698
3699 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3700 {
3701 if (d_cache)
3702 {
3703 u64 cnt = d_cache->cnt;
3704
3705 u64 keyspace = cnt;
3706
3707 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3708 {
3709 keyspace *= data.kernel_rules_cnt;
3710 }
3711 else if (data.attack_kern == ATTACK_KERN_COMBI)
3712 {
3713 keyspace *= data.combs_cnt;
3714 }
3715
3716 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);
3717 if (data.quiet == 0) log_info ("");
3718
3719 hc_signal (sigHandler_default);
3720
3721 return (keyspace);
3722 }
3723 }
3724
3725 time_t now = 0;
3726 time_t prev = 0;
3727
3728 u64 comp = 0;
3729 u64 cnt = 0;
3730 u64 cnt2 = 0;
3731
3732 while (!feof (fd))
3733 {
3734 load_segment (wl_data, fd);
3735
3736 comp += wl_data->cnt;
3737
3738 u32 i = 0;
3739
3740 while (i < wl_data->cnt)
3741 {
3742 u32 len;
3743 u32 off;
3744
3745 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3746
3747 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3748 {
3749 char rule_buf_out[BLOCK_SIZE] = { 0 };
3750
3751 int rule_len_out = -1;
3752
3753 if (len < BLOCK_SIZE)
3754 {
3755 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3756 }
3757
3758 if (rule_len_out < 0)
3759 {
3760 len = PW_MAX1;
3761 }
3762 else
3763 {
3764 len = rule_len_out;
3765 }
3766 }
3767
3768 if (len < PW_MAX1)
3769 {
3770 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3771 {
3772 cnt += data.kernel_rules_cnt;
3773 }
3774 else if (data.attack_kern == ATTACK_KERN_COMBI)
3775 {
3776 cnt += data.combs_cnt;
3777 }
3778
3779 d.cnt++;
3780 }
3781
3782 i += off;
3783
3784 cnt2++;
3785 }
3786
3787 time (&now);
3788
3789 if ((now - prev) == 0) continue;
3790
3791 float percent = (float) comp / (float) d.stat.st_size;
3792
3793 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);
3794
3795 time (&prev);
3796 }
3797
3798 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);
3799 if (data.quiet == 0) log_info ("");
3800
3801 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3802
3803 hc_signal (sigHandler_default);
3804
3805 return (cnt);
3806 }
3807
3808 static void *thread_monitor (void *p)
3809 {
3810 uint runtime_check = 0;
3811 uint remove_check = 0;
3812 uint status_check = 0;
3813 uint restore_check = 0;
3814
3815 uint restore_left = data.restore_timer;
3816 uint remove_left = data.remove_timer;
3817 uint status_left = data.status_timer;
3818
3819 #ifdef HAVE_HWMON
3820 uint hwmon_check = 0;
3821
3822 int slowdown_warnings = 0;
3823
3824 // these variables are mainly used for fan control
3825
3826 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3827
3828 // temperature controller "loopback" values
3829
3830 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3831 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3832
3833 int temp_threshold = 1; // degrees celcius
3834
3835 int fan_speed_min = 15; // in percentage
3836 int fan_speed_max = 100;
3837
3838 time_t last_temp_check_time;
3839 #endif // HAVE_HWMON
3840
3841 uint sleep_time = 1;
3842
3843 if (data.runtime)
3844 {
3845 runtime_check = 1;
3846 }
3847
3848 if (data.restore_timer)
3849 {
3850 restore_check = 1;
3851 }
3852
3853 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3854 {
3855 remove_check = 1;
3856 }
3857
3858 if (data.status == 1)
3859 {
3860 status_check = 1;
3861 }
3862
3863 #ifdef HAVE_HWMON
3864 if (data.gpu_temp_disable == 0)
3865 {
3866 time (&last_temp_check_time);
3867
3868 hwmon_check = 1;
3869 }
3870 #endif
3871
3872 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3873 {
3874 #ifdef HAVE_HWMON
3875 if (hwmon_check == 0)
3876 #endif
3877 return (p);
3878 }
3879
3880 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3881 {
3882 hc_sleep (sleep_time);
3883
3884 if (data.devices_status != STATUS_RUNNING) continue;
3885
3886 #ifdef HAVE_HWMON
3887
3888 if (1)
3889 {
3890 hc_thread_mutex_lock (mux_adl);
3891
3892 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3893 {
3894 hc_device_param_t *device_param = &data.devices_param[device_id];
3895
3896 if (device_param->skipped) continue;
3897
3898 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3899
3900 const int temperature = hm_get_temperature_with_device_id (device_id);
3901
3902 const int threshold = data.hm_device[device_id].gpu_temp_threshold_slowdown;
3903
3904 if (temperature >= threshold)
3905 {
3906 if (slowdown_warnings < 3)
3907 {
3908 if (data.quiet == 0) clear_prompt ();
3909
3910 log_info ("WARNING: Drivers temperature threshold (%dc) hit on GPU #%d, expect performance to drop...", threshold, device_id + 1);
3911
3912 if (slowdown_warnings == 2)
3913 {
3914 log_info ("");
3915 }
3916
3917 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
3918 if (data.quiet == 0) fflush (stdout);
3919
3920 slowdown_warnings++;
3921 }
3922 }
3923 else
3924 {
3925 slowdown_warnings = 0;
3926 }
3927 }
3928
3929 hc_thread_mutex_unlock (mux_adl);
3930 }
3931
3932 if (hwmon_check == 1)
3933 {
3934 hc_thread_mutex_lock (mux_adl);
3935
3936 time_t temp_check_time;
3937
3938 time (&temp_check_time);
3939
3940 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3941
3942 if (Ta == 0) Ta = 1;
3943
3944 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3945 {
3946 hc_device_param_t *device_param = &data.devices_param[device_id];
3947
3948 if (device_param->skipped) continue;
3949
3950 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3951
3952 const int temperature = hm_get_temperature_with_device_id (device_id);
3953
3954 if (temperature > (int) data.gpu_temp_abort)
3955 {
3956 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3957
3958 if (data.devices_status != STATUS_QUIT) myabort ();
3959
3960 break;
3961 }
3962
3963 const int gpu_temp_retain = data.gpu_temp_retain;
3964
3965 if (gpu_temp_retain)
3966 {
3967 if (data.hm_device[device_id].fan_set_supported == 1)
3968 {
3969 int temp_cur = temperature;
3970
3971 int temp_diff_new = gpu_temp_retain - temp_cur;
3972
3973 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3974
3975 // calculate Ta value (time difference in seconds between the last check and this check)
3976
3977 last_temp_check_time = temp_check_time;
3978
3979 float Kp = 1.8;
3980 float Ki = 0.005;
3981 float Kd = 6;
3982
3983 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3984
3985 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);
3986
3987 if (abs (fan_diff_required) >= temp_threshold)
3988 {
3989 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3990
3991 int fan_speed_level = fan_speed_cur;
3992
3993 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3994
3995 int fan_speed_new = fan_speed_level - fan_diff_required;
3996
3997 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3998 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3999
4000 if (fan_speed_new != fan_speed_cur)
4001 {
4002 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4003 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4004
4005 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4006 {
4007 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4008 {
4009 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new, 1);
4010 }
4011 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4012 {
4013
4014 }
4015
4016 fan_speed_chgd[device_id] = 1;
4017 }
4018
4019 temp_diff_old[device_id] = temp_diff_new;
4020 }
4021 }
4022 }
4023 }
4024 }
4025
4026 hc_thread_mutex_unlock (mux_adl);
4027 }
4028 #endif // HAVE_HWMON
4029
4030 if (restore_check == 1)
4031 {
4032 restore_left--;
4033
4034 if (restore_left == 0)
4035 {
4036 if (data.restore_disable == 0) cycle_restore ();
4037
4038 restore_left = data.restore_timer;
4039 }
4040 }
4041
4042 if ((runtime_check == 1) && (data.runtime_start > 0))
4043 {
4044 time_t runtime_cur;
4045
4046 time (&runtime_cur);
4047
4048 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4049
4050 if (runtime_left <= 0)
4051 {
4052 if (data.benchmark == 0)
4053 {
4054 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4055 }
4056
4057 if (data.devices_status != STATUS_QUIT) myabort ();
4058 }
4059 }
4060
4061 if (remove_check == 1)
4062 {
4063 remove_left--;
4064
4065 if (remove_left == 0)
4066 {
4067 if (data.digests_saved != data.digests_done)
4068 {
4069 data.digests_saved = data.digests_done;
4070
4071 save_hash ();
4072 }
4073
4074 remove_left = data.remove_timer;
4075 }
4076 }
4077
4078 if (status_check == 1)
4079 {
4080 status_left--;
4081
4082 if (status_left == 0)
4083 {
4084 //hc_thread_mutex_lock (mux_display);
4085
4086 if (data.quiet == 0) clear_prompt ();
4087
4088 if (data.quiet == 0) log_info ("");
4089
4090 status_display ();
4091
4092 if (data.quiet == 0) log_info ("");
4093
4094 //hc_thread_mutex_unlock (mux_display);
4095
4096 status_left = data.status_timer;
4097 }
4098 }
4099 }
4100
4101 #ifdef HAVE_HWMON
4102 myfree (fan_speed_chgd);
4103
4104 myfree (temp_diff_old);
4105 myfree (temp_diff_sum);
4106 #endif
4107
4108 p = NULL;
4109
4110 return (p);
4111 }
4112
4113 static void *thread_outfile_remove (void *p)
4114 {
4115 // some hash-dependent constants
4116 char *outfile_dir = data.outfile_check_directory;
4117 uint dgst_size = data.dgst_size;
4118 uint isSalted = data.isSalted;
4119 uint esalt_size = data.esalt_size;
4120 uint hash_mode = data.hash_mode;
4121
4122 uint outfile_check_timer = data.outfile_check_timer;
4123
4124 char separator = data.separator;
4125
4126 // some hash-dependent functions
4127 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4128 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4129
4130 // buffers
4131 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4132
4133 hash_buf.digest = mymalloc (dgst_size);
4134
4135 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4136
4137 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4138
4139 uint digest_buf[64] = { 0 };
4140
4141 outfile_data_t *out_info = NULL;
4142
4143 char **out_files = NULL;
4144
4145 time_t folder_mtime = 0;
4146
4147 int out_cnt = 0;
4148
4149 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4150
4151 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4152 {
4153 hc_sleep (1);
4154
4155 if (data.devices_status != STATUS_RUNNING) continue;
4156
4157 check_left--;
4158
4159 if (check_left == 0)
4160 {
4161 struct stat outfile_check_stat;
4162
4163 if (stat (outfile_dir, &outfile_check_stat) == 0)
4164 {
4165 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4166
4167 if (is_dir == 1)
4168 {
4169 if (outfile_check_stat.st_mtime > folder_mtime)
4170 {
4171 char **out_files_new = scan_directory (outfile_dir);
4172
4173 int out_cnt_new = count_dictionaries (out_files_new);
4174
4175 outfile_data_t *out_info_new = NULL;
4176
4177 if (out_cnt_new > 0)
4178 {
4179 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4180
4181 for (int i = 0; i < out_cnt_new; i++)
4182 {
4183 out_info_new[i].file_name = out_files_new[i];
4184
4185 // check if there are files that we have seen/checked before (and not changed)
4186
4187 for (int j = 0; j < out_cnt; j++)
4188 {
4189 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4190 {
4191 struct stat outfile_stat;
4192
4193 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4194 {
4195 if (outfile_stat.st_ctime == out_info[j].ctime)
4196 {
4197 out_info_new[i].ctime = out_info[j].ctime;
4198 out_info_new[i].seek = out_info[j].seek;
4199 }
4200 }
4201 }
4202 }
4203 }
4204 }
4205
4206 local_free (out_info);
4207 local_free (out_files);
4208
4209 out_files = out_files_new;
4210 out_cnt = out_cnt_new;
4211 out_info = out_info_new;
4212
4213 folder_mtime = outfile_check_stat.st_mtime;
4214 }
4215
4216 for (int j = 0; j < out_cnt; j++)
4217 {
4218 FILE *fp = fopen (out_info[j].file_name, "rb");
4219
4220 if (fp != NULL)
4221 {
4222 //hc_thread_mutex_lock (mux_display);
4223
4224 #ifdef _POSIX
4225 struct stat outfile_stat;
4226
4227 fstat (fileno (fp), &outfile_stat);
4228 #endif
4229
4230 #ifdef _WIN
4231 struct stat64 outfile_stat;
4232
4233 _fstat64 (fileno (fp), &outfile_stat);
4234 #endif
4235
4236 if (outfile_stat.st_ctime > out_info[j].ctime)
4237 {
4238 out_info[j].ctime = outfile_stat.st_ctime;
4239 out_info[j].seek = 0;
4240 }
4241
4242 fseek (fp, out_info[j].seek, SEEK_SET);
4243
4244 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4245
4246 while (!feof (fp))
4247 {
4248 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4249
4250 if (ptr == NULL) break;
4251
4252 int line_len = strlen (line_buf);
4253
4254 if (line_len <= 0) continue;
4255
4256 int iter = MAX_CUT_TRIES;
4257
4258 for (uint i = line_len - 1; i && iter; i--, line_len--)
4259 {
4260 if (line_buf[i] != separator) continue;
4261
4262 int parser_status = PARSER_OK;
4263
4264 if ((hash_mode != 2500) && (hash_mode != 6800))
4265 {
4266 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4267 }
4268
4269 uint found = 0;
4270
4271 if (parser_status == PARSER_OK)
4272 {
4273 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4274 {
4275 if (data.salts_shown[salt_pos] == 1) continue;
4276
4277 salt_t *salt_buf = &data.salts_buf[salt_pos];
4278
4279 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4280 {
4281 uint idx = salt_buf->digests_offset + digest_pos;
4282
4283 if (data.digests_shown[idx] == 1) continue;
4284
4285 uint cracked = 0;
4286
4287 if (hash_mode == 6800)
4288 {
4289 if (i == salt_buf->salt_len)
4290 {
4291 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4292 }
4293 }
4294 else if (hash_mode == 2500)
4295 {
4296 // BSSID : MAC1 : MAC2 (:plain)
4297 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4298 {
4299 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4300
4301 if (!cracked) continue;
4302
4303 // now compare MAC1 and MAC2 too, since we have this additional info
4304 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4305 char *mac2_pos = mac1_pos + 12 + 1;
4306
4307 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4308 wpa_t *wpa = &wpas[salt_pos];
4309
4310 // compare hex string(s) vs binary MAC address(es)
4311
4312 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4313 {
4314 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4315 {
4316 cracked = 0;
4317
4318 break;
4319 }
4320 }
4321
4322 // early skip ;)
4323 if (!cracked) continue;
4324
4325 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4326 {
4327 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4328 {
4329 cracked = 0;
4330
4331 break;
4332 }
4333 }
4334 }
4335 }
4336 else
4337 {
4338 char *digests_buf_ptr = (char *) data.digests_buf;
4339
4340 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4341
4342 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4343 }
4344
4345 if (cracked == 1)
4346 {
4347 found = 1;
4348
4349 data.digests_shown[idx] = 1;
4350
4351 data.digests_done++;
4352
4353 salt_buf->digests_done++;
4354
4355 if (salt_buf->digests_done == salt_buf->digests_cnt)
4356 {
4357 data.salts_shown[salt_pos] = 1;
4358
4359 data.salts_done++;
4360
4361 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4362 }
4363 }
4364 }
4365
4366 if (data.devices_status == STATUS_CRACKED) break;
4367 }
4368 }
4369
4370 if (found) break;
4371
4372 if (data.devices_status == STATUS_CRACKED) break;
4373
4374 iter--;
4375 }
4376
4377 if (data.devices_status == STATUS_CRACKED) break;
4378 }
4379
4380 myfree (line_buf);
4381
4382 out_info[j].seek = ftell (fp);
4383
4384 //hc_thread_mutex_unlock (mux_display);
4385
4386 fclose (fp);
4387 }
4388 }
4389 }
4390 }
4391
4392 check_left = outfile_check_timer;
4393 }
4394 }
4395
4396 if (esalt_size) local_free (hash_buf.esalt);
4397
4398 if (isSalted) local_free (hash_buf.salt);
4399
4400 local_free (hash_buf.digest);
4401
4402 local_free (out_info);
4403
4404 local_free (out_files);
4405
4406 p = NULL;
4407
4408 return (p);
4409 }
4410
4411 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4412 {
4413 if (device_param->pws_cnt < device_param->kernel_power)
4414 {
4415 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4416
4417 u8 *ptr = (u8 *) pw->i;
4418
4419 memcpy (ptr, pw_buf, pw_len);
4420
4421 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4422
4423 pw->pw_len = pw_len;
4424
4425 device_param->pws_cnt++;
4426 }
4427 else
4428 {
4429 fprintf (stderr, "BUG pw_add()!!\n");
4430
4431 return;
4432 }
4433 }
4434
4435 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4436 {
4437 hc_thread_mutex_lock (mux_dispatcher);
4438
4439 const u64 words_cur = data.words_cur;
4440 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4441
4442 device_param->words_off = words_cur;
4443
4444 const u64 words_left = words_base - words_cur;
4445
4446 if (allow_div)
4447 {
4448 if (data.kernel_power_all > words_left)
4449 {
4450 if (data.kernel_power_div == 0)
4451 {
4452 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4453 }
4454 }
4455
4456 if (data.kernel_power_div)
4457 {
4458 if (device_param->kernel_power == device_param->kernel_power_user)
4459 {
4460 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4461
4462 if (kernel_power_new < device_param->kernel_power)
4463 {
4464 device_param->kernel_power = kernel_power_new;
4465 }
4466 }
4467 }
4468 }
4469
4470 const uint kernel_power = device_param->kernel_power;
4471
4472 uint work = MIN (words_left, kernel_power);
4473
4474 work = MIN (work, max);
4475
4476 data.words_cur += work;
4477
4478 hc_thread_mutex_unlock (mux_dispatcher);
4479
4480 return work;
4481 }
4482
4483 static void *thread_calc_stdin (void *p)
4484 {
4485 hc_device_param_t *device_param = (hc_device_param_t *) p;
4486
4487 if (device_param->skipped) return NULL;
4488
4489 autotune (device_param);
4490
4491 char *buf = (char *) mymalloc (HCBUFSIZ);
4492
4493 const uint attack_kern = data.attack_kern;
4494
4495 const uint kernel_power = device_param->kernel_power;
4496
4497 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4498 {
4499 hc_thread_mutex_lock (mux_dispatcher);
4500
4501 if (feof (stdin) != 0)
4502 {
4503 hc_thread_mutex_unlock (mux_dispatcher);
4504
4505 break;
4506 }
4507
4508 uint words_cur = 0;
4509
4510 while (words_cur < kernel_power)
4511 {
4512 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4513
4514 if (line_buf == NULL) break;
4515
4516 uint line_len = in_superchop (line_buf);
4517
4518 line_len = convert_from_hex (line_buf, line_len);
4519
4520 // post-process rule engine
4521
4522 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4523 {
4524 char rule_buf_out[BLOCK_SIZE] = { 0 };
4525
4526 int rule_len_out = -1;
4527
4528 if (line_len < BLOCK_SIZE)
4529 {
4530 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4531 }
4532
4533 if (rule_len_out < 0) continue;
4534
4535 line_buf = rule_buf_out;
4536 line_len = rule_len_out;
4537 }
4538
4539 if (line_len > PW_MAX)
4540 {
4541 continue;
4542 }
4543
4544 if (attack_kern == ATTACK_KERN_STRAIGHT)
4545 {
4546 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4547 {
4548 hc_thread_mutex_lock (mux_counter);
4549
4550 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4551 {
4552 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4553 }
4554
4555 hc_thread_mutex_unlock (mux_counter);
4556
4557 continue;
4558 }
4559 }
4560 else if (attack_kern == ATTACK_KERN_COMBI)
4561 {
4562 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4563 // since we still need to combine the plains
4564
4565 if (line_len > data.pw_max)
4566 {
4567 hc_thread_mutex_lock (mux_counter);
4568
4569 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4570 {
4571 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4572 }
4573
4574 hc_thread_mutex_unlock (mux_counter);
4575
4576 continue;
4577 }
4578 }
4579
4580 pw_add (device_param, (u8 *) line_buf, line_len);
4581
4582 words_cur++;
4583
4584 if (data.devices_status == STATUS_CRACKED) break;
4585 if (data.devices_status == STATUS_ABORTED) break;
4586 if (data.devices_status == STATUS_QUIT) break;
4587 if (data.devices_status == STATUS_BYPASS) break;
4588 }
4589
4590 hc_thread_mutex_unlock (mux_dispatcher);
4591
4592 if (data.devices_status == STATUS_CRACKED) break;
4593 if (data.devices_status == STATUS_ABORTED) break;
4594 if (data.devices_status == STATUS_QUIT) break;
4595 if (data.devices_status == STATUS_BYPASS) break;
4596
4597 // flush
4598
4599 const uint pws_cnt = device_param->pws_cnt;
4600
4601 if (pws_cnt)
4602 {
4603 run_copy (device_param, pws_cnt);
4604
4605 run_cracker (device_param, pws_cnt);
4606
4607 device_param->pws_cnt = 0;
4608
4609 /*
4610 still required?
4611 if (attack_kern == ATTACK_KERN_STRAIGHT)
4612 {
4613 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4614 }
4615 else if (attack_kern == ATTACK_KERN_COMBI)
4616 {
4617 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4618 }
4619 */
4620 }
4621 }
4622
4623 device_param->kernel_accel = 0;
4624 device_param->kernel_loops = 0;
4625
4626 myfree (buf);
4627
4628 return NULL;
4629 }
4630
4631 static void *thread_calc (void *p)
4632 {
4633 hc_device_param_t *device_param = (hc_device_param_t *) p;
4634
4635 if (device_param->skipped) return NULL;
4636
4637 autotune (device_param);
4638
4639 const uint attack_mode = data.attack_mode;
4640 const uint attack_kern = data.attack_kern;
4641
4642 if (attack_mode == ATTACK_MODE_BF)
4643 {
4644 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4645 {
4646 const uint work = get_work (device_param, -1, true);
4647
4648 if (work == 0) break;
4649
4650 const u64 words_off = device_param->words_off;
4651 const u64 words_fin = words_off + work;
4652
4653 const uint pws_cnt = work;
4654
4655 device_param->pws_cnt = pws_cnt;
4656
4657 if (pws_cnt)
4658 {
4659 run_copy (device_param, pws_cnt);
4660
4661 run_cracker (device_param, pws_cnt);
4662
4663 device_param->pws_cnt = 0;
4664
4665 /*
4666 still required?
4667 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4668 */
4669 }
4670
4671 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4672
4673 if (data.devices_status == STATUS_CRACKED) break;
4674 if (data.devices_status == STATUS_ABORTED) break;
4675 if (data.devices_status == STATUS_QUIT) break;
4676 if (data.devices_status == STATUS_BYPASS) break;
4677
4678 if (data.benchmark == 1) break;
4679
4680 device_param->words_done = words_fin;
4681 }
4682 }
4683 else
4684 {
4685 const uint segment_size = data.segment_size;
4686
4687 char *dictfile = data.dictfile;
4688
4689 if (attack_mode == ATTACK_MODE_COMBI)
4690 {
4691 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4692 {
4693 dictfile = data.dictfile2;
4694 }
4695 }
4696
4697 FILE *fd = fopen (dictfile, "rb");
4698
4699 if (fd == NULL)
4700 {
4701 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4702
4703 return NULL;
4704 }
4705
4706 if (attack_mode == ATTACK_MODE_COMBI)
4707 {
4708 const uint combs_mode = data.combs_mode;
4709
4710 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4711 {
4712 const char *dictfilec = data.dictfile2;
4713
4714 FILE *combs_fp = fopen (dictfilec, "rb");
4715
4716 if (combs_fp == NULL)
4717 {
4718 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4719
4720 fclose (fd);
4721
4722 return NULL;
4723 }
4724
4725 device_param->combs_fp = combs_fp;
4726 }
4727 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4728 {
4729 const char *dictfilec = data.dictfile;
4730
4731 FILE *combs_fp = fopen (dictfilec, "rb");
4732
4733 if (combs_fp == NULL)
4734 {
4735 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4736
4737 fclose (fd);
4738
4739 return NULL;
4740 }
4741
4742 device_param->combs_fp = combs_fp;
4743 }
4744 }
4745
4746 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4747
4748 wl_data->buf = (char *) mymalloc (segment_size);
4749 wl_data->avail = segment_size;
4750 wl_data->incr = segment_size;
4751 wl_data->cnt = 0;
4752 wl_data->pos = 0;
4753
4754 u64 words_cur = 0;
4755
4756 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4757 {
4758 u64 words_off = 0;
4759 u64 words_fin = 0;
4760
4761 bool allow_div = true;
4762
4763 u64 max = -1;
4764
4765 while (max)
4766 {
4767 const uint work = get_work (device_param, max, allow_div);
4768
4769 allow_div = false;
4770
4771 if (work == 0) break;
4772
4773 words_off = device_param->words_off;
4774 words_fin = words_off + work;
4775
4776 char *line_buf;
4777 uint line_len;
4778
4779 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4780
4781 max = 0;
4782
4783 for ( ; words_cur < words_fin; words_cur++)
4784 {
4785 get_next_word (wl_data, fd, &line_buf, &line_len);
4786
4787 line_len = convert_from_hex (line_buf, line_len);
4788
4789 // post-process rule engine
4790
4791 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4792 {
4793 char rule_buf_out[BLOCK_SIZE] = { 0 };
4794
4795 int rule_len_out = -1;
4796
4797 if (line_len < BLOCK_SIZE)
4798 {
4799 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4800 }
4801
4802 if (rule_len_out < 0) continue;
4803
4804 line_buf = rule_buf_out;
4805 line_len = rule_len_out;
4806 }
4807
4808 if (attack_kern == ATTACK_KERN_STRAIGHT)
4809 {
4810 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4811 {
4812 max++;
4813
4814 hc_thread_mutex_lock (mux_counter);
4815
4816 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4817 {
4818 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4819 }
4820
4821 hc_thread_mutex_unlock (mux_counter);
4822
4823 continue;
4824 }
4825 }
4826 else if (attack_kern == ATTACK_KERN_COMBI)
4827 {
4828 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4829 // since we still need to combine the plains
4830
4831 if (line_len > data.pw_max)
4832 {
4833 max++;
4834
4835 hc_thread_mutex_lock (mux_counter);
4836
4837 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4838 {
4839 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4840 }
4841
4842 hc_thread_mutex_unlock (mux_counter);
4843
4844 continue;
4845 }
4846 }
4847
4848 pw_add (device_param, (u8 *) line_buf, line_len);
4849
4850 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4851
4852 if (data.devices_status == STATUS_CRACKED) break;
4853 if (data.devices_status == STATUS_ABORTED) break;
4854 if (data.devices_status == STATUS_QUIT) break;
4855 if (data.devices_status == STATUS_BYPASS) break;
4856 }
4857
4858 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4859
4860 if (data.devices_status == STATUS_CRACKED) break;
4861 if (data.devices_status == STATUS_ABORTED) break;
4862 if (data.devices_status == STATUS_QUIT) break;
4863 if (data.devices_status == STATUS_BYPASS) break;
4864 }
4865
4866 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4867
4868 if (data.devices_status == STATUS_CRACKED) break;
4869 if (data.devices_status == STATUS_ABORTED) break;
4870 if (data.devices_status == STATUS_QUIT) break;
4871 if (data.devices_status == STATUS_BYPASS) break;
4872
4873 //
4874 // flush
4875 //
4876
4877 const uint pws_cnt = device_param->pws_cnt;
4878
4879 if (pws_cnt)
4880 {
4881 run_copy (device_param, pws_cnt);
4882
4883 run_cracker (device_param, pws_cnt);
4884
4885 device_param->pws_cnt = 0;
4886
4887 /*
4888 still required?
4889 if (attack_kern == ATTACK_KERN_STRAIGHT)
4890 {
4891 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4892 }
4893 else if (attack_kern == ATTACK_KERN_COMBI)
4894 {
4895 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4896 }
4897 */
4898 }
4899
4900 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4901
4902 if (data.devices_status == STATUS_CRACKED) break;
4903 if (data.devices_status == STATUS_ABORTED) break;
4904 if (data.devices_status == STATUS_QUIT) break;
4905 if (data.devices_status == STATUS_BYPASS) break;
4906
4907 if (words_fin == 0) break;
4908
4909 device_param->words_done = words_fin;
4910 }
4911
4912 if (attack_mode == ATTACK_MODE_COMBI)
4913 {
4914 fclose (device_param->combs_fp);
4915 }
4916
4917 free (wl_data->buf);
4918 free (wl_data);
4919
4920 fclose (fd);
4921 }
4922
4923 device_param->kernel_accel = 0;
4924 device_param->kernel_loops = 0;
4925
4926 return NULL;
4927 }
4928
4929 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4930 {
4931 if (!device_param)
4932 {
4933 log_error ("ERROR: %s : Invalid argument", __func__);
4934
4935 exit (-1);
4936 }
4937
4938 salt_t *salt_buf = &data.salts_buf[salt_pos];
4939
4940 device_param->kernel_params_buf32[24] = salt_pos;
4941 device_param->kernel_params_buf32[27] = 1;
4942 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4943 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4944 device_param->kernel_params_buf32[30] = 0;
4945 device_param->kernel_params_buf32[31] = 1;
4946
4947 char *dictfile_old = data.dictfile;
4948
4949 const char *weak_hash_check = "weak-hash-check";
4950
4951 data.dictfile = (char *) weak_hash_check;
4952
4953 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4954
4955 data.kernel_rules_buf[0].cmds[0] = 0;
4956
4957 /**
4958 * run the kernel
4959 */
4960
4961 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4962 {
4963 run_kernel (KERN_RUN_1, device_param, 1, false);
4964 }
4965 else
4966 {
4967 run_kernel (KERN_RUN_1, device_param, 1, false);
4968
4969 uint loop_step = 16;
4970
4971 const uint iter = salt_buf->salt_iter;
4972
4973 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4974 {
4975 uint loop_left = iter - loop_pos;
4976
4977 loop_left = MIN (loop_left, loop_step);
4978
4979 device_param->kernel_params_buf32[25] = loop_pos;
4980 device_param->kernel_params_buf32[26] = loop_left;
4981
4982 run_kernel (KERN_RUN_2, device_param, 1, false);
4983 }
4984
4985 run_kernel (KERN_RUN_3, device_param, 1, false);
4986 }
4987
4988 /**
4989 * result
4990 */
4991
4992 check_cracked (device_param, salt_pos);
4993
4994 /**
4995 * cleanup
4996 */
4997
4998 device_param->kernel_params_buf32[24] = 0;
4999 device_param->kernel_params_buf32[25] = 0;
5000 device_param->kernel_params_buf32[26] = 0;
5001 device_param->kernel_params_buf32[27] = 0;
5002 device_param->kernel_params_buf32[28] = 0;
5003 device_param->kernel_params_buf32[29] = 0;
5004 device_param->kernel_params_buf32[30] = 0;
5005 device_param->kernel_params_buf32[31] = 0;
5006
5007 data.dictfile = dictfile_old;
5008
5009 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5010 }
5011
5012 // hlfmt hashcat
5013
5014 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5015 {
5016 if (data.username == 0)
5017 {
5018 *hashbuf_pos = line_buf;
5019 *hashbuf_len = line_len;
5020 }
5021 else
5022 {
5023 char *pos = line_buf;
5024 int len = line_len;
5025
5026 for (int i = 0; i < line_len; i++, pos++, len--)
5027 {
5028 if (line_buf[i] == data.separator)
5029 {
5030 pos++;
5031
5032 len--;
5033
5034 break;
5035 }
5036 }
5037
5038 *hashbuf_pos = pos;
5039 *hashbuf_len = len;
5040 }
5041 }
5042
5043 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5044 {
5045 char *pos = NULL;
5046 int len = 0;
5047
5048 int sep_cnt = 0;
5049
5050 for (int i = 0; i < line_len; i++)
5051 {
5052 if (line_buf[i] == data.separator)
5053 {
5054 sep_cnt++;
5055
5056 continue;
5057 }
5058
5059 if (sep_cnt == 0)
5060 {
5061 if (pos == NULL) pos = line_buf + i;
5062
5063 len++;
5064 }
5065 }
5066
5067 *userbuf_pos = pos;
5068 *userbuf_len = len;
5069 }
5070
5071 // hlfmt pwdump
5072
5073 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5074 {
5075 int sep_cnt = 0;
5076
5077 int sep2_len = 0;
5078 int sep3_len = 0;
5079
5080 for (int i = 0; i < line_len; i++)
5081 {
5082 if (line_buf[i] == ':')
5083 {
5084 sep_cnt++;
5085
5086 continue;
5087 }
5088
5089 if (sep_cnt == 2) sep2_len++;
5090 if (sep_cnt == 3) sep3_len++;
5091 }
5092
5093 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5094
5095 return 0;
5096 }
5097
5098 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5099 {
5100 char *pos = NULL;
5101 int len = 0;
5102
5103 int sep_cnt = 0;
5104
5105 for (int i = 0; i < line_len; i++)
5106 {
5107 if (line_buf[i] == ':')
5108 {
5109 sep_cnt++;
5110
5111 continue;
5112 }
5113
5114 if (data.hash_mode == 1000)
5115 {
5116 if (sep_cnt == 3)
5117 {
5118 if (pos == NULL) pos = line_buf + i;
5119
5120 len++;
5121 }
5122 }
5123 else if (data.hash_mode == 3000)
5124 {
5125 if (sep_cnt == 2)
5126 {
5127 if (pos == NULL) pos = line_buf + i;
5128
5129 len++;
5130 }
5131 }
5132 }
5133
5134 *hashbuf_pos = pos;
5135 *hashbuf_len = len;
5136 }
5137
5138 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5139 {
5140 char *pos = NULL;
5141 int len = 0;
5142
5143 int sep_cnt = 0;
5144
5145 for (int i = 0; i < line_len; i++)
5146 {
5147 if (line_buf[i] == ':')
5148 {
5149 sep_cnt++;
5150
5151 continue;
5152 }
5153
5154 if (sep_cnt == 0)
5155 {
5156 if (pos == NULL) pos = line_buf + i;
5157
5158 len++;
5159 }
5160 }
5161
5162 *userbuf_pos = pos;
5163 *userbuf_len = len;
5164 }
5165
5166 // hlfmt passwd
5167
5168 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5169 {
5170 int sep_cnt = 0;
5171
5172 char sep5_first = 0;
5173 char sep6_first = 0;
5174
5175 for (int i = 0; i < line_len; i++)
5176 {
5177 if (line_buf[i] == ':')
5178 {
5179 sep_cnt++;
5180
5181 continue;
5182 }
5183
5184 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5185 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5186 }
5187
5188 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5189
5190 return 0;
5191 }
5192
5193 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5194 {
5195 char *pos = NULL;
5196 int len = 0;
5197
5198 int sep_cnt = 0;
5199
5200 for (int i = 0; i < line_len; i++)
5201 {
5202 if (line_buf[i] == ':')
5203 {
5204 sep_cnt++;
5205
5206 continue;
5207 }
5208
5209 if (sep_cnt == 1)
5210 {
5211 if (pos == NULL) pos = line_buf + i;
5212
5213 len++;
5214 }
5215 }
5216
5217 *hashbuf_pos = pos;
5218 *hashbuf_len = len;
5219 }
5220
5221 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5222 {
5223 char *pos = NULL;
5224 int len = 0;
5225
5226 int sep_cnt = 0;
5227
5228 for (int i = 0; i < line_len; i++)
5229 {
5230 if (line_buf[i] == ':')
5231 {
5232 sep_cnt++;
5233
5234 continue;
5235 }
5236
5237 if (sep_cnt == 0)
5238 {
5239 if (pos == NULL) pos = line_buf + i;
5240
5241 len++;
5242 }
5243 }
5244
5245 *userbuf_pos = pos;
5246 *userbuf_len = len;
5247 }
5248
5249 // hlfmt shadow
5250
5251 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5252 {
5253 int sep_cnt = 0;
5254
5255 for (int i = 0; i < line_len; i++)
5256 {
5257 if (line_buf[i] == ':') sep_cnt++;
5258 }
5259
5260 if (sep_cnt == 8) return 1;
5261
5262 return 0;
5263 }
5264
5265 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5266 {
5267 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5268 }
5269
5270 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5271 {
5272 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5273 }
5274
5275 // hlfmt main
5276
5277 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5278 {
5279 switch (hashfile_format)
5280 {
5281 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5282 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5283 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5284 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5285 }
5286 }
5287
5288 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5289 {
5290 switch (hashfile_format)
5291 {
5292 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5293 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5294 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5295 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5296 }
5297 }
5298
5299 char *strhlfmt (const uint hashfile_format)
5300 {
5301 switch (hashfile_format)
5302 {
5303 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5304 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5305 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5306 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5307 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5308 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5309 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5310 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5311 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5312 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5313 }
5314
5315 return ((char *) "Unknown");
5316 }
5317
5318 static uint hlfmt_detect (FILE *fp, uint max_check)
5319 {
5320 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5321
5322 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5323 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5324
5325 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5326
5327 uint num_check = 0;
5328
5329 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5330
5331 while (!feof (fp))
5332 {
5333 int line_len = fgetl (fp, line_buf);
5334
5335 if (line_len == 0) continue;
5336
5337 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5338 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5339 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5340
5341 if (num_check == max_check) break;
5342
5343 num_check++;
5344 }
5345
5346 myfree (line_buf);
5347
5348 uint hashlist_format = HLFMT_HASHCAT;
5349
5350 for (int i = 1; i < HLFMTS_CNT; i++)
5351 {
5352 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5353
5354 hashlist_format = i;
5355 }
5356
5357 free (formats_cnt);
5358
5359 return hashlist_format;
5360 }
5361
5362 /**
5363 * some further helper function
5364 */
5365
5366 // wrapper around mymalloc for ADL
5367
5368 #if defined(HAVE_HWMON)
5369 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5370 {
5371 return mymalloc (iSize);
5372 }
5373 #endif
5374
5375 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const u64 collisions_max)
5376 {
5377 u64 collisions = 0;
5378
5379 const uint dgst_pos0 = data.dgst_pos0;
5380 const uint dgst_pos1 = data.dgst_pos1;
5381 const uint dgst_pos2 = data.dgst_pos2;
5382 const uint dgst_pos3 = data.dgst_pos3;
5383
5384 memset (bitmap_a, 0, bitmap_size);
5385 memset (bitmap_b, 0, bitmap_size);
5386 memset (bitmap_c, 0, bitmap_size);
5387 memset (bitmap_d, 0, bitmap_size);
5388
5389 for (uint i = 0; i < digests_cnt; i++)
5390 {
5391 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5392
5393 uint *digest_ptr = (uint *) digests_buf_ptr;
5394
5395 digests_buf_ptr += dgst_size;
5396
5397 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5398 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5399 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5400 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5401
5402 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5403 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5404 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5405 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5406
5407 if (bitmap_a[idx0] & val0) collisions++;
5408 if (bitmap_b[idx1] & val1) collisions++;
5409 if (bitmap_c[idx2] & val2) collisions++;
5410 if (bitmap_d[idx3] & val3) collisions++;
5411
5412 bitmap_a[idx0] |= val0;
5413 bitmap_b[idx1] |= val1;
5414 bitmap_c[idx2] |= val2;
5415 bitmap_d[idx3] |= val3;
5416
5417 if (collisions >= collisions_max) return 0x7fffffff;
5418 }
5419
5420 return collisions;
5421 }
5422
5423 /**
5424 * main
5425 */
5426
5427 #ifdef _WIN
5428 void SetConsoleWindowSize (const int x)
5429 {
5430 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5431
5432 if (h == INVALID_HANDLE_VALUE) return;
5433
5434 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5435
5436 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5437
5438 SMALL_RECT *sr = &bufferInfo.srWindow;
5439
5440 sr->Right = MAX (sr->Right, x - 1);
5441
5442 COORD co;
5443
5444 co.X = sr->Right + 1;
5445 co.Y = sr->Bottom + 1;
5446
5447 if (!SetConsoleScreenBufferSize (h, co)) return;
5448
5449 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5450 }
5451 #endif
5452
5453 int main (int argc, char **argv)
5454 {
5455 #ifdef _WIN
5456 SetConsoleWindowSize (132);
5457 #endif
5458
5459 /**
5460 * To help users a bit
5461 */
5462
5463 char *compute = getenv ("COMPUTE");
5464
5465 if (compute)
5466 {
5467 static char display[100];
5468
5469 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5470
5471 putenv (display);
5472 }
5473 else
5474 {
5475 if (getenv ("DISPLAY") == NULL)
5476 putenv ((char *) "DISPLAY=:0");
5477 }
5478
5479 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5480 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5481
5482 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5483 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5484
5485 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5486 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5487
5488 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5489 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5490
5491 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5492 putenv ((char *) "POCL_KERNEL_CACHE=0");
5493
5494 umask (077);
5495
5496 /**
5497 * Real init
5498 */
5499
5500 memset (&data, 0, sizeof (hc_global_data_t));
5501
5502 time_t proc_start;
5503
5504 time (&proc_start);
5505
5506 data.proc_start = proc_start;
5507
5508 int myargc = argc;
5509 char **myargv = argv;
5510
5511 hc_thread_mutex_init (mux_dispatcher);
5512 hc_thread_mutex_init (mux_counter);
5513 hc_thread_mutex_init (mux_display);
5514 hc_thread_mutex_init (mux_adl);
5515
5516 /**
5517 * commandline parameters
5518 */
5519
5520 uint usage = USAGE;
5521 uint version = VERSION;
5522 uint quiet = QUIET;
5523 uint benchmark = BENCHMARK;
5524 uint show = SHOW;
5525 uint left = LEFT;
5526 uint username = USERNAME;
5527 uint remove = REMOVE;
5528 uint remove_timer = REMOVE_TIMER;
5529 u64 skip = SKIP;
5530 u64 limit = LIMIT;
5531 uint keyspace = KEYSPACE;
5532 uint potfile_disable = POTFILE_DISABLE;
5533 char *potfile_path = NULL;
5534 uint debug_mode = DEBUG_MODE;
5535 char *debug_file = NULL;
5536 char *induction_dir = NULL;
5537 char *outfile_check_dir = NULL;
5538 uint force = FORCE;
5539 uint runtime = RUNTIME;
5540 uint hash_mode = HASH_MODE;
5541 uint attack_mode = ATTACK_MODE;
5542 uint markov_disable = MARKOV_DISABLE;
5543 uint markov_classic = MARKOV_CLASSIC;
5544 uint markov_threshold = MARKOV_THRESHOLD;
5545 char *markov_hcstat = NULL;
5546 char *outfile = NULL;
5547 uint outfile_format = OUTFILE_FORMAT;
5548 uint outfile_autohex = OUTFILE_AUTOHEX;
5549 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5550 uint restore = RESTORE;
5551 uint restore_timer = RESTORE_TIMER;
5552 uint restore_disable = RESTORE_DISABLE;
5553 uint status = STATUS;
5554 uint status_timer = STATUS_TIMER;
5555 uint machine_readable = MACHINE_READABLE;
5556 uint loopback = LOOPBACK;
5557 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5558 char *session = NULL;
5559 uint hex_charset = HEX_CHARSET;
5560 uint hex_salt = HEX_SALT;
5561 uint hex_wordlist = HEX_WORDLIST;
5562 uint rp_gen = RP_GEN;
5563 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5564 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5565 uint rp_gen_seed = RP_GEN_SEED;
5566 char *rule_buf_l = (char *) RULE_BUF_L;
5567 char *rule_buf_r = (char *) RULE_BUF_R;
5568 uint increment = INCREMENT;
5569 uint increment_min = INCREMENT_MIN;
5570 uint increment_max = INCREMENT_MAX;
5571 char *cpu_affinity = NULL;
5572 OCL_PTR *ocl = NULL;
5573 char *opencl_devices = NULL;
5574 char *opencl_platforms = NULL;
5575 char *opencl_device_types = NULL;
5576 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5577 char *truecrypt_keyfiles = NULL;
5578 char *veracrypt_keyfiles = NULL;
5579 uint veracrypt_pim = 0;
5580 uint workload_profile = WORKLOAD_PROFILE;
5581 uint kernel_accel = KERNEL_ACCEL;
5582 uint kernel_loops = KERNEL_LOOPS;
5583 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5584 #ifdef HAVE_HWMON
5585 uint gpu_temp_abort = GPU_TEMP_ABORT;
5586 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5587 uint powertune_enable = POWERTUNE_ENABLE;
5588 #endif
5589 uint logfile_disable = LOGFILE_DISABLE;
5590 uint segment_size = SEGMENT_SIZE;
5591 uint scrypt_tmto = SCRYPT_TMTO;
5592 char separator = SEPARATOR;
5593 uint bitmap_min = BITMAP_MIN;
5594 uint bitmap_max = BITMAP_MAX;
5595 char *custom_charset_1 = NULL;
5596 char *custom_charset_2 = NULL;
5597 char *custom_charset_3 = NULL;
5598 char *custom_charset_4 = NULL;
5599
5600 #define IDX_HELP 'h'
5601 #define IDX_VERSION 'V'
5602 #define IDX_VERSION_LOWER 'v'
5603 #define IDX_QUIET 0xff02
5604 #define IDX_SHOW 0xff03
5605 #define IDX_LEFT 0xff04
5606 #define IDX_REMOVE 0xff05
5607 #define IDX_REMOVE_TIMER 0xff37
5608 #define IDX_SKIP 's'
5609 #define IDX_LIMIT 'l'
5610 #define IDX_KEYSPACE 0xff35
5611 #define IDX_POTFILE_DISABLE 0xff06
5612 #define IDX_POTFILE_PATH 0xffe0
5613 #define IDX_DEBUG_MODE 0xff43
5614 #define IDX_DEBUG_FILE 0xff44
5615 #define IDX_INDUCTION_DIR 0xff46
5616 #define IDX_OUTFILE_CHECK_DIR 0xff47
5617 #define IDX_USERNAME 0xff07
5618 #define IDX_FORCE 0xff08
5619 #define IDX_RUNTIME 0xff09
5620 #define IDX_BENCHMARK 'b'
5621 #define IDX_HASH_MODE 'm'
5622 #define IDX_ATTACK_MODE 'a'
5623 #define IDX_RP_FILE 'r'
5624 #define IDX_RP_GEN 'g'
5625 #define IDX_RP_GEN_FUNC_MIN 0xff10
5626 #define IDX_RP_GEN_FUNC_MAX 0xff11
5627 #define IDX_RP_GEN_SEED 0xff34
5628 #define IDX_RULE_BUF_L 'j'
5629 #define IDX_RULE_BUF_R 'k'
5630 #define IDX_INCREMENT 'i'
5631 #define IDX_INCREMENT_MIN 0xff12
5632 #define IDX_INCREMENT_MAX 0xff13
5633 #define IDX_OUTFILE 'o'
5634 #define IDX_OUTFILE_FORMAT 0xff14
5635 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5636 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5637 #define IDX_RESTORE 0xff15
5638 #define IDX_RESTORE_DISABLE 0xff27
5639 #define IDX_STATUS 0xff17
5640 #define IDX_STATUS_TIMER 0xff18
5641 #define IDX_MACHINE_READABLE 0xff50
5642 #define IDX_LOOPBACK 0xff38
5643 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5644 #define IDX_SESSION 0xff19
5645 #define IDX_HEX_CHARSET 0xff20
5646 #define IDX_HEX_SALT 0xff21
5647 #define IDX_HEX_WORDLIST 0xff40
5648 #define IDX_MARKOV_DISABLE 0xff22
5649 #define IDX_MARKOV_CLASSIC 0xff23
5650 #define IDX_MARKOV_THRESHOLD 't'
5651 #define IDX_MARKOV_HCSTAT 0xff24
5652 #define IDX_CPU_AFFINITY 0xff25
5653 #define IDX_OPENCL_DEVICES 'd'
5654 #define IDX_OPENCL_PLATFORMS 0xff72
5655 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5656 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5657 #define IDX_WORKLOAD_PROFILE 'w'
5658 #define IDX_KERNEL_ACCEL 'n'
5659 #define IDX_KERNEL_LOOPS 'u'
5660 #define IDX_GPU_TEMP_DISABLE 0xff29
5661 #define IDX_GPU_TEMP_ABORT 0xff30
5662 #define IDX_GPU_TEMP_RETAIN 0xff31
5663 #define IDX_POWERTUNE_ENABLE 0xff41
5664 #define IDX_LOGFILE_DISABLE 0xff51
5665 #define IDX_TRUECRYPT_KEYFILES 0xff52
5666 #define IDX_VERACRYPT_KEYFILES 0xff53
5667 #define IDX_VERACRYPT_PIM 0xff54
5668 #define IDX_SCRYPT_TMTO 0xff61
5669 #define IDX_SEGMENT_SIZE 'c'
5670 #define IDX_SEPARATOR 'p'
5671 #define IDX_BITMAP_MIN 0xff70
5672 #define IDX_BITMAP_MAX 0xff71
5673 #define IDX_CUSTOM_CHARSET_1 '1'
5674 #define IDX_CUSTOM_CHARSET_2 '2'
5675 #define IDX_CUSTOM_CHARSET_3 '3'
5676 #define IDX_CUSTOM_CHARSET_4 '4'
5677
5678 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5679
5680 struct option long_options[] =
5681 {
5682 {"help", no_argument, 0, IDX_HELP},
5683 {"version", no_argument, 0, IDX_VERSION},
5684 {"quiet", no_argument, 0, IDX_QUIET},
5685 {"show", no_argument, 0, IDX_SHOW},
5686 {"left", no_argument, 0, IDX_LEFT},
5687 {"username", no_argument, 0, IDX_USERNAME},
5688 {"remove", no_argument, 0, IDX_REMOVE},
5689 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5690 {"skip", required_argument, 0, IDX_SKIP},
5691 {"limit", required_argument, 0, IDX_LIMIT},
5692 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5693 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5694 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5695 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5696 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5697 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5698 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5699 {"force", no_argument, 0, IDX_FORCE},
5700 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5701 {"restore", no_argument, 0, IDX_RESTORE},
5702 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5703 {"status", no_argument, 0, IDX_STATUS},
5704 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5705 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5706 {"loopback", no_argument, 0, IDX_LOOPBACK},
5707 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5708 {"session", required_argument, 0, IDX_SESSION},
5709 {"runtime", required_argument, 0, IDX_RUNTIME},
5710 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5711 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5712 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5713 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5714 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5715 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5716 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5717 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5718 {"rules-file", required_argument, 0, IDX_RP_FILE},
5719 {"outfile", required_argument, 0, IDX_OUTFILE},
5720 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5721 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5722 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5723 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5724 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5725 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5726 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5727 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5728 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5729 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5730 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5731 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5732 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5733 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5734 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5735 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5736 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5737 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5738 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5739 #ifdef HAVE_HWMON
5740 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5741 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5742 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5743 #endif // HAVE_HWMON
5744 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5745 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5746 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5747 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5748 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5749 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5750 {"seperator", required_argument, 0, IDX_SEPARATOR},
5751 {"separator", required_argument, 0, IDX_SEPARATOR},
5752 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5753 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5754 {"increment", no_argument, 0, IDX_INCREMENT},
5755 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5756 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5757 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5758 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5759 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5760 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5761 {0, 0, 0, 0}
5762 };
5763
5764 uint rp_files_cnt = 0;
5765
5766 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5767
5768 int option_index = 0;
5769 int c = -1;
5770
5771 optind = 1;
5772 optopt = 0;
5773
5774 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5775 {
5776 switch (c)
5777 {
5778 case IDX_HELP: usage = 1; break;
5779 case IDX_VERSION:
5780 case IDX_VERSION_LOWER: version = 1; break;
5781 case IDX_RESTORE: restore = 1; break;
5782 case IDX_SESSION: session = optarg; break;
5783 case IDX_SHOW: show = 1; break;
5784 case IDX_LEFT: left = 1; break;
5785 case '?': return (-1);
5786 }
5787 }
5788
5789 if (optopt != 0)
5790 {
5791 log_error ("ERROR: Invalid argument specified");
5792
5793 return (-1);
5794 }
5795
5796 /**
5797 * exit functions
5798 */
5799
5800 if (version)
5801 {
5802 log_info ("%s", VERSION_TAG);
5803
5804 return (0);
5805 }
5806
5807 if (usage)
5808 {
5809 usage_big_print (PROGNAME);
5810
5811 return (0);
5812 }
5813
5814 /**
5815 * session needs to be set, always!
5816 */
5817
5818 if (session == NULL) session = (char *) PROGNAME;
5819
5820 /**
5821 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5822 */
5823
5824 char *exec_path = get_exec_path ();
5825
5826 #ifdef LINUX
5827
5828 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5829 char *resolved_exec_path = realpath (exec_path, NULL);
5830
5831 char *install_dir = get_install_dir (resolved_exec_path);
5832 char *profile_dir = NULL;
5833 char *session_dir = NULL;
5834 char *shared_dir = NULL;
5835
5836 if (strcmp (install_dir, resolved_install_folder) == 0)
5837 {
5838 struct passwd *pw = getpwuid (getuid ());
5839
5840 const char *homedir = pw->pw_dir;
5841
5842 profile_dir = get_profile_dir (homedir);
5843 session_dir = get_session_dir (profile_dir);
5844 shared_dir = strdup (SHARED_FOLDER);
5845
5846 mkdir (profile_dir, 0700);
5847 mkdir (session_dir, 0700);
5848 }
5849 else
5850 {
5851 profile_dir = install_dir;
5852 session_dir = install_dir;
5853 shared_dir = install_dir;
5854 }
5855
5856 myfree (resolved_install_folder);
5857 myfree (resolved_exec_path);
5858
5859 #else
5860
5861 char *install_dir = get_install_dir (exec_path);
5862 char *profile_dir = install_dir;
5863 char *session_dir = install_dir;
5864 char *shared_dir = install_dir;
5865
5866 #endif
5867
5868 data.install_dir = install_dir;
5869 data.profile_dir = profile_dir;
5870 data.session_dir = session_dir;
5871 data.shared_dir = shared_dir;
5872
5873 myfree (exec_path);
5874
5875 /**
5876 * kernel cache, we need to make sure folder exist
5877 */
5878
5879 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5880
5881 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5882
5883 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5884
5885 mkdir (kernels_folder, 0700);
5886
5887 myfree (kernels_folder);
5888
5889 /**
5890 * session
5891 */
5892
5893 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5894
5895 data.session = session;
5896
5897 char *eff_restore_file = (char *) mymalloc (session_size);
5898 char *new_restore_file = (char *) mymalloc (session_size);
5899
5900 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5901 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5902
5903 data.eff_restore_file = eff_restore_file;
5904 data.new_restore_file = new_restore_file;
5905
5906 if (((show == 1) || (left == 1)) && (restore == 1))
5907 {
5908 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5909 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5910
5911 return (-1);
5912 }
5913
5914 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5915 if ((show == 1) || (left == 1))
5916 {
5917 restore_disable = 1;
5918
5919 restore = 0;
5920 }
5921
5922 data.restore_disable = restore_disable;
5923
5924 restore_data_t *rd = init_restore (argc, argv);
5925
5926 data.rd = rd;
5927
5928 /**
5929 * restore file
5930 */
5931
5932 if (restore == 1)
5933 {
5934 read_restore (eff_restore_file, rd);
5935
5936 if (rd->version_bin < RESTORE_MIN)
5937 {
5938 log_error ("ERROR: Incompatible restore-file version");
5939
5940 return (-1);
5941 }
5942
5943 myargc = rd->argc;
5944 myargv = rd->argv;
5945
5946 #ifdef _POSIX
5947 rd->pid = getpid ();
5948 #elif _WIN
5949 rd->pid = GetCurrentProcessId ();
5950 #endif
5951 }
5952
5953 uint hash_mode_chgd = 0;
5954 uint runtime_chgd = 0;
5955 uint kernel_loops_chgd = 0;
5956 uint kernel_accel_chgd = 0;
5957 uint attack_mode_chgd = 0;
5958 uint outfile_format_chgd = 0;
5959 uint rp_gen_seed_chgd = 0;
5960 uint remove_timer_chgd = 0;
5961 uint increment_min_chgd = 0;
5962 uint increment_max_chgd = 0;
5963 uint workload_profile_chgd = 0;
5964 uint opencl_vector_width_chgd = 0;
5965
5966 optind = 1;
5967 optopt = 0;
5968 option_index = 0;
5969
5970 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5971 {
5972 switch (c)
5973 {
5974 //case IDX_HELP: usage = 1; break;
5975 //case IDX_VERSION: version = 1; break;
5976 //case IDX_RESTORE: restore = 1; break;
5977 case IDX_QUIET: quiet = 1; break;
5978 //case IDX_SHOW: show = 1; break;
5979 case IDX_SHOW: break;
5980 //case IDX_LEFT: left = 1; break;
5981 case IDX_LEFT: break;
5982 case IDX_USERNAME: username = 1; break;
5983 case IDX_REMOVE: remove = 1; break;
5984 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5985 remove_timer_chgd = 1; break;
5986 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5987 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5988 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5989 case IDX_DEBUG_FILE: debug_file = optarg; break;
5990 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5991 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5992 case IDX_FORCE: force = 1; break;
5993 case IDX_SKIP: skip = atoll (optarg); break;
5994 case IDX_LIMIT: limit = atoll (optarg); break;
5995 case IDX_KEYSPACE: keyspace = 1; break;
5996 case IDX_BENCHMARK: benchmark = 1; break;
5997 case IDX_RESTORE: break;
5998 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5999 case IDX_STATUS: status = 1; break;
6000 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6001 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6002 case IDX_LOOPBACK: loopback = 1; break;
6003 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6004 //case IDX_SESSION: session = optarg; break;
6005 case IDX_SESSION: break;
6006 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6007 hash_mode_chgd = 1; break;
6008 case IDX_RUNTIME: runtime = atoi (optarg);
6009 runtime_chgd = 1; break;
6010 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6011 attack_mode_chgd = 1; break;
6012 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6013 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6014 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6015 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6016 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6017 rp_gen_seed_chgd = 1; break;
6018 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6019 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6020 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6021 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6022 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6023 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6024 case IDX_OUTFILE: outfile = optarg; break;
6025 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6026 outfile_format_chgd = 1; break;
6027 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6028 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6029 case IDX_HEX_CHARSET: hex_charset = 1; break;
6030 case IDX_HEX_SALT: hex_salt = 1; break;
6031 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6032 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6033 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6034 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6035 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6036 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6037 opencl_vector_width_chgd = 1; break;
6038 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6039 workload_profile_chgd = 1; break;
6040 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6041 kernel_accel_chgd = 1; break;
6042 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6043 kernel_loops_chgd = 1; break;
6044 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6045 #ifdef HAVE_HWMON
6046 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6047 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6048 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6049 #endif // HAVE_HWMON
6050 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6051 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6052 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6053 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6054 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6055 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6056 case IDX_SEPARATOR: separator = optarg[0]; break;
6057 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6058 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6059 case IDX_INCREMENT: increment = 1; break;
6060 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6061 increment_min_chgd = 1; break;
6062 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6063 increment_max_chgd = 1; break;
6064 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6065 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6066 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6067 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6068
6069 default:
6070 log_error ("ERROR: Invalid argument specified");
6071 return (-1);
6072 }
6073 }
6074
6075 if (optopt != 0)
6076 {
6077 log_error ("ERROR: Invalid argument specified");
6078
6079 return (-1);
6080 }
6081
6082 /**
6083 * Inform user things getting started,
6084 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6085 * - we do not need to check algorithm_pos
6086 */
6087
6088 if (quiet == 0)
6089 {
6090 if (benchmark == 1)
6091 {
6092 if (machine_readable == 0)
6093 {
6094 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6095 log_info ("");
6096 }
6097 else
6098 {
6099 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6100 }
6101 }
6102 else if (restore == 1)
6103 {
6104 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6105 log_info ("");
6106 }
6107 else
6108 {
6109 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6110 log_info ("");
6111 }
6112 }
6113
6114 /**
6115 * sanity check
6116 */
6117
6118 if (attack_mode > 7)
6119 {
6120 log_error ("ERROR: Invalid attack-mode specified");
6121
6122 return (-1);
6123 }
6124
6125 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6126 {
6127 log_error ("ERROR: Invalid runtime specified");
6128
6129 return (-1);
6130 }
6131
6132 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
6133 {
6134 log_error ("ERROR: Invalid hash-type specified");
6135
6136 return (-1);
6137 }
6138
6139 // renamed hash modes
6140
6141 if (hash_mode_chgd)
6142 {
6143 int n = -1;
6144
6145 switch (hash_mode)
6146 {
6147 case 123: n = 124;
6148 break;
6149 }
6150
6151 if (n >= 0)
6152 {
6153 log_error ("Old -m specified, use -m %d instead", n);
6154
6155 return (-1);
6156 }
6157 }
6158
6159 if (username == 1)
6160 {
6161 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6162 {
6163 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6164
6165 return (-1);
6166 }
6167 }
6168
6169 if (outfile_format > 16)
6170 {
6171 log_error ("ERROR: Invalid outfile-format specified");
6172
6173 return (-1);
6174 }
6175
6176 if (left == 1)
6177 {
6178 if (outfile_format_chgd == 1)
6179 {
6180 if (outfile_format > 1)
6181 {
6182 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6183
6184 return (-1);
6185 }
6186 }
6187 else
6188 {
6189 outfile_format = OUTFILE_FMT_HASH;
6190 }
6191 }
6192
6193 if (show == 1)
6194 {
6195 if (outfile_format_chgd == 1)
6196 {
6197 if ((outfile_format > 7) && (outfile_format < 16))
6198 {
6199 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6200
6201 return (-1);
6202 }
6203 }
6204 }
6205
6206 if (increment_min < INCREMENT_MIN)
6207 {
6208 log_error ("ERROR: Invalid increment-min specified");
6209
6210 return (-1);
6211 }
6212
6213 if (increment_max > INCREMENT_MAX)
6214 {
6215 log_error ("ERROR: Invalid increment-max specified");
6216
6217 return (-1);
6218 }
6219
6220 if (increment_min > increment_max)
6221 {
6222 log_error ("ERROR: Invalid increment-min specified");
6223
6224 return (-1);
6225 }
6226
6227 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6228 {
6229 log_error ("ERROR: increment is not allowed in attack-mode 0");
6230
6231 return (-1);
6232 }
6233
6234 if ((increment == 0) && (increment_min_chgd == 1))
6235 {
6236 log_error ("ERROR: increment-min is only supported together with increment switch");
6237
6238 return (-1);
6239 }
6240
6241 if ((increment == 0) && (increment_max_chgd == 1))
6242 {
6243 log_error ("ERROR: increment-max is only supported together with increment switch");
6244
6245 return (-1);
6246 }
6247
6248 if (rp_files_cnt && rp_gen)
6249 {
6250 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6251
6252 return (-1);
6253 }
6254
6255 if (rp_files_cnt || rp_gen)
6256 {
6257 if (attack_mode != ATTACK_MODE_STRAIGHT)
6258 {
6259 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6260
6261 return (-1);
6262 }
6263 }
6264
6265 if (rp_gen_func_min > rp_gen_func_max)
6266 {
6267 log_error ("ERROR: Invalid rp-gen-func-min specified");
6268
6269 return (-1);
6270 }
6271
6272 if (kernel_accel_chgd == 1)
6273 {
6274 if (force == 0)
6275 {
6276 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6277 log_info ("Please consider using the option -w instead");
6278 log_info ("You can use --force to override this but do not post error reports if you do so");
6279 log_info ("");
6280
6281 return (-1);
6282 }
6283
6284 if (kernel_accel < 1)
6285 {
6286 log_error ("ERROR: Invalid kernel-accel specified");
6287
6288 return (-1);
6289 }
6290
6291 if (kernel_accel > 1024)
6292 {
6293 log_error ("ERROR: Invalid kernel-accel specified");
6294
6295 return (-1);
6296 }
6297 }
6298
6299 if (kernel_loops_chgd == 1)
6300 {
6301 if (force == 0)
6302 {
6303 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6304 log_info ("Please consider using the option -w instead");
6305 log_info ("You can use --force to override this but do not post error reports if you do so");
6306 log_info ("");
6307
6308 return (-1);
6309 }
6310
6311 if (kernel_loops < 1)
6312 {
6313 log_error ("ERROR: Invalid kernel-loops specified");
6314
6315 return (-1);
6316 }
6317
6318 if (kernel_loops > 1024)
6319 {
6320 log_error ("ERROR: Invalid kernel-loops specified");
6321
6322 return (-1);
6323 }
6324 }
6325
6326 if ((workload_profile < 1) || (workload_profile > 4))
6327 {
6328 log_error ("ERROR: workload-profile %i not available", workload_profile);
6329
6330 return (-1);
6331 }
6332
6333 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6334 {
6335 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6336
6337 return (-1);
6338 }
6339
6340 if (show == 1 || left == 1)
6341 {
6342 attack_mode = ATTACK_MODE_NONE;
6343
6344 if (remove == 1)
6345 {
6346 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6347
6348 return (-1);
6349 }
6350
6351 if (potfile_disable == 1)
6352 {
6353 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6354
6355 return (-1);
6356 }
6357 }
6358
6359 uint attack_kern = ATTACK_KERN_NONE;
6360
6361 switch (attack_mode)
6362 {
6363 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6364 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6365 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6366 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6367 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6368 }
6369
6370 if (benchmark == 0)
6371 {
6372 if (keyspace == 1)
6373 {
6374 int num_additional_params = 1;
6375
6376 if (attack_kern == ATTACK_KERN_COMBI)
6377 {
6378 num_additional_params = 2;
6379 }
6380
6381 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6382
6383 if (keyspace_wordlist_specified == 0) optind--;
6384 }
6385
6386 if (attack_kern == ATTACK_KERN_NONE)
6387 {
6388 if ((optind + 1) != myargc)
6389 {
6390 usage_mini_print (myargv[0]);
6391
6392 return (-1);
6393 }
6394 }
6395 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6396 {
6397 if ((optind + 1) > myargc)
6398 {
6399 usage_mini_print (myargv[0]);
6400
6401 return (-1);
6402 }
6403 }
6404 else if (attack_kern == ATTACK_KERN_COMBI)
6405 {
6406 if ((optind + 3) != myargc)
6407 {
6408 usage_mini_print (myargv[0]);
6409
6410 return (-1);
6411 }
6412 }
6413 else if (attack_kern == ATTACK_KERN_BF)
6414 {
6415 if ((optind + 1) > myargc)
6416 {
6417 usage_mini_print (myargv[0]);
6418
6419 return (-1);
6420 }
6421 }
6422 else
6423 {
6424 usage_mini_print (myargv[0]);
6425
6426 return (-1);
6427 }
6428 }
6429 else
6430 {
6431 if (myargv[optind] != 0)
6432 {
6433 log_error ("ERROR: Invalid argument for benchmark mode specified");
6434
6435 return (-1);
6436 }
6437
6438 if (attack_mode_chgd == 1)
6439 {
6440 if (attack_mode != ATTACK_MODE_BF)
6441 {
6442 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6443
6444 return (-1);
6445 }
6446 }
6447 }
6448
6449 if (skip != 0 && limit != 0)
6450 {
6451 limit += skip;
6452 }
6453
6454 if (keyspace == 1)
6455 {
6456 if (show == 1)
6457 {
6458 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6459
6460 return (-1);
6461 }
6462 else if (left == 1)
6463 {
6464 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6465
6466 return (-1);
6467 }
6468
6469 potfile_disable = 1;
6470
6471 restore_disable = 1;
6472
6473 restore = 0;
6474
6475 weak_hash_threshold = 0;
6476
6477 quiet = 1;
6478 }
6479
6480 if (remove_timer_chgd == 1)
6481 {
6482 if (remove == 0)
6483 {
6484 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6485
6486 return (-1);
6487 }
6488
6489 if (remove_timer < 1)
6490 {
6491 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6492
6493 return (-1);
6494 }
6495 }
6496
6497 if (loopback == 1)
6498 {
6499 if (attack_mode == ATTACK_MODE_STRAIGHT)
6500 {
6501 if ((rp_files_cnt == 0) && (rp_gen == 0))
6502 {
6503 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6504
6505 return (-1);
6506 }
6507 }
6508 else
6509 {
6510 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6511
6512 return (-1);
6513 }
6514 }
6515
6516 if (debug_mode > 0)
6517 {
6518 if (attack_mode != ATTACK_MODE_STRAIGHT)
6519 {
6520 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6521
6522 return (-1);
6523 }
6524
6525 if ((rp_files_cnt == 0) && (rp_gen == 0))
6526 {
6527 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6528
6529 return (-1);
6530 }
6531 }
6532
6533 if (debug_mode > 4)
6534 {
6535 log_error ("ERROR: Invalid debug-mode specified");
6536
6537 return (-1);
6538 }
6539
6540 if (debug_file != NULL)
6541 {
6542 if (debug_mode < 1)
6543 {
6544 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6545
6546 return (-1);
6547 }
6548 }
6549
6550 if (induction_dir != NULL)
6551 {
6552 if (attack_mode == ATTACK_MODE_BF)
6553 {
6554 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6555
6556 return (-1);
6557 }
6558 }
6559
6560 if (attack_mode != ATTACK_MODE_STRAIGHT)
6561 {
6562 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6563 {
6564 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6565
6566 return (-1);
6567 }
6568
6569 weak_hash_threshold = 0;
6570 }
6571
6572 /**
6573 * induction directory
6574 */
6575
6576 char *induction_directory = NULL;
6577
6578 if (attack_mode != ATTACK_MODE_BF)
6579 {
6580 if (induction_dir == NULL)
6581 {
6582 induction_directory = (char *) mymalloc (session_size);
6583
6584 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6585
6586 // create induction folder if it does not already exist
6587
6588 if (keyspace == 0)
6589 {
6590 if (rmdir (induction_directory) == -1)
6591 {
6592 if (errno == ENOENT)
6593 {
6594 // good, we can ignore
6595 }
6596 else if (errno == ENOTEMPTY)
6597 {
6598 char *induction_directory_mv = (char *) mymalloc (session_size);
6599
6600 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6601
6602 if (rename (induction_directory, induction_directory_mv) != 0)
6603 {
6604 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6605
6606 return (-1);
6607 }
6608 }
6609 else
6610 {
6611 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6612
6613 return (-1);
6614 }
6615 }
6616
6617 if (mkdir (induction_directory, 0700) == -1)
6618 {
6619 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6620
6621 return (-1);
6622 }
6623 }
6624 }
6625 else
6626 {
6627 induction_directory = induction_dir;
6628 }
6629 }
6630
6631 data.induction_directory = induction_directory;
6632
6633 /**
6634 * loopback
6635 */
6636
6637 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6638
6639 char *loopback_file = (char *) mymalloc (loopback_size);
6640
6641 /**
6642 * tuning db
6643 */
6644
6645 char tuning_db_file[256] = { 0 };
6646
6647 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6648
6649 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6650
6651 /**
6652 * outfile-check directory
6653 */
6654
6655 char *outfile_check_directory = NULL;
6656
6657 if (outfile_check_dir == NULL)
6658 {
6659 outfile_check_directory = (char *) mymalloc (session_size);
6660
6661 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6662 }
6663 else
6664 {
6665 outfile_check_directory = outfile_check_dir;
6666 }
6667
6668 data.outfile_check_directory = outfile_check_directory;
6669
6670 if (keyspace == 0)
6671 {
6672 struct stat outfile_check_stat;
6673
6674 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6675 {
6676 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6677
6678 if (is_dir == 0)
6679 {
6680 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6681
6682 return (-1);
6683 }
6684 }
6685 else if (outfile_check_dir == NULL)
6686 {
6687 if (mkdir (outfile_check_directory, 0700) == -1)
6688 {
6689 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6690
6691 return (-1);
6692 }
6693 }
6694 }
6695
6696 /**
6697 * special other stuff
6698 */
6699
6700 if (hash_mode == 9710)
6701 {
6702 outfile_format = 5;
6703 outfile_format_chgd = 1;
6704 }
6705
6706 if (hash_mode == 9810)
6707 {
6708 outfile_format = 5;
6709 outfile_format_chgd = 1;
6710 }
6711
6712 if (hash_mode == 10410)
6713 {
6714 outfile_format = 5;
6715 outfile_format_chgd = 1;
6716 }
6717
6718 /**
6719 * store stuff
6720 */
6721
6722 data.hash_mode = hash_mode;
6723 data.restore = restore;
6724 data.restore_timer = restore_timer;
6725 data.restore_disable = restore_disable;
6726 data.status = status;
6727 data.status_timer = status_timer;
6728 data.machine_readable = machine_readable;
6729 data.loopback = loopback;
6730 data.runtime = runtime;
6731 data.remove = remove;
6732 data.remove_timer = remove_timer;
6733 data.debug_mode = debug_mode;
6734 data.debug_file = debug_file;
6735 data.username = username;
6736 data.quiet = quiet;
6737 data.outfile = outfile;
6738 data.outfile_format = outfile_format;
6739 data.outfile_autohex = outfile_autohex;
6740 data.hex_charset = hex_charset;
6741 data.hex_salt = hex_salt;
6742 data.hex_wordlist = hex_wordlist;
6743 data.separator = separator;
6744 data.rp_files = rp_files;
6745 data.rp_files_cnt = rp_files_cnt;
6746 data.rp_gen = rp_gen;
6747 data.rp_gen_seed = rp_gen_seed;
6748 data.force = force;
6749 data.benchmark = benchmark;
6750 data.skip = skip;
6751 data.limit = limit;
6752 #ifdef HAVE_HWMON
6753 data.powertune_enable = powertune_enable;
6754 #endif
6755 data.logfile_disable = logfile_disable;
6756 data.truecrypt_keyfiles = truecrypt_keyfiles;
6757 data.veracrypt_keyfiles = veracrypt_keyfiles;
6758 data.veracrypt_pim = veracrypt_pim;
6759 data.scrypt_tmto = scrypt_tmto;
6760 data.workload_profile = workload_profile;
6761
6762 /**
6763 * cpu affinity
6764 */
6765
6766 if (cpu_affinity)
6767 {
6768 set_cpu_affinity (cpu_affinity);
6769 }
6770
6771 if (rp_gen_seed_chgd == 0)
6772 {
6773 srand (proc_start);
6774 }
6775 else
6776 {
6777 srand (rp_gen_seed);
6778 }
6779
6780 /**
6781 * logfile init
6782 */
6783
6784 if (logfile_disable == 0)
6785 {
6786 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6787
6788 char *logfile = (char *) mymalloc (logfile_size);
6789
6790 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6791
6792 data.logfile = logfile;
6793
6794 char *topid = logfile_generate_topid ();
6795
6796 data.topid = topid;
6797 }
6798
6799 // logfile_append() checks for logfile_disable internally to make it easier from here
6800
6801 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6802 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6803 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6804 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6805 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6806 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6807 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6808 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6809 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6810 #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));
6811
6812 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6813 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6814 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6815 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6816 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6817 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6818 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6819 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6820
6821 logfile_top_msg ("START");
6822
6823 logfile_top_uint (attack_mode);
6824 logfile_top_uint (attack_kern);
6825 logfile_top_uint (benchmark);
6826 logfile_top_uint (bitmap_min);
6827 logfile_top_uint (bitmap_max);
6828 logfile_top_uint (debug_mode);
6829 logfile_top_uint (force);
6830 logfile_top_uint (kernel_accel);
6831 logfile_top_uint (kernel_loops);
6832 logfile_top_uint (gpu_temp_disable);
6833 #ifdef HAVE_HWMON
6834 logfile_top_uint (gpu_temp_abort);
6835 logfile_top_uint (gpu_temp_retain);
6836 #endif
6837 logfile_top_uint (hash_mode);
6838 logfile_top_uint (hex_charset);
6839 logfile_top_uint (hex_salt);
6840 logfile_top_uint (hex_wordlist);
6841 logfile_top_uint (increment);
6842 logfile_top_uint (increment_max);
6843 logfile_top_uint (increment_min);
6844 logfile_top_uint (keyspace);
6845 logfile_top_uint (left);
6846 logfile_top_uint (logfile_disable);
6847 logfile_top_uint (loopback);
6848 logfile_top_uint (markov_classic);
6849 logfile_top_uint (markov_disable);
6850 logfile_top_uint (markov_threshold);
6851 logfile_top_uint (outfile_autohex);
6852 logfile_top_uint (outfile_check_timer);
6853 logfile_top_uint (outfile_format);
6854 logfile_top_uint (potfile_disable);
6855 logfile_top_string (potfile_path);
6856 #if defined(HAVE_HWMON)
6857 logfile_top_uint (powertune_enable);
6858 #endif
6859 logfile_top_uint (scrypt_tmto);
6860 logfile_top_uint (quiet);
6861 logfile_top_uint (remove);
6862 logfile_top_uint (remove_timer);
6863 logfile_top_uint (restore);
6864 logfile_top_uint (restore_disable);
6865 logfile_top_uint (restore_timer);
6866 logfile_top_uint (rp_gen);
6867 logfile_top_uint (rp_gen_func_max);
6868 logfile_top_uint (rp_gen_func_min);
6869 logfile_top_uint (rp_gen_seed);
6870 logfile_top_uint (runtime);
6871 logfile_top_uint (segment_size);
6872 logfile_top_uint (show);
6873 logfile_top_uint (status);
6874 logfile_top_uint (machine_readable);
6875 logfile_top_uint (status_timer);
6876 logfile_top_uint (usage);
6877 logfile_top_uint (username);
6878 logfile_top_uint (version);
6879 logfile_top_uint (weak_hash_threshold);
6880 logfile_top_uint (workload_profile);
6881 logfile_top_uint64 (limit);
6882 logfile_top_uint64 (skip);
6883 logfile_top_char (separator);
6884 logfile_top_string (cpu_affinity);
6885 logfile_top_string (custom_charset_1);
6886 logfile_top_string (custom_charset_2);
6887 logfile_top_string (custom_charset_3);
6888 logfile_top_string (custom_charset_4);
6889 logfile_top_string (debug_file);
6890 logfile_top_string (opencl_devices);
6891 logfile_top_string (opencl_platforms);
6892 logfile_top_string (opencl_device_types);
6893 logfile_top_uint (opencl_vector_width);
6894 logfile_top_string (induction_dir);
6895 logfile_top_string (markov_hcstat);
6896 logfile_top_string (outfile);
6897 logfile_top_string (outfile_check_dir);
6898 logfile_top_string (rule_buf_l);
6899 logfile_top_string (rule_buf_r);
6900 logfile_top_string (session);
6901 logfile_top_string (truecrypt_keyfiles);
6902 logfile_top_string (veracrypt_keyfiles);
6903 logfile_top_uint (veracrypt_pim);
6904
6905 /**
6906 * Init OpenCL library loader
6907 */
6908
6909 if (keyspace == 0)
6910 {
6911 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6912
6913 ocl_init (ocl);
6914
6915 data.ocl = ocl;
6916 }
6917
6918 /**
6919 * OpenCL platform selection
6920 */
6921
6922 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6923
6924 /**
6925 * OpenCL device selection
6926 */
6927
6928 u32 devices_filter = setup_devices_filter (opencl_devices);
6929
6930 /**
6931 * OpenCL device type selection
6932 */
6933
6934 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6935
6936 /**
6937 * benchmark
6938 */
6939
6940 if (benchmark == 1)
6941 {
6942 /**
6943 * disable useless stuff for benchmark
6944 */
6945
6946 status_timer = 0;
6947 restore_timer = 0;
6948 restore_disable = 1;
6949 potfile_disable = 1;
6950 weak_hash_threshold = 0;
6951 gpu_temp_disable = 1;
6952
6953 #ifdef HAVE_HWMON
6954 powertune_enable = 1;
6955 #endif
6956
6957 data.status_timer = status_timer;
6958 data.restore_timer = restore_timer;
6959 data.restore_disable = restore_disable;
6960
6961 /**
6962 * force attack mode to be bruteforce
6963 */
6964
6965 attack_mode = ATTACK_MODE_BF;
6966 attack_kern = ATTACK_KERN_BF;
6967
6968 if (workload_profile_chgd == 0)
6969 {
6970 workload_profile = 3;
6971
6972 data.workload_profile = workload_profile;
6973 }
6974 }
6975
6976 /**
6977 * config
6978 */
6979
6980 uint hash_type = 0;
6981 uint salt_type = 0;
6982 uint attack_exec = 0;
6983 uint opts_type = 0;
6984 uint kern_type = 0;
6985 uint dgst_size = 0;
6986 uint esalt_size = 0;
6987 uint opti_type = 0;
6988 uint dgst_pos0 = -1;
6989 uint dgst_pos1 = -1;
6990 uint dgst_pos2 = -1;
6991 uint dgst_pos3 = -1;
6992
6993 int (*parse_func) (char *, uint, hash_t *);
6994 int (*sort_by_digest) (const void *, const void *);
6995
6996 uint algorithm_pos = 0;
6997 uint algorithm_max = 1;
6998
6999 uint *algorithms = default_benchmark_algorithms;
7000
7001 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7002
7003 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7004 {
7005 /*
7006 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7007 * the following algos are skipped entirely
7008 */
7009
7010 if (algorithm_pos > 0)
7011 {
7012 local_free (rd);
7013
7014 rd = init_restore (argc, argv);
7015
7016 data.rd = rd;
7017 }
7018
7019 /**
7020 * update hash_mode in case of multihash benchmark
7021 */
7022
7023 if (benchmark == 1)
7024 {
7025 if (hash_mode_chgd == 0)
7026 {
7027 hash_mode = algorithms[algorithm_pos];
7028
7029 data.hash_mode = hash_mode;
7030 }
7031
7032 quiet = 1;
7033
7034 data.quiet = quiet;
7035 }
7036
7037 switch (hash_mode)
7038 {
7039 case 0: hash_type = HASH_TYPE_MD5;
7040 salt_type = SALT_TYPE_NONE;
7041 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7042 opts_type = OPTS_TYPE_PT_GENERATE_LE
7043 | OPTS_TYPE_PT_ADD80
7044 | OPTS_TYPE_PT_ADDBITS14;
7045 kern_type = KERN_TYPE_MD5;
7046 dgst_size = DGST_SIZE_4_4;
7047 parse_func = md5_parse_hash;
7048 sort_by_digest = sort_by_digest_4_4;
7049 opti_type = OPTI_TYPE_ZERO_BYTE
7050 | OPTI_TYPE_PRECOMPUTE_INIT
7051 | OPTI_TYPE_PRECOMPUTE_MERKLE
7052 | OPTI_TYPE_MEET_IN_MIDDLE
7053 | OPTI_TYPE_EARLY_SKIP
7054 | OPTI_TYPE_NOT_ITERATED
7055 | OPTI_TYPE_NOT_SALTED
7056 | OPTI_TYPE_RAW_HASH;
7057 dgst_pos0 = 0;
7058 dgst_pos1 = 3;
7059 dgst_pos2 = 2;
7060 dgst_pos3 = 1;
7061 break;
7062
7063 case 10: hash_type = HASH_TYPE_MD5;
7064 salt_type = SALT_TYPE_INTERN;
7065 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7066 opts_type = OPTS_TYPE_PT_GENERATE_LE
7067 | OPTS_TYPE_ST_ADD80
7068 | OPTS_TYPE_ST_ADDBITS14;
7069 kern_type = KERN_TYPE_MD5_PWSLT;
7070 dgst_size = DGST_SIZE_4_4;
7071 parse_func = md5s_parse_hash;
7072 sort_by_digest = sort_by_digest_4_4;
7073 opti_type = OPTI_TYPE_ZERO_BYTE
7074 | OPTI_TYPE_PRECOMPUTE_INIT
7075 | OPTI_TYPE_PRECOMPUTE_MERKLE
7076 | OPTI_TYPE_MEET_IN_MIDDLE
7077 | OPTI_TYPE_EARLY_SKIP
7078 | OPTI_TYPE_NOT_ITERATED
7079 | OPTI_TYPE_APPENDED_SALT
7080 | OPTI_TYPE_RAW_HASH;
7081 dgst_pos0 = 0;
7082 dgst_pos1 = 3;
7083 dgst_pos2 = 2;
7084 dgst_pos3 = 1;
7085 break;
7086
7087 case 11: hash_type = HASH_TYPE_MD5;
7088 salt_type = SALT_TYPE_INTERN;
7089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7090 opts_type = OPTS_TYPE_PT_GENERATE_LE
7091 | OPTS_TYPE_ST_ADD80
7092 | OPTS_TYPE_ST_ADDBITS14;
7093 kern_type = KERN_TYPE_MD5_PWSLT;
7094 dgst_size = DGST_SIZE_4_4;
7095 parse_func = joomla_parse_hash;
7096 sort_by_digest = sort_by_digest_4_4;
7097 opti_type = OPTI_TYPE_ZERO_BYTE
7098 | OPTI_TYPE_PRECOMPUTE_INIT
7099 | OPTI_TYPE_PRECOMPUTE_MERKLE
7100 | OPTI_TYPE_MEET_IN_MIDDLE
7101 | OPTI_TYPE_EARLY_SKIP
7102 | OPTI_TYPE_NOT_ITERATED
7103 | OPTI_TYPE_APPENDED_SALT
7104 | OPTI_TYPE_RAW_HASH;
7105 dgst_pos0 = 0;
7106 dgst_pos1 = 3;
7107 dgst_pos2 = 2;
7108 dgst_pos3 = 1;
7109 break;
7110
7111 case 12: hash_type = HASH_TYPE_MD5;
7112 salt_type = SALT_TYPE_INTERN;
7113 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7114 opts_type = OPTS_TYPE_PT_GENERATE_LE
7115 | OPTS_TYPE_ST_ADD80
7116 | OPTS_TYPE_ST_ADDBITS14;
7117 kern_type = KERN_TYPE_MD5_PWSLT;
7118 dgst_size = DGST_SIZE_4_4;
7119 parse_func = postgresql_parse_hash;
7120 sort_by_digest = sort_by_digest_4_4;
7121 opti_type = OPTI_TYPE_ZERO_BYTE
7122 | OPTI_TYPE_PRECOMPUTE_INIT
7123 | OPTI_TYPE_PRECOMPUTE_MERKLE
7124 | OPTI_TYPE_MEET_IN_MIDDLE
7125 | OPTI_TYPE_EARLY_SKIP
7126 | OPTI_TYPE_NOT_ITERATED
7127 | OPTI_TYPE_APPENDED_SALT
7128 | OPTI_TYPE_RAW_HASH;
7129 dgst_pos0 = 0;
7130 dgst_pos1 = 3;
7131 dgst_pos2 = 2;
7132 dgst_pos3 = 1;
7133 break;
7134
7135 case 20: hash_type = HASH_TYPE_MD5;
7136 salt_type = SALT_TYPE_INTERN;
7137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7138 opts_type = OPTS_TYPE_PT_GENERATE_LE
7139 | OPTS_TYPE_PT_ADD80
7140 | OPTS_TYPE_PT_ADDBITS14;
7141 kern_type = KERN_TYPE_MD5_SLTPW;
7142 dgst_size = DGST_SIZE_4_4;
7143 parse_func = md5s_parse_hash;
7144 sort_by_digest = sort_by_digest_4_4;
7145 opti_type = OPTI_TYPE_ZERO_BYTE
7146 | OPTI_TYPE_PRECOMPUTE_INIT
7147 | OPTI_TYPE_PRECOMPUTE_MERKLE
7148 | OPTI_TYPE_EARLY_SKIP
7149 | OPTI_TYPE_NOT_ITERATED
7150 | OPTI_TYPE_PREPENDED_SALT
7151 | OPTI_TYPE_RAW_HASH;
7152 dgst_pos0 = 0;
7153 dgst_pos1 = 3;
7154 dgst_pos2 = 2;
7155 dgst_pos3 = 1;
7156 break;
7157
7158 case 21: hash_type = HASH_TYPE_MD5;
7159 salt_type = SALT_TYPE_INTERN;
7160 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7161 opts_type = OPTS_TYPE_PT_GENERATE_LE
7162 | OPTS_TYPE_PT_ADD80
7163 | OPTS_TYPE_PT_ADDBITS14;
7164 kern_type = KERN_TYPE_MD5_SLTPW;
7165 dgst_size = DGST_SIZE_4_4;
7166 parse_func = osc_parse_hash;
7167 sort_by_digest = sort_by_digest_4_4;
7168 opti_type = OPTI_TYPE_ZERO_BYTE
7169 | OPTI_TYPE_PRECOMPUTE_INIT
7170 | OPTI_TYPE_PRECOMPUTE_MERKLE
7171 | OPTI_TYPE_EARLY_SKIP
7172 | OPTI_TYPE_NOT_ITERATED
7173 | OPTI_TYPE_PREPENDED_SALT
7174 | OPTI_TYPE_RAW_HASH;
7175 dgst_pos0 = 0;
7176 dgst_pos1 = 3;
7177 dgst_pos2 = 2;
7178 dgst_pos3 = 1;
7179 break;
7180
7181 case 22: hash_type = HASH_TYPE_MD5;
7182 salt_type = SALT_TYPE_EMBEDDED;
7183 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7184 opts_type = OPTS_TYPE_PT_GENERATE_LE
7185 | OPTS_TYPE_PT_ADD80
7186 | OPTS_TYPE_PT_ADDBITS14;
7187 kern_type = KERN_TYPE_MD5_SLTPW;
7188 dgst_size = DGST_SIZE_4_4;
7189 parse_func = netscreen_parse_hash;
7190 sort_by_digest = sort_by_digest_4_4;
7191 opti_type = OPTI_TYPE_ZERO_BYTE
7192 | OPTI_TYPE_PRECOMPUTE_INIT
7193 | OPTI_TYPE_PRECOMPUTE_MERKLE
7194 | OPTI_TYPE_EARLY_SKIP
7195 | OPTI_TYPE_NOT_ITERATED
7196 | OPTI_TYPE_PREPENDED_SALT
7197 | OPTI_TYPE_RAW_HASH;
7198 dgst_pos0 = 0;
7199 dgst_pos1 = 3;
7200 dgst_pos2 = 2;
7201 dgst_pos3 = 1;
7202 break;
7203
7204 case 23: hash_type = HASH_TYPE_MD5;
7205 salt_type = SALT_TYPE_EMBEDDED;
7206 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7207 opts_type = OPTS_TYPE_PT_GENERATE_LE
7208 | OPTS_TYPE_PT_ADD80
7209 | OPTS_TYPE_PT_ADDBITS14;
7210 kern_type = KERN_TYPE_MD5_SLTPW;
7211 dgst_size = DGST_SIZE_4_4;
7212 parse_func = skype_parse_hash;
7213 sort_by_digest = sort_by_digest_4_4;
7214 opti_type = OPTI_TYPE_ZERO_BYTE
7215 | OPTI_TYPE_PRECOMPUTE_INIT
7216 | OPTI_TYPE_PRECOMPUTE_MERKLE
7217 | OPTI_TYPE_EARLY_SKIP
7218 | OPTI_TYPE_NOT_ITERATED
7219 | OPTI_TYPE_PREPENDED_SALT
7220 | OPTI_TYPE_RAW_HASH;
7221 dgst_pos0 = 0;
7222 dgst_pos1 = 3;
7223 dgst_pos2 = 2;
7224 dgst_pos3 = 1;
7225 break;
7226
7227 case 30: hash_type = HASH_TYPE_MD5;
7228 salt_type = SALT_TYPE_INTERN;
7229 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7230 opts_type = OPTS_TYPE_PT_GENERATE_LE
7231 | OPTS_TYPE_PT_UNICODE
7232 | OPTS_TYPE_ST_ADD80
7233 | OPTS_TYPE_ST_ADDBITS14;
7234 kern_type = KERN_TYPE_MD5_PWUSLT;
7235 dgst_size = DGST_SIZE_4_4;
7236 parse_func = md5s_parse_hash;
7237 sort_by_digest = sort_by_digest_4_4;
7238 opti_type = OPTI_TYPE_ZERO_BYTE
7239 | OPTI_TYPE_PRECOMPUTE_INIT
7240 | OPTI_TYPE_PRECOMPUTE_MERKLE
7241 | OPTI_TYPE_MEET_IN_MIDDLE
7242 | OPTI_TYPE_EARLY_SKIP
7243 | OPTI_TYPE_NOT_ITERATED
7244 | OPTI_TYPE_APPENDED_SALT
7245 | OPTI_TYPE_RAW_HASH;
7246 dgst_pos0 = 0;
7247 dgst_pos1 = 3;
7248 dgst_pos2 = 2;
7249 dgst_pos3 = 1;
7250 break;
7251
7252 case 40: hash_type = HASH_TYPE_MD5;
7253 salt_type = SALT_TYPE_INTERN;
7254 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7255 opts_type = OPTS_TYPE_PT_GENERATE_LE
7256 | OPTS_TYPE_PT_ADD80
7257 | OPTS_TYPE_PT_ADDBITS14
7258 | OPTS_TYPE_PT_UNICODE;
7259 kern_type = KERN_TYPE_MD5_SLTPWU;
7260 dgst_size = DGST_SIZE_4_4;
7261 parse_func = md5s_parse_hash;
7262 sort_by_digest = sort_by_digest_4_4;
7263 opti_type = OPTI_TYPE_ZERO_BYTE
7264 | OPTI_TYPE_PRECOMPUTE_INIT
7265 | OPTI_TYPE_PRECOMPUTE_MERKLE
7266 | OPTI_TYPE_EARLY_SKIP
7267 | OPTI_TYPE_NOT_ITERATED
7268 | OPTI_TYPE_PREPENDED_SALT
7269 | OPTI_TYPE_RAW_HASH;
7270 dgst_pos0 = 0;
7271 dgst_pos1 = 3;
7272 dgst_pos2 = 2;
7273 dgst_pos3 = 1;
7274 break;
7275
7276 case 50: hash_type = HASH_TYPE_MD5;
7277 salt_type = SALT_TYPE_INTERN;
7278 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7279 opts_type = OPTS_TYPE_PT_GENERATE_LE
7280 | OPTS_TYPE_ST_ADD80
7281 | OPTS_TYPE_ST_ADDBITS14;
7282 kern_type = KERN_TYPE_HMACMD5_PW;
7283 dgst_size = DGST_SIZE_4_4;
7284 parse_func = hmacmd5_parse_hash;
7285 sort_by_digest = sort_by_digest_4_4;
7286 opti_type = OPTI_TYPE_ZERO_BYTE
7287 | OPTI_TYPE_NOT_ITERATED;
7288 dgst_pos0 = 0;
7289 dgst_pos1 = 3;
7290 dgst_pos2 = 2;
7291 dgst_pos3 = 1;
7292 break;
7293
7294 case 60: hash_type = HASH_TYPE_MD5;
7295 salt_type = SALT_TYPE_INTERN;
7296 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7297 opts_type = OPTS_TYPE_PT_GENERATE_LE
7298 | OPTS_TYPE_PT_ADD80
7299 | OPTS_TYPE_PT_ADDBITS14;
7300 kern_type = KERN_TYPE_HMACMD5_SLT;
7301 dgst_size = DGST_SIZE_4_4;
7302 parse_func = hmacmd5_parse_hash;
7303 sort_by_digest = sort_by_digest_4_4;
7304 opti_type = OPTI_TYPE_ZERO_BYTE
7305 | OPTI_TYPE_NOT_ITERATED;
7306 dgst_pos0 = 0;
7307 dgst_pos1 = 3;
7308 dgst_pos2 = 2;
7309 dgst_pos3 = 1;
7310 break;
7311
7312 case 100: hash_type = HASH_TYPE_SHA1;
7313 salt_type = SALT_TYPE_NONE;
7314 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7315 opts_type = OPTS_TYPE_PT_GENERATE_BE
7316 | OPTS_TYPE_PT_ADD80
7317 | OPTS_TYPE_PT_ADDBITS15;
7318 kern_type = KERN_TYPE_SHA1;
7319 dgst_size = DGST_SIZE_4_5;
7320 parse_func = sha1_parse_hash;
7321 sort_by_digest = sort_by_digest_4_5;
7322 opti_type = OPTI_TYPE_ZERO_BYTE
7323 | OPTI_TYPE_PRECOMPUTE_INIT
7324 | OPTI_TYPE_PRECOMPUTE_MERKLE
7325 | OPTI_TYPE_EARLY_SKIP
7326 | OPTI_TYPE_NOT_ITERATED
7327 | OPTI_TYPE_NOT_SALTED
7328 | OPTI_TYPE_RAW_HASH;
7329 dgst_pos0 = 3;
7330 dgst_pos1 = 4;
7331 dgst_pos2 = 2;
7332 dgst_pos3 = 1;
7333 break;
7334
7335 case 101: hash_type = HASH_TYPE_SHA1;
7336 salt_type = SALT_TYPE_NONE;
7337 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7338 opts_type = OPTS_TYPE_PT_GENERATE_BE
7339 | OPTS_TYPE_PT_ADD80
7340 | OPTS_TYPE_PT_ADDBITS15;
7341 kern_type = KERN_TYPE_SHA1;
7342 dgst_size = DGST_SIZE_4_5;
7343 parse_func = sha1b64_parse_hash;
7344 sort_by_digest = sort_by_digest_4_5;
7345 opti_type = OPTI_TYPE_ZERO_BYTE
7346 | OPTI_TYPE_PRECOMPUTE_INIT
7347 | OPTI_TYPE_PRECOMPUTE_MERKLE
7348 | OPTI_TYPE_EARLY_SKIP
7349 | OPTI_TYPE_NOT_ITERATED
7350 | OPTI_TYPE_NOT_SALTED
7351 | OPTI_TYPE_RAW_HASH;
7352 dgst_pos0 = 3;
7353 dgst_pos1 = 4;
7354 dgst_pos2 = 2;
7355 dgst_pos3 = 1;
7356 break;
7357
7358 case 110: hash_type = HASH_TYPE_SHA1;
7359 salt_type = SALT_TYPE_INTERN;
7360 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7361 opts_type = OPTS_TYPE_PT_GENERATE_BE
7362 | OPTS_TYPE_ST_ADD80
7363 | OPTS_TYPE_ST_ADDBITS15;
7364 kern_type = KERN_TYPE_SHA1_PWSLT;
7365 dgst_size = DGST_SIZE_4_5;
7366 parse_func = sha1s_parse_hash;
7367 sort_by_digest = sort_by_digest_4_5;
7368 opti_type = OPTI_TYPE_ZERO_BYTE
7369 | OPTI_TYPE_PRECOMPUTE_INIT
7370 | OPTI_TYPE_PRECOMPUTE_MERKLE
7371 | OPTI_TYPE_EARLY_SKIP
7372 | OPTI_TYPE_NOT_ITERATED
7373 | OPTI_TYPE_APPENDED_SALT
7374 | OPTI_TYPE_RAW_HASH;
7375 dgst_pos0 = 3;
7376 dgst_pos1 = 4;
7377 dgst_pos2 = 2;
7378 dgst_pos3 = 1;
7379 break;
7380
7381 case 111: hash_type = HASH_TYPE_SHA1;
7382 salt_type = SALT_TYPE_EMBEDDED;
7383 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7384 opts_type = OPTS_TYPE_PT_GENERATE_BE
7385 | OPTS_TYPE_ST_ADD80
7386 | OPTS_TYPE_ST_ADDBITS15;
7387 kern_type = KERN_TYPE_SHA1_PWSLT;
7388 dgst_size = DGST_SIZE_4_5;
7389 parse_func = sha1b64s_parse_hash;
7390 sort_by_digest = sort_by_digest_4_5;
7391 opti_type = OPTI_TYPE_ZERO_BYTE
7392 | OPTI_TYPE_PRECOMPUTE_INIT
7393 | OPTI_TYPE_PRECOMPUTE_MERKLE
7394 | OPTI_TYPE_EARLY_SKIP
7395 | OPTI_TYPE_NOT_ITERATED
7396 | OPTI_TYPE_APPENDED_SALT
7397 | OPTI_TYPE_RAW_HASH;
7398 dgst_pos0 = 3;
7399 dgst_pos1 = 4;
7400 dgst_pos2 = 2;
7401 dgst_pos3 = 1;
7402 break;
7403
7404 case 112: hash_type = HASH_TYPE_SHA1;
7405 salt_type = SALT_TYPE_INTERN;
7406 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7407 opts_type = OPTS_TYPE_PT_GENERATE_BE
7408 | OPTS_TYPE_ST_ADD80
7409 | OPTS_TYPE_ST_ADDBITS15
7410 | OPTS_TYPE_ST_HEX;
7411 kern_type = KERN_TYPE_SHA1_PWSLT;
7412 dgst_size = DGST_SIZE_4_5;
7413 parse_func = oracles_parse_hash;
7414 sort_by_digest = sort_by_digest_4_5;
7415 opti_type = OPTI_TYPE_ZERO_BYTE
7416 | OPTI_TYPE_PRECOMPUTE_INIT
7417 | OPTI_TYPE_PRECOMPUTE_MERKLE
7418 | OPTI_TYPE_EARLY_SKIP
7419 | OPTI_TYPE_NOT_ITERATED
7420 | OPTI_TYPE_APPENDED_SALT
7421 | OPTI_TYPE_RAW_HASH;
7422 dgst_pos0 = 3;
7423 dgst_pos1 = 4;
7424 dgst_pos2 = 2;
7425 dgst_pos3 = 1;
7426 break;
7427
7428 case 120: hash_type = HASH_TYPE_SHA1;
7429 salt_type = SALT_TYPE_INTERN;
7430 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7431 opts_type = OPTS_TYPE_PT_GENERATE_BE
7432 | OPTS_TYPE_PT_ADD80
7433 | OPTS_TYPE_PT_ADDBITS15;
7434 kern_type = KERN_TYPE_SHA1_SLTPW;
7435 dgst_size = DGST_SIZE_4_5;
7436 parse_func = sha1s_parse_hash;
7437 sort_by_digest = sort_by_digest_4_5;
7438 opti_type = OPTI_TYPE_ZERO_BYTE
7439 | OPTI_TYPE_PRECOMPUTE_INIT
7440 | OPTI_TYPE_PRECOMPUTE_MERKLE
7441 | OPTI_TYPE_EARLY_SKIP
7442 | OPTI_TYPE_NOT_ITERATED
7443 | OPTI_TYPE_PREPENDED_SALT
7444 | OPTI_TYPE_RAW_HASH;
7445 dgst_pos0 = 3;
7446 dgst_pos1 = 4;
7447 dgst_pos2 = 2;
7448 dgst_pos3 = 1;
7449 break;
7450
7451 case 121: hash_type = HASH_TYPE_SHA1;
7452 salt_type = SALT_TYPE_INTERN;
7453 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7454 opts_type = OPTS_TYPE_PT_GENERATE_BE
7455 | OPTS_TYPE_PT_ADD80
7456 | OPTS_TYPE_PT_ADDBITS15
7457 | OPTS_TYPE_ST_LOWER;
7458 kern_type = KERN_TYPE_SHA1_SLTPW;
7459 dgst_size = DGST_SIZE_4_5;
7460 parse_func = smf_parse_hash;
7461 sort_by_digest = sort_by_digest_4_5;
7462 opti_type = OPTI_TYPE_ZERO_BYTE
7463 | OPTI_TYPE_PRECOMPUTE_INIT
7464 | OPTI_TYPE_PRECOMPUTE_MERKLE
7465 | OPTI_TYPE_EARLY_SKIP
7466 | OPTI_TYPE_NOT_ITERATED
7467 | OPTI_TYPE_PREPENDED_SALT
7468 | OPTI_TYPE_RAW_HASH;
7469 dgst_pos0 = 3;
7470 dgst_pos1 = 4;
7471 dgst_pos2 = 2;
7472 dgst_pos3 = 1;
7473 break;
7474
7475 case 122: hash_type = HASH_TYPE_SHA1;
7476 salt_type = SALT_TYPE_EMBEDDED;
7477 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7478 opts_type = OPTS_TYPE_PT_GENERATE_BE
7479 | OPTS_TYPE_PT_ADD80
7480 | OPTS_TYPE_PT_ADDBITS15
7481 | OPTS_TYPE_ST_HEX;
7482 kern_type = KERN_TYPE_SHA1_SLTPW;
7483 dgst_size = DGST_SIZE_4_5;
7484 parse_func = osx1_parse_hash;
7485 sort_by_digest = sort_by_digest_4_5;
7486 opti_type = OPTI_TYPE_ZERO_BYTE
7487 | OPTI_TYPE_PRECOMPUTE_INIT
7488 | OPTI_TYPE_PRECOMPUTE_MERKLE
7489 | OPTI_TYPE_EARLY_SKIP
7490 | OPTI_TYPE_NOT_ITERATED
7491 | OPTI_TYPE_PREPENDED_SALT
7492 | OPTI_TYPE_RAW_HASH;
7493 dgst_pos0 = 3;
7494 dgst_pos1 = 4;
7495 dgst_pos2 = 2;
7496 dgst_pos3 = 1;
7497 break;
7498
7499 case 124: hash_type = HASH_TYPE_SHA1;
7500 salt_type = SALT_TYPE_EMBEDDED;
7501 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7502 opts_type = OPTS_TYPE_PT_GENERATE_BE
7503 | OPTS_TYPE_PT_ADD80
7504 | OPTS_TYPE_PT_ADDBITS15;
7505 kern_type = KERN_TYPE_SHA1_SLTPW;
7506 dgst_size = DGST_SIZE_4_5;
7507 parse_func = djangosha1_parse_hash;
7508 sort_by_digest = sort_by_digest_4_5;
7509 opti_type = OPTI_TYPE_ZERO_BYTE
7510 | OPTI_TYPE_PRECOMPUTE_INIT
7511 | OPTI_TYPE_PRECOMPUTE_MERKLE
7512 | OPTI_TYPE_EARLY_SKIP
7513 | OPTI_TYPE_NOT_ITERATED
7514 | OPTI_TYPE_PREPENDED_SALT
7515 | OPTI_TYPE_RAW_HASH;
7516 dgst_pos0 = 3;
7517 dgst_pos1 = 4;
7518 dgst_pos2 = 2;
7519 dgst_pos3 = 1;
7520 break;
7521
7522 case 125: hash_type = HASH_TYPE_SHA1;
7523 salt_type = SALT_TYPE_EMBEDDED;
7524 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7525 opts_type = OPTS_TYPE_PT_GENERATE_BE
7526 | OPTS_TYPE_PT_ADD80
7527 | OPTS_TYPE_PT_ADDBITS15
7528 | OPTS_TYPE_ST_HEX;
7529 kern_type = KERN_TYPE_SHA1_SLTPW;
7530 dgst_size = DGST_SIZE_4_5;
7531 parse_func = arubaos_parse_hash;
7532 sort_by_digest = sort_by_digest_4_5;
7533 opti_type = OPTI_TYPE_ZERO_BYTE
7534 | OPTI_TYPE_PRECOMPUTE_INIT
7535 | OPTI_TYPE_PRECOMPUTE_MERKLE
7536 | OPTI_TYPE_EARLY_SKIP
7537 | OPTI_TYPE_NOT_ITERATED
7538 | OPTI_TYPE_PREPENDED_SALT
7539 | OPTI_TYPE_RAW_HASH;
7540 dgst_pos0 = 3;
7541 dgst_pos1 = 4;
7542 dgst_pos2 = 2;
7543 dgst_pos3 = 1;
7544 break;
7545
7546 case 130: hash_type = HASH_TYPE_SHA1;
7547 salt_type = SALT_TYPE_INTERN;
7548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7549 opts_type = OPTS_TYPE_PT_GENERATE_BE
7550 | OPTS_TYPE_PT_UNICODE
7551 | OPTS_TYPE_ST_ADD80
7552 | OPTS_TYPE_ST_ADDBITS15;
7553 kern_type = KERN_TYPE_SHA1_PWUSLT;
7554 dgst_size = DGST_SIZE_4_5;
7555 parse_func = sha1s_parse_hash;
7556 sort_by_digest = sort_by_digest_4_5;
7557 opti_type = OPTI_TYPE_ZERO_BYTE
7558 | OPTI_TYPE_PRECOMPUTE_INIT
7559 | OPTI_TYPE_PRECOMPUTE_MERKLE
7560 | OPTI_TYPE_EARLY_SKIP
7561 | OPTI_TYPE_NOT_ITERATED
7562 | OPTI_TYPE_APPENDED_SALT
7563 | OPTI_TYPE_RAW_HASH;
7564 dgst_pos0 = 3;
7565 dgst_pos1 = 4;
7566 dgst_pos2 = 2;
7567 dgst_pos3 = 1;
7568 break;
7569
7570 case 131: hash_type = HASH_TYPE_SHA1;
7571 salt_type = SALT_TYPE_EMBEDDED;
7572 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7573 opts_type = OPTS_TYPE_PT_GENERATE_BE
7574 | OPTS_TYPE_PT_UNICODE
7575 | OPTS_TYPE_PT_UPPER
7576 | OPTS_TYPE_ST_ADD80
7577 | OPTS_TYPE_ST_ADDBITS15
7578 | OPTS_TYPE_ST_HEX;
7579 kern_type = KERN_TYPE_SHA1_PWUSLT;
7580 dgst_size = DGST_SIZE_4_5;
7581 parse_func = mssql2000_parse_hash;
7582 sort_by_digest = sort_by_digest_4_5;
7583 opti_type = OPTI_TYPE_ZERO_BYTE
7584 | OPTI_TYPE_PRECOMPUTE_INIT
7585 | OPTI_TYPE_PRECOMPUTE_MERKLE
7586 | OPTI_TYPE_EARLY_SKIP
7587 | OPTI_TYPE_NOT_ITERATED
7588 | OPTI_TYPE_APPENDED_SALT
7589 | OPTI_TYPE_RAW_HASH;
7590 dgst_pos0 = 3;
7591 dgst_pos1 = 4;
7592 dgst_pos2 = 2;
7593 dgst_pos3 = 1;
7594 break;
7595
7596 case 132: hash_type = HASH_TYPE_SHA1;
7597 salt_type = SALT_TYPE_EMBEDDED;
7598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7599 opts_type = OPTS_TYPE_PT_GENERATE_BE
7600 | OPTS_TYPE_PT_UNICODE
7601 | OPTS_TYPE_ST_ADD80
7602 | OPTS_TYPE_ST_ADDBITS15
7603 | OPTS_TYPE_ST_HEX;
7604 kern_type = KERN_TYPE_SHA1_PWUSLT;
7605 dgst_size = DGST_SIZE_4_5;
7606 parse_func = mssql2005_parse_hash;
7607 sort_by_digest = sort_by_digest_4_5;
7608 opti_type = OPTI_TYPE_ZERO_BYTE
7609 | OPTI_TYPE_PRECOMPUTE_INIT
7610 | OPTI_TYPE_PRECOMPUTE_MERKLE
7611 | OPTI_TYPE_EARLY_SKIP
7612 | OPTI_TYPE_NOT_ITERATED
7613 | OPTI_TYPE_APPENDED_SALT
7614 | OPTI_TYPE_RAW_HASH;
7615 dgst_pos0 = 3;
7616 dgst_pos1 = 4;
7617 dgst_pos2 = 2;
7618 dgst_pos3 = 1;
7619 break;
7620
7621 case 133: hash_type = HASH_TYPE_SHA1;
7622 salt_type = SALT_TYPE_EMBEDDED;
7623 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7624 opts_type = OPTS_TYPE_PT_GENERATE_BE
7625 | OPTS_TYPE_PT_UNICODE
7626 | OPTS_TYPE_ST_ADD80
7627 | OPTS_TYPE_ST_ADDBITS15;
7628 kern_type = KERN_TYPE_SHA1_PWUSLT;
7629 dgst_size = DGST_SIZE_4_5;
7630 parse_func = peoplesoft_parse_hash;
7631 sort_by_digest = sort_by_digest_4_5;
7632 opti_type = OPTI_TYPE_ZERO_BYTE
7633 | OPTI_TYPE_PRECOMPUTE_INIT
7634 | OPTI_TYPE_PRECOMPUTE_MERKLE
7635 | OPTI_TYPE_EARLY_SKIP
7636 | OPTI_TYPE_NOT_ITERATED
7637 | OPTI_TYPE_APPENDED_SALT
7638 | OPTI_TYPE_RAW_HASH;
7639 dgst_pos0 = 3;
7640 dgst_pos1 = 4;
7641 dgst_pos2 = 2;
7642 dgst_pos3 = 1;
7643 break;
7644
7645 case 140: hash_type = HASH_TYPE_SHA1;
7646 salt_type = SALT_TYPE_INTERN;
7647 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7648 opts_type = OPTS_TYPE_PT_GENERATE_BE
7649 | OPTS_TYPE_PT_ADD80
7650 | OPTS_TYPE_PT_ADDBITS15
7651 | OPTS_TYPE_PT_UNICODE;
7652 kern_type = KERN_TYPE_SHA1_SLTPWU;
7653 dgst_size = DGST_SIZE_4_5;
7654 parse_func = sha1s_parse_hash;
7655 sort_by_digest = sort_by_digest_4_5;
7656 opti_type = OPTI_TYPE_ZERO_BYTE
7657 | OPTI_TYPE_PRECOMPUTE_INIT
7658 | OPTI_TYPE_PRECOMPUTE_MERKLE
7659 | OPTI_TYPE_EARLY_SKIP
7660 | OPTI_TYPE_NOT_ITERATED
7661 | OPTI_TYPE_PREPENDED_SALT
7662 | OPTI_TYPE_RAW_HASH;
7663 dgst_pos0 = 3;
7664 dgst_pos1 = 4;
7665 dgst_pos2 = 2;
7666 dgst_pos3 = 1;
7667 break;
7668
7669 case 141: hash_type = HASH_TYPE_SHA1;
7670 salt_type = SALT_TYPE_EMBEDDED;
7671 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7672 opts_type = OPTS_TYPE_PT_GENERATE_BE
7673 | OPTS_TYPE_PT_ADD80
7674 | OPTS_TYPE_PT_ADDBITS15
7675 | OPTS_TYPE_PT_UNICODE
7676 | OPTS_TYPE_ST_BASE64;
7677 kern_type = KERN_TYPE_SHA1_SLTPWU;
7678 dgst_size = DGST_SIZE_4_5;
7679 parse_func = episerver_parse_hash;
7680 sort_by_digest = sort_by_digest_4_5;
7681 opti_type = OPTI_TYPE_ZERO_BYTE
7682 | OPTI_TYPE_PRECOMPUTE_INIT
7683 | OPTI_TYPE_PRECOMPUTE_MERKLE
7684 | OPTI_TYPE_EARLY_SKIP
7685 | OPTI_TYPE_NOT_ITERATED
7686 | OPTI_TYPE_PREPENDED_SALT
7687 | OPTI_TYPE_RAW_HASH;
7688 dgst_pos0 = 3;
7689 dgst_pos1 = 4;
7690 dgst_pos2 = 2;
7691 dgst_pos3 = 1;
7692 break;
7693
7694 case 150: hash_type = HASH_TYPE_SHA1;
7695 salt_type = SALT_TYPE_INTERN;
7696 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7697 opts_type = OPTS_TYPE_PT_GENERATE_BE
7698 | OPTS_TYPE_ST_ADD80
7699 | OPTS_TYPE_ST_ADDBITS15;
7700 kern_type = KERN_TYPE_HMACSHA1_PW;
7701 dgst_size = DGST_SIZE_4_5;
7702 parse_func = hmacsha1_parse_hash;
7703 sort_by_digest = sort_by_digest_4_5;
7704 opti_type = OPTI_TYPE_ZERO_BYTE
7705 | OPTI_TYPE_NOT_ITERATED;
7706 dgst_pos0 = 3;
7707 dgst_pos1 = 4;
7708 dgst_pos2 = 2;
7709 dgst_pos3 = 1;
7710 break;
7711
7712 case 160: hash_type = HASH_TYPE_SHA1;
7713 salt_type = SALT_TYPE_INTERN;
7714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7715 opts_type = OPTS_TYPE_PT_GENERATE_BE
7716 | OPTS_TYPE_PT_ADD80
7717 | OPTS_TYPE_PT_ADDBITS15;
7718 kern_type = KERN_TYPE_HMACSHA1_SLT;
7719 dgst_size = DGST_SIZE_4_5;
7720 parse_func = hmacsha1_parse_hash;
7721 sort_by_digest = sort_by_digest_4_5;
7722 opti_type = OPTI_TYPE_ZERO_BYTE
7723 | OPTI_TYPE_NOT_ITERATED;
7724 dgst_pos0 = 3;
7725 dgst_pos1 = 4;
7726 dgst_pos2 = 2;
7727 dgst_pos3 = 1;
7728 break;
7729
7730 case 190: hash_type = HASH_TYPE_SHA1;
7731 salt_type = SALT_TYPE_NONE;
7732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7733 opts_type = OPTS_TYPE_PT_GENERATE_BE
7734 | OPTS_TYPE_PT_ADD80
7735 | OPTS_TYPE_PT_ADDBITS15;
7736 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7737 dgst_size = DGST_SIZE_4_5;
7738 parse_func = sha1linkedin_parse_hash;
7739 sort_by_digest = sort_by_digest_4_5;
7740 opti_type = OPTI_TYPE_ZERO_BYTE
7741 | OPTI_TYPE_PRECOMPUTE_INIT
7742 | OPTI_TYPE_EARLY_SKIP
7743 | OPTI_TYPE_NOT_ITERATED
7744 | OPTI_TYPE_NOT_SALTED;
7745 dgst_pos0 = 0;
7746 dgst_pos1 = 4;
7747 dgst_pos2 = 3;
7748 dgst_pos3 = 2;
7749 break;
7750
7751 case 200: hash_type = HASH_TYPE_MYSQL;
7752 salt_type = SALT_TYPE_NONE;
7753 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7754 opts_type = 0;
7755 kern_type = KERN_TYPE_MYSQL;
7756 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7757 parse_func = mysql323_parse_hash;
7758 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7759 opti_type = OPTI_TYPE_ZERO_BYTE;
7760 dgst_pos0 = 0;
7761 dgst_pos1 = 1;
7762 dgst_pos2 = 2;
7763 dgst_pos3 = 3;
7764 break;
7765
7766 case 300: hash_type = HASH_TYPE_SHA1;
7767 salt_type = SALT_TYPE_NONE;
7768 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7769 opts_type = OPTS_TYPE_PT_GENERATE_BE
7770 | OPTS_TYPE_PT_ADD80
7771 | OPTS_TYPE_PT_ADDBITS15;
7772 kern_type = KERN_TYPE_MYSQL41;
7773 dgst_size = DGST_SIZE_4_5;
7774 parse_func = sha1_parse_hash;
7775 sort_by_digest = sort_by_digest_4_5;
7776 opti_type = OPTI_TYPE_ZERO_BYTE
7777 | OPTI_TYPE_PRECOMPUTE_INIT
7778 | OPTI_TYPE_PRECOMPUTE_MERKLE
7779 | OPTI_TYPE_EARLY_SKIP
7780 | OPTI_TYPE_NOT_ITERATED
7781 | OPTI_TYPE_NOT_SALTED;
7782 dgst_pos0 = 3;
7783 dgst_pos1 = 4;
7784 dgst_pos2 = 2;
7785 dgst_pos3 = 1;
7786 break;
7787
7788 case 400: hash_type = HASH_TYPE_MD5;
7789 salt_type = SALT_TYPE_EMBEDDED;
7790 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7791 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7792 kern_type = KERN_TYPE_PHPASS;
7793 dgst_size = DGST_SIZE_4_4;
7794 parse_func = phpass_parse_hash;
7795 sort_by_digest = sort_by_digest_4_4;
7796 opti_type = OPTI_TYPE_ZERO_BYTE
7797 | OPTI_TYPE_SLOW_HASH_SIMD;
7798 dgst_pos0 = 0;
7799 dgst_pos1 = 1;
7800 dgst_pos2 = 2;
7801 dgst_pos3 = 3;
7802 break;
7803
7804 case 500: hash_type = HASH_TYPE_MD5;
7805 salt_type = SALT_TYPE_EMBEDDED;
7806 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7807 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7808 kern_type = KERN_TYPE_MD5CRYPT;
7809 dgst_size = DGST_SIZE_4_4;
7810 parse_func = md5crypt_parse_hash;
7811 sort_by_digest = sort_by_digest_4_4;
7812 opti_type = OPTI_TYPE_ZERO_BYTE;
7813 dgst_pos0 = 0;
7814 dgst_pos1 = 1;
7815 dgst_pos2 = 2;
7816 dgst_pos3 = 3;
7817 break;
7818
7819 case 501: hash_type = HASH_TYPE_MD5;
7820 salt_type = SALT_TYPE_EMBEDDED;
7821 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7822 opts_type = OPTS_TYPE_PT_GENERATE_LE
7823 | OPTS_TYPE_HASH_COPY;
7824 kern_type = KERN_TYPE_MD5CRYPT;
7825 dgst_size = DGST_SIZE_4_4;
7826 parse_func = juniper_parse_hash;
7827 sort_by_digest = sort_by_digest_4_4;
7828 opti_type = OPTI_TYPE_ZERO_BYTE;
7829 dgst_pos0 = 0;
7830 dgst_pos1 = 1;
7831 dgst_pos2 = 2;
7832 dgst_pos3 = 3;
7833 break;
7834
7835 case 900: hash_type = HASH_TYPE_MD4;
7836 salt_type = SALT_TYPE_NONE;
7837 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7838 opts_type = OPTS_TYPE_PT_GENERATE_LE
7839 | OPTS_TYPE_PT_ADD80
7840 | OPTS_TYPE_PT_ADDBITS14;
7841 kern_type = KERN_TYPE_MD4;
7842 dgst_size = DGST_SIZE_4_4;
7843 parse_func = md4_parse_hash;
7844 sort_by_digest = sort_by_digest_4_4;
7845 opti_type = OPTI_TYPE_ZERO_BYTE
7846 | OPTI_TYPE_PRECOMPUTE_INIT
7847 | OPTI_TYPE_PRECOMPUTE_MERKLE
7848 | OPTI_TYPE_MEET_IN_MIDDLE
7849 | OPTI_TYPE_EARLY_SKIP
7850 | OPTI_TYPE_NOT_ITERATED
7851 | OPTI_TYPE_NOT_SALTED
7852 | OPTI_TYPE_RAW_HASH;
7853 dgst_pos0 = 0;
7854 dgst_pos1 = 3;
7855 dgst_pos2 = 2;
7856 dgst_pos3 = 1;
7857 break;
7858
7859 case 1000: hash_type = HASH_TYPE_MD4;
7860 salt_type = SALT_TYPE_NONE;
7861 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7862 opts_type = OPTS_TYPE_PT_GENERATE_LE
7863 | OPTS_TYPE_PT_ADD80
7864 | OPTS_TYPE_PT_ADDBITS14
7865 | OPTS_TYPE_PT_UNICODE;
7866 kern_type = KERN_TYPE_MD4_PWU;
7867 dgst_size = DGST_SIZE_4_4;
7868 parse_func = md4_parse_hash;
7869 sort_by_digest = sort_by_digest_4_4;
7870 opti_type = OPTI_TYPE_ZERO_BYTE
7871 | OPTI_TYPE_PRECOMPUTE_INIT
7872 | OPTI_TYPE_PRECOMPUTE_MERKLE
7873 | OPTI_TYPE_MEET_IN_MIDDLE
7874 | OPTI_TYPE_EARLY_SKIP
7875 | OPTI_TYPE_NOT_ITERATED
7876 | OPTI_TYPE_NOT_SALTED
7877 | OPTI_TYPE_RAW_HASH;
7878 dgst_pos0 = 0;
7879 dgst_pos1 = 3;
7880 dgst_pos2 = 2;
7881 dgst_pos3 = 1;
7882 break;
7883
7884 case 1100: hash_type = HASH_TYPE_MD4;
7885 salt_type = SALT_TYPE_INTERN;
7886 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7887 opts_type = OPTS_TYPE_PT_GENERATE_LE
7888 | OPTS_TYPE_PT_ADD80
7889 | OPTS_TYPE_PT_ADDBITS14
7890 | OPTS_TYPE_PT_UNICODE
7891 | OPTS_TYPE_ST_ADD80
7892 | OPTS_TYPE_ST_UNICODE
7893 | OPTS_TYPE_ST_LOWER;
7894 kern_type = KERN_TYPE_MD44_PWUSLT;
7895 dgst_size = DGST_SIZE_4_4;
7896 parse_func = dcc_parse_hash;
7897 sort_by_digest = sort_by_digest_4_4;
7898 opti_type = OPTI_TYPE_ZERO_BYTE
7899 | OPTI_TYPE_PRECOMPUTE_INIT
7900 | OPTI_TYPE_PRECOMPUTE_MERKLE
7901 | OPTI_TYPE_EARLY_SKIP
7902 | OPTI_TYPE_NOT_ITERATED;
7903 dgst_pos0 = 0;
7904 dgst_pos1 = 3;
7905 dgst_pos2 = 2;
7906 dgst_pos3 = 1;
7907 break;
7908
7909 case 1400: hash_type = HASH_TYPE_SHA256;
7910 salt_type = SALT_TYPE_NONE;
7911 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7912 opts_type = OPTS_TYPE_PT_GENERATE_BE
7913 | OPTS_TYPE_PT_ADD80
7914 | OPTS_TYPE_PT_ADDBITS15;
7915 kern_type = KERN_TYPE_SHA256;
7916 dgst_size = DGST_SIZE_4_8;
7917 parse_func = sha256_parse_hash;
7918 sort_by_digest = sort_by_digest_4_8;
7919 opti_type = OPTI_TYPE_ZERO_BYTE
7920 | OPTI_TYPE_PRECOMPUTE_INIT
7921 | OPTI_TYPE_PRECOMPUTE_MERKLE
7922 | OPTI_TYPE_EARLY_SKIP
7923 | OPTI_TYPE_NOT_ITERATED
7924 | OPTI_TYPE_NOT_SALTED
7925 | OPTI_TYPE_RAW_HASH;
7926 dgst_pos0 = 3;
7927 dgst_pos1 = 7;
7928 dgst_pos2 = 2;
7929 dgst_pos3 = 6;
7930 break;
7931
7932 case 1410: hash_type = HASH_TYPE_SHA256;
7933 salt_type = SALT_TYPE_INTERN;
7934 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7935 opts_type = OPTS_TYPE_PT_GENERATE_BE
7936 | OPTS_TYPE_ST_ADD80
7937 | OPTS_TYPE_ST_ADDBITS15;
7938 kern_type = KERN_TYPE_SHA256_PWSLT;
7939 dgst_size = DGST_SIZE_4_8;
7940 parse_func = sha256s_parse_hash;
7941 sort_by_digest = sort_by_digest_4_8;
7942 opti_type = OPTI_TYPE_ZERO_BYTE
7943 | OPTI_TYPE_PRECOMPUTE_INIT
7944 | OPTI_TYPE_PRECOMPUTE_MERKLE
7945 | OPTI_TYPE_EARLY_SKIP
7946 | OPTI_TYPE_NOT_ITERATED
7947 | OPTI_TYPE_APPENDED_SALT
7948 | OPTI_TYPE_RAW_HASH;
7949 dgst_pos0 = 3;
7950 dgst_pos1 = 7;
7951 dgst_pos2 = 2;
7952 dgst_pos3 = 6;
7953 break;
7954
7955 case 1420: hash_type = HASH_TYPE_SHA256;
7956 salt_type = SALT_TYPE_INTERN;
7957 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7958 opts_type = OPTS_TYPE_PT_GENERATE_BE
7959 | OPTS_TYPE_PT_ADD80
7960 | OPTS_TYPE_PT_ADDBITS15;
7961 kern_type = KERN_TYPE_SHA256_SLTPW;
7962 dgst_size = DGST_SIZE_4_8;
7963 parse_func = sha256s_parse_hash;
7964 sort_by_digest = sort_by_digest_4_8;
7965 opti_type = OPTI_TYPE_ZERO_BYTE
7966 | OPTI_TYPE_PRECOMPUTE_INIT
7967 | OPTI_TYPE_PRECOMPUTE_MERKLE
7968 | OPTI_TYPE_EARLY_SKIP
7969 | OPTI_TYPE_NOT_ITERATED
7970 | OPTI_TYPE_PREPENDED_SALT
7971 | OPTI_TYPE_RAW_HASH;
7972 dgst_pos0 = 3;
7973 dgst_pos1 = 7;
7974 dgst_pos2 = 2;
7975 dgst_pos3 = 6;
7976 break;
7977
7978 case 1421: hash_type = HASH_TYPE_SHA256;
7979 salt_type = SALT_TYPE_EMBEDDED;
7980 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7981 opts_type = OPTS_TYPE_PT_GENERATE_BE
7982 | OPTS_TYPE_PT_ADD80
7983 | OPTS_TYPE_PT_ADDBITS15;
7984 kern_type = KERN_TYPE_SHA256_SLTPW;
7985 dgst_size = DGST_SIZE_4_8;
7986 parse_func = hmailserver_parse_hash;
7987 sort_by_digest = sort_by_digest_4_8;
7988 opti_type = OPTI_TYPE_ZERO_BYTE
7989 | OPTI_TYPE_PRECOMPUTE_INIT
7990 | OPTI_TYPE_PRECOMPUTE_MERKLE
7991 | OPTI_TYPE_EARLY_SKIP
7992 | OPTI_TYPE_NOT_ITERATED
7993 | OPTI_TYPE_PREPENDED_SALT
7994 | OPTI_TYPE_RAW_HASH;
7995 dgst_pos0 = 3;
7996 dgst_pos1 = 7;
7997 dgst_pos2 = 2;
7998 dgst_pos3 = 6;
7999 break;
8000
8001 case 1430: hash_type = HASH_TYPE_SHA256;
8002 salt_type = SALT_TYPE_INTERN;
8003 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8004 opts_type = OPTS_TYPE_PT_GENERATE_BE
8005 | OPTS_TYPE_PT_UNICODE
8006 | OPTS_TYPE_ST_ADD80
8007 | OPTS_TYPE_ST_ADDBITS15;
8008 kern_type = KERN_TYPE_SHA256_PWUSLT;
8009 dgst_size = DGST_SIZE_4_8;
8010 parse_func = sha256s_parse_hash;
8011 sort_by_digest = sort_by_digest_4_8;
8012 opti_type = OPTI_TYPE_ZERO_BYTE
8013 | OPTI_TYPE_PRECOMPUTE_INIT
8014 | OPTI_TYPE_PRECOMPUTE_MERKLE
8015 | OPTI_TYPE_EARLY_SKIP
8016 | OPTI_TYPE_NOT_ITERATED
8017 | OPTI_TYPE_APPENDED_SALT
8018 | OPTI_TYPE_RAW_HASH;
8019 dgst_pos0 = 3;
8020 dgst_pos1 = 7;
8021 dgst_pos2 = 2;
8022 dgst_pos3 = 6;
8023 break;
8024
8025 case 1440: hash_type = HASH_TYPE_SHA256;
8026 salt_type = SALT_TYPE_INTERN;
8027 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8028 opts_type = OPTS_TYPE_PT_GENERATE_BE
8029 | OPTS_TYPE_PT_ADD80
8030 | OPTS_TYPE_PT_ADDBITS15
8031 | OPTS_TYPE_PT_UNICODE;
8032 kern_type = KERN_TYPE_SHA256_SLTPWU;
8033 dgst_size = DGST_SIZE_4_8;
8034 parse_func = sha256s_parse_hash;
8035 sort_by_digest = sort_by_digest_4_8;
8036 opti_type = OPTI_TYPE_ZERO_BYTE
8037 | OPTI_TYPE_PRECOMPUTE_INIT
8038 | OPTI_TYPE_PRECOMPUTE_MERKLE
8039 | OPTI_TYPE_EARLY_SKIP
8040 | OPTI_TYPE_NOT_ITERATED
8041 | OPTI_TYPE_PREPENDED_SALT
8042 | OPTI_TYPE_RAW_HASH;
8043 dgst_pos0 = 3;
8044 dgst_pos1 = 7;
8045 dgst_pos2 = 2;
8046 dgst_pos3 = 6;
8047 break;
8048
8049 case 1441: hash_type = HASH_TYPE_SHA256;
8050 salt_type = SALT_TYPE_EMBEDDED;
8051 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8052 opts_type = OPTS_TYPE_PT_GENERATE_BE
8053 | OPTS_TYPE_PT_ADD80
8054 | OPTS_TYPE_PT_ADDBITS15
8055 | OPTS_TYPE_PT_UNICODE
8056 | OPTS_TYPE_ST_BASE64;
8057 kern_type = KERN_TYPE_SHA256_SLTPWU;
8058 dgst_size = DGST_SIZE_4_8;
8059 parse_func = episerver4_parse_hash;
8060 sort_by_digest = sort_by_digest_4_8;
8061 opti_type = OPTI_TYPE_ZERO_BYTE
8062 | OPTI_TYPE_PRECOMPUTE_INIT
8063 | OPTI_TYPE_PRECOMPUTE_MERKLE
8064 | OPTI_TYPE_EARLY_SKIP
8065 | OPTI_TYPE_NOT_ITERATED
8066 | OPTI_TYPE_PREPENDED_SALT
8067 | OPTI_TYPE_RAW_HASH;
8068 dgst_pos0 = 3;
8069 dgst_pos1 = 7;
8070 dgst_pos2 = 2;
8071 dgst_pos3 = 6;
8072 break;
8073
8074 case 1450: hash_type = HASH_TYPE_SHA256;
8075 salt_type = SALT_TYPE_INTERN;
8076 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8077 opts_type = OPTS_TYPE_PT_GENERATE_BE
8078 | OPTS_TYPE_ST_ADD80;
8079 kern_type = KERN_TYPE_HMACSHA256_PW;
8080 dgst_size = DGST_SIZE_4_8;
8081 parse_func = hmacsha256_parse_hash;
8082 sort_by_digest = sort_by_digest_4_8;
8083 opti_type = OPTI_TYPE_ZERO_BYTE
8084 | OPTI_TYPE_NOT_ITERATED;
8085 dgst_pos0 = 3;
8086 dgst_pos1 = 7;
8087 dgst_pos2 = 2;
8088 dgst_pos3 = 6;
8089 break;
8090
8091 case 1460: hash_type = HASH_TYPE_SHA256;
8092 salt_type = SALT_TYPE_INTERN;
8093 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8094 opts_type = OPTS_TYPE_PT_GENERATE_BE
8095 | OPTS_TYPE_PT_ADD80
8096 | OPTS_TYPE_PT_ADDBITS15;
8097 kern_type = KERN_TYPE_HMACSHA256_SLT;
8098 dgst_size = DGST_SIZE_4_8;
8099 parse_func = hmacsha256_parse_hash;
8100 sort_by_digest = sort_by_digest_4_8;
8101 opti_type = OPTI_TYPE_ZERO_BYTE
8102 | OPTI_TYPE_NOT_ITERATED;
8103 dgst_pos0 = 3;
8104 dgst_pos1 = 7;
8105 dgst_pos2 = 2;
8106 dgst_pos3 = 6;
8107 break;
8108
8109 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8110 salt_type = SALT_TYPE_EMBEDDED;
8111 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8112 opts_type = OPTS_TYPE_PT_GENERATE_LE
8113 | OPTS_TYPE_PT_BITSLICE;
8114 kern_type = KERN_TYPE_DESCRYPT;
8115 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8116 parse_func = descrypt_parse_hash;
8117 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8118 opti_type = OPTI_TYPE_ZERO_BYTE
8119 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8120 dgst_pos0 = 0;
8121 dgst_pos1 = 1;
8122 dgst_pos2 = 2;
8123 dgst_pos3 = 3;
8124 break;
8125
8126 case 1600: hash_type = HASH_TYPE_MD5;
8127 salt_type = SALT_TYPE_EMBEDDED;
8128 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8129 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8130 kern_type = KERN_TYPE_APR1CRYPT;
8131 dgst_size = DGST_SIZE_4_4;
8132 parse_func = md5apr1_parse_hash;
8133 sort_by_digest = sort_by_digest_4_4;
8134 opti_type = OPTI_TYPE_ZERO_BYTE;
8135 dgst_pos0 = 0;
8136 dgst_pos1 = 1;
8137 dgst_pos2 = 2;
8138 dgst_pos3 = 3;
8139 break;
8140
8141 case 1700: hash_type = HASH_TYPE_SHA512;
8142 salt_type = SALT_TYPE_NONE;
8143 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8144 opts_type = OPTS_TYPE_PT_GENERATE_BE
8145 | OPTS_TYPE_PT_ADD80
8146 | OPTS_TYPE_PT_ADDBITS15;
8147 kern_type = KERN_TYPE_SHA512;
8148 dgst_size = DGST_SIZE_8_8;
8149 parse_func = sha512_parse_hash;
8150 sort_by_digest = sort_by_digest_8_8;
8151 opti_type = OPTI_TYPE_ZERO_BYTE
8152 | OPTI_TYPE_PRECOMPUTE_INIT
8153 | OPTI_TYPE_PRECOMPUTE_MERKLE
8154 | OPTI_TYPE_EARLY_SKIP
8155 | OPTI_TYPE_NOT_ITERATED
8156 | OPTI_TYPE_NOT_SALTED
8157 | OPTI_TYPE_USES_BITS_64
8158 | OPTI_TYPE_RAW_HASH;
8159 dgst_pos0 = 14;
8160 dgst_pos1 = 15;
8161 dgst_pos2 = 6;
8162 dgst_pos3 = 7;
8163 break;
8164
8165 case 1710: hash_type = HASH_TYPE_SHA512;
8166 salt_type = SALT_TYPE_INTERN;
8167 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8168 opts_type = OPTS_TYPE_PT_GENERATE_BE
8169 | OPTS_TYPE_ST_ADD80
8170 | OPTS_TYPE_ST_ADDBITS15;
8171 kern_type = KERN_TYPE_SHA512_PWSLT;
8172 dgst_size = DGST_SIZE_8_8;
8173 parse_func = sha512s_parse_hash;
8174 sort_by_digest = sort_by_digest_8_8;
8175 opti_type = OPTI_TYPE_ZERO_BYTE
8176 | OPTI_TYPE_PRECOMPUTE_INIT
8177 | OPTI_TYPE_PRECOMPUTE_MERKLE
8178 | OPTI_TYPE_EARLY_SKIP
8179 | OPTI_TYPE_NOT_ITERATED
8180 | OPTI_TYPE_APPENDED_SALT
8181 | OPTI_TYPE_USES_BITS_64
8182 | OPTI_TYPE_RAW_HASH;
8183 dgst_pos0 = 14;
8184 dgst_pos1 = 15;
8185 dgst_pos2 = 6;
8186 dgst_pos3 = 7;
8187 break;
8188
8189 case 1711: hash_type = HASH_TYPE_SHA512;
8190 salt_type = SALT_TYPE_EMBEDDED;
8191 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8192 opts_type = OPTS_TYPE_PT_GENERATE_BE
8193 | OPTS_TYPE_ST_ADD80
8194 | OPTS_TYPE_ST_ADDBITS15;
8195 kern_type = KERN_TYPE_SHA512_PWSLT;
8196 dgst_size = DGST_SIZE_8_8;
8197 parse_func = sha512b64s_parse_hash;
8198 sort_by_digest = sort_by_digest_8_8;
8199 opti_type = OPTI_TYPE_ZERO_BYTE
8200 | OPTI_TYPE_PRECOMPUTE_INIT
8201 | OPTI_TYPE_PRECOMPUTE_MERKLE
8202 | OPTI_TYPE_EARLY_SKIP
8203 | OPTI_TYPE_NOT_ITERATED
8204 | OPTI_TYPE_APPENDED_SALT
8205 | OPTI_TYPE_USES_BITS_64
8206 | OPTI_TYPE_RAW_HASH;
8207 dgst_pos0 = 14;
8208 dgst_pos1 = 15;
8209 dgst_pos2 = 6;
8210 dgst_pos3 = 7;
8211 break;
8212
8213 case 1720: hash_type = HASH_TYPE_SHA512;
8214 salt_type = SALT_TYPE_INTERN;
8215 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8216 opts_type = OPTS_TYPE_PT_GENERATE_BE
8217 | OPTS_TYPE_PT_ADD80
8218 | OPTS_TYPE_PT_ADDBITS15;
8219 kern_type = KERN_TYPE_SHA512_SLTPW;
8220 dgst_size = DGST_SIZE_8_8;
8221 parse_func = sha512s_parse_hash;
8222 sort_by_digest = sort_by_digest_8_8;
8223 opti_type = OPTI_TYPE_ZERO_BYTE
8224 | OPTI_TYPE_PRECOMPUTE_INIT
8225 | OPTI_TYPE_PRECOMPUTE_MERKLE
8226 | OPTI_TYPE_EARLY_SKIP
8227 | OPTI_TYPE_NOT_ITERATED
8228 | OPTI_TYPE_PREPENDED_SALT
8229 | OPTI_TYPE_USES_BITS_64
8230 | OPTI_TYPE_RAW_HASH;
8231 dgst_pos0 = 14;
8232 dgst_pos1 = 15;
8233 dgst_pos2 = 6;
8234 dgst_pos3 = 7;
8235 break;
8236
8237 case 1722: hash_type = HASH_TYPE_SHA512;
8238 salt_type = SALT_TYPE_EMBEDDED;
8239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8240 opts_type = OPTS_TYPE_PT_GENERATE_BE
8241 | OPTS_TYPE_PT_ADD80
8242 | OPTS_TYPE_PT_ADDBITS15
8243 | OPTS_TYPE_ST_HEX;
8244 kern_type = KERN_TYPE_SHA512_SLTPW;
8245 dgst_size = DGST_SIZE_8_8;
8246 parse_func = osx512_parse_hash;
8247 sort_by_digest = sort_by_digest_8_8;
8248 opti_type = OPTI_TYPE_ZERO_BYTE
8249 | OPTI_TYPE_PRECOMPUTE_INIT
8250 | OPTI_TYPE_PRECOMPUTE_MERKLE
8251 | OPTI_TYPE_EARLY_SKIP
8252 | OPTI_TYPE_NOT_ITERATED
8253 | OPTI_TYPE_PREPENDED_SALT
8254 | OPTI_TYPE_USES_BITS_64
8255 | OPTI_TYPE_RAW_HASH;
8256 dgst_pos0 = 14;
8257 dgst_pos1 = 15;
8258 dgst_pos2 = 6;
8259 dgst_pos3 = 7;
8260 break;
8261
8262 case 1730: hash_type = HASH_TYPE_SHA512;
8263 salt_type = SALT_TYPE_INTERN;
8264 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8265 opts_type = OPTS_TYPE_PT_GENERATE_BE
8266 | OPTS_TYPE_PT_UNICODE
8267 | OPTS_TYPE_ST_ADD80
8268 | OPTS_TYPE_ST_ADDBITS15;
8269 kern_type = KERN_TYPE_SHA512_PWSLTU;
8270 dgst_size = DGST_SIZE_8_8;
8271 parse_func = sha512s_parse_hash;
8272 sort_by_digest = sort_by_digest_8_8;
8273 opti_type = OPTI_TYPE_ZERO_BYTE
8274 | OPTI_TYPE_PRECOMPUTE_INIT
8275 | OPTI_TYPE_PRECOMPUTE_MERKLE
8276 | OPTI_TYPE_EARLY_SKIP
8277 | OPTI_TYPE_NOT_ITERATED
8278 | OPTI_TYPE_APPENDED_SALT
8279 | OPTI_TYPE_USES_BITS_64
8280 | OPTI_TYPE_RAW_HASH;
8281 dgst_pos0 = 14;
8282 dgst_pos1 = 15;
8283 dgst_pos2 = 6;
8284 dgst_pos3 = 7;
8285 break;
8286
8287 case 1731: hash_type = HASH_TYPE_SHA512;
8288 salt_type = SALT_TYPE_EMBEDDED;
8289 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8290 opts_type = OPTS_TYPE_PT_GENERATE_BE
8291 | OPTS_TYPE_PT_UNICODE
8292 | OPTS_TYPE_ST_ADD80
8293 | OPTS_TYPE_ST_ADDBITS15
8294 | OPTS_TYPE_ST_HEX;
8295 kern_type = KERN_TYPE_SHA512_PWSLTU;
8296 dgst_size = DGST_SIZE_8_8;
8297 parse_func = mssql2012_parse_hash;
8298 sort_by_digest = sort_by_digest_8_8;
8299 opti_type = OPTI_TYPE_ZERO_BYTE
8300 | OPTI_TYPE_PRECOMPUTE_INIT
8301 | OPTI_TYPE_PRECOMPUTE_MERKLE
8302 | OPTI_TYPE_EARLY_SKIP
8303 | OPTI_TYPE_NOT_ITERATED
8304 | OPTI_TYPE_APPENDED_SALT
8305 | OPTI_TYPE_USES_BITS_64
8306 | OPTI_TYPE_RAW_HASH;
8307 dgst_pos0 = 14;
8308 dgst_pos1 = 15;
8309 dgst_pos2 = 6;
8310 dgst_pos3 = 7;
8311 break;
8312
8313 case 1740: hash_type = HASH_TYPE_SHA512;
8314 salt_type = SALT_TYPE_INTERN;
8315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8316 opts_type = OPTS_TYPE_PT_GENERATE_BE
8317 | OPTS_TYPE_PT_ADD80
8318 | OPTS_TYPE_PT_ADDBITS15
8319 | OPTS_TYPE_PT_UNICODE;
8320 kern_type = KERN_TYPE_SHA512_SLTPWU;
8321 dgst_size = DGST_SIZE_8_8;
8322 parse_func = sha512s_parse_hash;
8323 sort_by_digest = sort_by_digest_8_8;
8324 opti_type = OPTI_TYPE_ZERO_BYTE
8325 | OPTI_TYPE_PRECOMPUTE_INIT
8326 | OPTI_TYPE_PRECOMPUTE_MERKLE
8327 | OPTI_TYPE_EARLY_SKIP
8328 | OPTI_TYPE_NOT_ITERATED
8329 | OPTI_TYPE_PREPENDED_SALT
8330 | OPTI_TYPE_USES_BITS_64
8331 | OPTI_TYPE_RAW_HASH;
8332 dgst_pos0 = 14;
8333 dgst_pos1 = 15;
8334 dgst_pos2 = 6;
8335 dgst_pos3 = 7;
8336 break;
8337
8338 case 1750: hash_type = HASH_TYPE_SHA512;
8339 salt_type = SALT_TYPE_INTERN;
8340 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8341 opts_type = OPTS_TYPE_PT_GENERATE_BE
8342 | OPTS_TYPE_ST_ADD80;
8343 kern_type = KERN_TYPE_HMACSHA512_PW;
8344 dgst_size = DGST_SIZE_8_8;
8345 parse_func = hmacsha512_parse_hash;
8346 sort_by_digest = sort_by_digest_8_8;
8347 opti_type = OPTI_TYPE_ZERO_BYTE
8348 | OPTI_TYPE_USES_BITS_64
8349 | OPTI_TYPE_NOT_ITERATED;
8350 dgst_pos0 = 14;
8351 dgst_pos1 = 15;
8352 dgst_pos2 = 6;
8353 dgst_pos3 = 7;
8354 break;
8355
8356 case 1760: hash_type = HASH_TYPE_SHA512;
8357 salt_type = SALT_TYPE_INTERN;
8358 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8359 opts_type = OPTS_TYPE_PT_GENERATE_BE
8360 | OPTS_TYPE_PT_ADD80
8361 | OPTS_TYPE_PT_ADDBITS15;
8362 kern_type = KERN_TYPE_HMACSHA512_SLT;
8363 dgst_size = DGST_SIZE_8_8;
8364 parse_func = hmacsha512_parse_hash;
8365 sort_by_digest = sort_by_digest_8_8;
8366 opti_type = OPTI_TYPE_ZERO_BYTE
8367 | OPTI_TYPE_USES_BITS_64
8368 | OPTI_TYPE_NOT_ITERATED;
8369 dgst_pos0 = 14;
8370 dgst_pos1 = 15;
8371 dgst_pos2 = 6;
8372 dgst_pos3 = 7;
8373 break;
8374
8375 case 1800: hash_type = HASH_TYPE_SHA512;
8376 salt_type = SALT_TYPE_EMBEDDED;
8377 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8378 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8379 kern_type = KERN_TYPE_SHA512CRYPT;
8380 dgst_size = DGST_SIZE_8_8;
8381 parse_func = sha512crypt_parse_hash;
8382 sort_by_digest = sort_by_digest_8_8;
8383 opti_type = OPTI_TYPE_ZERO_BYTE
8384 | OPTI_TYPE_USES_BITS_64;
8385 dgst_pos0 = 0;
8386 dgst_pos1 = 1;
8387 dgst_pos2 = 2;
8388 dgst_pos3 = 3;
8389 break;
8390
8391 case 2100: hash_type = HASH_TYPE_DCC2;
8392 salt_type = SALT_TYPE_EMBEDDED;
8393 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8394 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8395 | OPTS_TYPE_ST_LOWER
8396 | OPTS_TYPE_ST_UNICODE;
8397 kern_type = KERN_TYPE_DCC2;
8398 dgst_size = DGST_SIZE_4_4;
8399 parse_func = dcc2_parse_hash;
8400 sort_by_digest = sort_by_digest_4_4;
8401 opti_type = OPTI_TYPE_ZERO_BYTE
8402 | OPTI_TYPE_SLOW_HASH_SIMD;
8403 dgst_pos0 = 0;
8404 dgst_pos1 = 1;
8405 dgst_pos2 = 2;
8406 dgst_pos3 = 3;
8407 break;
8408
8409 case 2400: hash_type = HASH_TYPE_MD5;
8410 salt_type = SALT_TYPE_NONE;
8411 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8412 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8413 kern_type = KERN_TYPE_MD5PIX;
8414 dgst_size = DGST_SIZE_4_4;
8415 parse_func = md5pix_parse_hash;
8416 sort_by_digest = sort_by_digest_4_4;
8417 opti_type = OPTI_TYPE_ZERO_BYTE
8418 | OPTI_TYPE_PRECOMPUTE_INIT
8419 | OPTI_TYPE_PRECOMPUTE_MERKLE
8420 | OPTI_TYPE_EARLY_SKIP
8421 | OPTI_TYPE_NOT_ITERATED
8422 | OPTI_TYPE_NOT_SALTED;
8423 dgst_pos0 = 0;
8424 dgst_pos1 = 3;
8425 dgst_pos2 = 2;
8426 dgst_pos3 = 1;
8427 break;
8428
8429 case 2410: hash_type = HASH_TYPE_MD5;
8430 salt_type = SALT_TYPE_INTERN;
8431 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8432 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8433 kern_type = KERN_TYPE_MD5ASA;
8434 dgst_size = DGST_SIZE_4_4;
8435 parse_func = md5asa_parse_hash;
8436 sort_by_digest = sort_by_digest_4_4;
8437 opti_type = OPTI_TYPE_ZERO_BYTE
8438 | OPTI_TYPE_PRECOMPUTE_INIT
8439 | OPTI_TYPE_PRECOMPUTE_MERKLE
8440 | OPTI_TYPE_EARLY_SKIP
8441 | OPTI_TYPE_NOT_ITERATED;
8442 dgst_pos0 = 0;
8443 dgst_pos1 = 3;
8444 dgst_pos2 = 2;
8445 dgst_pos3 = 1;
8446 break;
8447
8448 case 2500: hash_type = HASH_TYPE_WPA;
8449 salt_type = SALT_TYPE_EMBEDDED;
8450 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8451 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8452 kern_type = KERN_TYPE_WPA;
8453 dgst_size = DGST_SIZE_4_4;
8454 parse_func = wpa_parse_hash;
8455 sort_by_digest = sort_by_digest_4_4;
8456 opti_type = OPTI_TYPE_ZERO_BYTE
8457 | OPTI_TYPE_SLOW_HASH_SIMD;
8458 dgst_pos0 = 0;
8459 dgst_pos1 = 1;
8460 dgst_pos2 = 2;
8461 dgst_pos3 = 3;
8462 break;
8463
8464 case 2600: hash_type = HASH_TYPE_MD5;
8465 salt_type = SALT_TYPE_VIRTUAL;
8466 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8467 opts_type = OPTS_TYPE_PT_GENERATE_LE
8468 | OPTS_TYPE_PT_ADD80
8469 | OPTS_TYPE_PT_ADDBITS14
8470 | OPTS_TYPE_ST_ADD80;
8471 kern_type = KERN_TYPE_MD55_PWSLT1;
8472 dgst_size = DGST_SIZE_4_4;
8473 parse_func = md5md5_parse_hash;
8474 sort_by_digest = sort_by_digest_4_4;
8475 opti_type = OPTI_TYPE_ZERO_BYTE
8476 | OPTI_TYPE_PRECOMPUTE_INIT
8477 | OPTI_TYPE_PRECOMPUTE_MERKLE
8478 | OPTI_TYPE_EARLY_SKIP;
8479 dgst_pos0 = 0;
8480 dgst_pos1 = 3;
8481 dgst_pos2 = 2;
8482 dgst_pos3 = 1;
8483 break;
8484
8485 case 2611: hash_type = HASH_TYPE_MD5;
8486 salt_type = SALT_TYPE_INTERN;
8487 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8488 opts_type = OPTS_TYPE_PT_GENERATE_LE
8489 | OPTS_TYPE_PT_ADD80
8490 | OPTS_TYPE_PT_ADDBITS14
8491 | OPTS_TYPE_ST_ADD80;
8492 kern_type = KERN_TYPE_MD55_PWSLT1;
8493 dgst_size = DGST_SIZE_4_4;
8494 parse_func = vb3_parse_hash;
8495 sort_by_digest = sort_by_digest_4_4;
8496 opti_type = OPTI_TYPE_ZERO_BYTE
8497 | OPTI_TYPE_PRECOMPUTE_INIT
8498 | OPTI_TYPE_PRECOMPUTE_MERKLE
8499 | OPTI_TYPE_EARLY_SKIP;
8500 dgst_pos0 = 0;
8501 dgst_pos1 = 3;
8502 dgst_pos2 = 2;
8503 dgst_pos3 = 1;
8504 break;
8505
8506 case 2612: hash_type = HASH_TYPE_MD5;
8507 salt_type = SALT_TYPE_EMBEDDED;
8508 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8509 opts_type = OPTS_TYPE_PT_GENERATE_LE
8510 | OPTS_TYPE_PT_ADD80
8511 | OPTS_TYPE_PT_ADDBITS14
8512 | OPTS_TYPE_ST_ADD80
8513 | OPTS_TYPE_ST_HEX;
8514 kern_type = KERN_TYPE_MD55_PWSLT1;
8515 dgst_size = DGST_SIZE_4_4;
8516 parse_func = phps_parse_hash;
8517 sort_by_digest = sort_by_digest_4_4;
8518 opti_type = OPTI_TYPE_ZERO_BYTE
8519 | OPTI_TYPE_PRECOMPUTE_INIT
8520 | OPTI_TYPE_PRECOMPUTE_MERKLE
8521 | OPTI_TYPE_EARLY_SKIP;
8522 dgst_pos0 = 0;
8523 dgst_pos1 = 3;
8524 dgst_pos2 = 2;
8525 dgst_pos3 = 1;
8526 break;
8527
8528 case 2711: hash_type = HASH_TYPE_MD5;
8529 salt_type = SALT_TYPE_INTERN;
8530 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8531 opts_type = OPTS_TYPE_PT_GENERATE_LE
8532 | OPTS_TYPE_PT_ADD80
8533 | OPTS_TYPE_PT_ADDBITS14
8534 | OPTS_TYPE_ST_ADD80;
8535 kern_type = KERN_TYPE_MD55_PWSLT2;
8536 dgst_size = DGST_SIZE_4_4;
8537 parse_func = vb30_parse_hash;
8538 sort_by_digest = sort_by_digest_4_4;
8539 opti_type = OPTI_TYPE_ZERO_BYTE
8540 | OPTI_TYPE_PRECOMPUTE_INIT
8541 | OPTI_TYPE_EARLY_SKIP;
8542 dgst_pos0 = 0;
8543 dgst_pos1 = 3;
8544 dgst_pos2 = 2;
8545 dgst_pos3 = 1;
8546 break;
8547
8548 case 2811: hash_type = HASH_TYPE_MD5;
8549 salt_type = SALT_TYPE_INTERN;
8550 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8551 opts_type = OPTS_TYPE_PT_GENERATE_LE
8552 | OPTS_TYPE_PT_ADD80
8553 | OPTS_TYPE_PT_ADDBITS14;
8554 kern_type = KERN_TYPE_MD55_SLTPW;
8555 dgst_size = DGST_SIZE_4_4;
8556 parse_func = ipb2_parse_hash;
8557 sort_by_digest = sort_by_digest_4_4;
8558 opti_type = OPTI_TYPE_ZERO_BYTE
8559 | OPTI_TYPE_PRECOMPUTE_INIT
8560 | OPTI_TYPE_EARLY_SKIP;
8561 dgst_pos0 = 0;
8562 dgst_pos1 = 3;
8563 dgst_pos2 = 2;
8564 dgst_pos3 = 1;
8565 break;
8566
8567 case 3000: hash_type = HASH_TYPE_LM;
8568 salt_type = SALT_TYPE_NONE;
8569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8570 opts_type = OPTS_TYPE_PT_GENERATE_LE
8571 | OPTS_TYPE_PT_UPPER
8572 | OPTS_TYPE_PT_BITSLICE;
8573 kern_type = KERN_TYPE_LM;
8574 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8575 parse_func = lm_parse_hash;
8576 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8577 opti_type = OPTI_TYPE_ZERO_BYTE
8578 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8579 dgst_pos0 = 0;
8580 dgst_pos1 = 1;
8581 dgst_pos2 = 2;
8582 dgst_pos3 = 3;
8583 break;
8584
8585 case 3100: hash_type = HASH_TYPE_ORACLEH;
8586 salt_type = SALT_TYPE_INTERN;
8587 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8588 opts_type = OPTS_TYPE_PT_GENERATE_LE
8589 | OPTS_TYPE_PT_UPPER
8590 | OPTS_TYPE_ST_UPPER;
8591 kern_type = KERN_TYPE_ORACLEH;
8592 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8593 parse_func = oracleh_parse_hash;
8594 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8595 opti_type = OPTI_TYPE_ZERO_BYTE;
8596 dgst_pos0 = 0;
8597 dgst_pos1 = 1;
8598 dgst_pos2 = 2;
8599 dgst_pos3 = 3;
8600 break;
8601
8602 case 3200: hash_type = HASH_TYPE_BCRYPT;
8603 salt_type = SALT_TYPE_EMBEDDED;
8604 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8605 opts_type = OPTS_TYPE_PT_GENERATE_LE
8606 | OPTS_TYPE_ST_GENERATE_LE;
8607 kern_type = KERN_TYPE_BCRYPT;
8608 dgst_size = DGST_SIZE_4_6;
8609 parse_func = bcrypt_parse_hash;
8610 sort_by_digest = sort_by_digest_4_6;
8611 opti_type = OPTI_TYPE_ZERO_BYTE;
8612 dgst_pos0 = 0;
8613 dgst_pos1 = 1;
8614 dgst_pos2 = 2;
8615 dgst_pos3 = 3;
8616 break;
8617
8618 case 3710: hash_type = HASH_TYPE_MD5;
8619 salt_type = SALT_TYPE_INTERN;
8620 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8621 opts_type = OPTS_TYPE_PT_GENERATE_LE
8622 | OPTS_TYPE_PT_ADD80
8623 | OPTS_TYPE_PT_ADDBITS14;
8624 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8625 dgst_size = DGST_SIZE_4_4;
8626 parse_func = md5s_parse_hash;
8627 sort_by_digest = sort_by_digest_4_4;
8628 opti_type = OPTI_TYPE_ZERO_BYTE
8629 | OPTI_TYPE_PRECOMPUTE_INIT
8630 | OPTI_TYPE_PRECOMPUTE_MERKLE
8631 | OPTI_TYPE_EARLY_SKIP;
8632 dgst_pos0 = 0;
8633 dgst_pos1 = 3;
8634 dgst_pos2 = 2;
8635 dgst_pos3 = 1;
8636 break;
8637
8638 case 3711: hash_type = HASH_TYPE_MD5;
8639 salt_type = SALT_TYPE_EMBEDDED;
8640 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8641 opts_type = OPTS_TYPE_PT_GENERATE_LE
8642 | OPTS_TYPE_PT_ADD80
8643 | OPTS_TYPE_PT_ADDBITS14;
8644 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8645 dgst_size = DGST_SIZE_4_4;
8646 parse_func = mediawiki_b_parse_hash;
8647 sort_by_digest = sort_by_digest_4_4;
8648 opti_type = OPTI_TYPE_ZERO_BYTE
8649 | OPTI_TYPE_PRECOMPUTE_INIT
8650 | OPTI_TYPE_PRECOMPUTE_MERKLE
8651 | OPTI_TYPE_EARLY_SKIP;
8652 dgst_pos0 = 0;
8653 dgst_pos1 = 3;
8654 dgst_pos2 = 2;
8655 dgst_pos3 = 1;
8656 break;
8657
8658 case 3800: hash_type = HASH_TYPE_MD5;
8659 salt_type = SALT_TYPE_INTERN;
8660 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8661 opts_type = OPTS_TYPE_PT_GENERATE_LE
8662 | OPTS_TYPE_ST_ADDBITS14;
8663 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8664 dgst_size = DGST_SIZE_4_4;
8665 parse_func = md5s_parse_hash;
8666 sort_by_digest = sort_by_digest_4_4;
8667 opti_type = OPTI_TYPE_ZERO_BYTE
8668 | OPTI_TYPE_PRECOMPUTE_INIT
8669 | OPTI_TYPE_PRECOMPUTE_MERKLE
8670 | OPTI_TYPE_EARLY_SKIP
8671 | OPTI_TYPE_NOT_ITERATED
8672 | OPTI_TYPE_RAW_HASH;
8673 dgst_pos0 = 0;
8674 dgst_pos1 = 3;
8675 dgst_pos2 = 2;
8676 dgst_pos3 = 1;
8677 break;
8678
8679 case 4300: hash_type = HASH_TYPE_MD5;
8680 salt_type = SALT_TYPE_VIRTUAL;
8681 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8682 opts_type = OPTS_TYPE_PT_GENERATE_LE
8683 | OPTS_TYPE_PT_ADD80
8684 | OPTS_TYPE_PT_ADDBITS14
8685 | OPTS_TYPE_ST_ADD80;
8686 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8687 dgst_size = DGST_SIZE_4_4;
8688 parse_func = md5md5_parse_hash;
8689 sort_by_digest = sort_by_digest_4_4;
8690 opti_type = OPTI_TYPE_ZERO_BYTE
8691 | OPTI_TYPE_PRECOMPUTE_INIT
8692 | OPTI_TYPE_PRECOMPUTE_MERKLE
8693 | OPTI_TYPE_EARLY_SKIP;
8694 dgst_pos0 = 0;
8695 dgst_pos1 = 3;
8696 dgst_pos2 = 2;
8697 dgst_pos3 = 1;
8698 break;
8699
8700
8701 case 4400: hash_type = HASH_TYPE_MD5;
8702 salt_type = SALT_TYPE_NONE;
8703 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8704 opts_type = OPTS_TYPE_PT_GENERATE_BE
8705 | OPTS_TYPE_PT_ADD80
8706 | OPTS_TYPE_PT_ADDBITS15;
8707 kern_type = KERN_TYPE_MD5_SHA1;
8708 dgst_size = DGST_SIZE_4_4;
8709 parse_func = md5_parse_hash;
8710 sort_by_digest = sort_by_digest_4_4;
8711 opti_type = OPTI_TYPE_ZERO_BYTE
8712 | OPTI_TYPE_PRECOMPUTE_INIT
8713 | OPTI_TYPE_PRECOMPUTE_MERKLE
8714 | OPTI_TYPE_EARLY_SKIP
8715 | OPTI_TYPE_NOT_ITERATED
8716 | OPTI_TYPE_NOT_SALTED
8717 | OPTI_TYPE_RAW_HASH;
8718 dgst_pos0 = 0;
8719 dgst_pos1 = 3;
8720 dgst_pos2 = 2;
8721 dgst_pos3 = 1;
8722 break;
8723
8724 case 4500: hash_type = HASH_TYPE_SHA1;
8725 salt_type = SALT_TYPE_NONE;
8726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8727 opts_type = OPTS_TYPE_PT_GENERATE_BE
8728 | OPTS_TYPE_PT_ADD80
8729 | OPTS_TYPE_PT_ADDBITS15;
8730 kern_type = KERN_TYPE_SHA11;
8731 dgst_size = DGST_SIZE_4_5;
8732 parse_func = sha1_parse_hash;
8733 sort_by_digest = sort_by_digest_4_5;
8734 opti_type = OPTI_TYPE_ZERO_BYTE
8735 | OPTI_TYPE_PRECOMPUTE_INIT
8736 | OPTI_TYPE_PRECOMPUTE_MERKLE
8737 | OPTI_TYPE_EARLY_SKIP
8738 | OPTI_TYPE_NOT_SALTED;
8739 dgst_pos0 = 3;
8740 dgst_pos1 = 4;
8741 dgst_pos2 = 2;
8742 dgst_pos3 = 1;
8743 break;
8744
8745 case 4700: hash_type = HASH_TYPE_SHA1;
8746 salt_type = SALT_TYPE_NONE;
8747 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8748 opts_type = OPTS_TYPE_PT_GENERATE_LE
8749 | OPTS_TYPE_PT_ADD80
8750 | OPTS_TYPE_PT_ADDBITS14;
8751 kern_type = KERN_TYPE_SHA1_MD5;
8752 dgst_size = DGST_SIZE_4_5;
8753 parse_func = sha1_parse_hash;
8754 sort_by_digest = sort_by_digest_4_5;
8755 opti_type = OPTI_TYPE_ZERO_BYTE
8756 | OPTI_TYPE_PRECOMPUTE_INIT
8757 | OPTI_TYPE_PRECOMPUTE_MERKLE
8758 | OPTI_TYPE_EARLY_SKIP
8759 | OPTI_TYPE_NOT_ITERATED
8760 | OPTI_TYPE_NOT_SALTED
8761 | OPTI_TYPE_RAW_HASH;
8762 dgst_pos0 = 3;
8763 dgst_pos1 = 4;
8764 dgst_pos2 = 2;
8765 dgst_pos3 = 1;
8766 break;
8767
8768 case 4800: hash_type = HASH_TYPE_MD5;
8769 salt_type = SALT_TYPE_EMBEDDED;
8770 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8771 opts_type = OPTS_TYPE_PT_GENERATE_LE
8772 | OPTS_TYPE_PT_ADDBITS14;
8773 kern_type = KERN_TYPE_MD5_CHAP;
8774 dgst_size = DGST_SIZE_4_4;
8775 parse_func = chap_parse_hash;
8776 sort_by_digest = sort_by_digest_4_4;
8777 opti_type = OPTI_TYPE_ZERO_BYTE
8778 | OPTI_TYPE_PRECOMPUTE_INIT
8779 | OPTI_TYPE_PRECOMPUTE_MERKLE
8780 | OPTI_TYPE_MEET_IN_MIDDLE
8781 | OPTI_TYPE_EARLY_SKIP
8782 | OPTI_TYPE_NOT_ITERATED
8783 | OPTI_TYPE_RAW_HASH;
8784 dgst_pos0 = 0;
8785 dgst_pos1 = 3;
8786 dgst_pos2 = 2;
8787 dgst_pos3 = 1;
8788 break;
8789
8790 case 4900: hash_type = HASH_TYPE_SHA1;
8791 salt_type = SALT_TYPE_INTERN;
8792 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8793 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8794 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8795 dgst_size = DGST_SIZE_4_5;
8796 parse_func = sha1s_parse_hash;
8797 sort_by_digest = sort_by_digest_4_5;
8798 opti_type = OPTI_TYPE_ZERO_BYTE
8799 | OPTI_TYPE_PRECOMPUTE_INIT
8800 | OPTI_TYPE_PRECOMPUTE_MERKLE
8801 | OPTI_TYPE_EARLY_SKIP;
8802 dgst_pos0 = 3;
8803 dgst_pos1 = 4;
8804 dgst_pos2 = 2;
8805 dgst_pos3 = 1;
8806 break;
8807
8808 case 5000: hash_type = HASH_TYPE_KECCAK;
8809 salt_type = SALT_TYPE_EMBEDDED;
8810 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8811 opts_type = OPTS_TYPE_PT_GENERATE_LE
8812 | OPTS_TYPE_PT_ADD01;
8813 kern_type = KERN_TYPE_KECCAK;
8814 dgst_size = DGST_SIZE_8_25;
8815 parse_func = keccak_parse_hash;
8816 sort_by_digest = sort_by_digest_8_25;
8817 opti_type = OPTI_TYPE_ZERO_BYTE
8818 | OPTI_TYPE_USES_BITS_64
8819 | OPTI_TYPE_RAW_HASH;
8820 dgst_pos0 = 2;
8821 dgst_pos1 = 3;
8822 dgst_pos2 = 4;
8823 dgst_pos3 = 5;
8824 break;
8825
8826 case 5100: hash_type = HASH_TYPE_MD5H;
8827 salt_type = SALT_TYPE_NONE;
8828 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8829 opts_type = OPTS_TYPE_PT_GENERATE_LE
8830 | OPTS_TYPE_PT_ADD80
8831 | OPTS_TYPE_PT_ADDBITS14;
8832 kern_type = KERN_TYPE_MD5H;
8833 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8834 parse_func = md5half_parse_hash;
8835 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8836 opti_type = OPTI_TYPE_ZERO_BYTE
8837 | OPTI_TYPE_RAW_HASH;
8838 dgst_pos0 = 0;
8839 dgst_pos1 = 1;
8840 dgst_pos2 = 2;
8841 dgst_pos3 = 3;
8842 break;
8843
8844 case 5200: hash_type = HASH_TYPE_SHA256;
8845 salt_type = SALT_TYPE_EMBEDDED;
8846 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8847 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8848 kern_type = KERN_TYPE_PSAFE3;
8849 dgst_size = DGST_SIZE_4_8;
8850 parse_func = psafe3_parse_hash;
8851 sort_by_digest = sort_by_digest_4_8;
8852 opti_type = OPTI_TYPE_ZERO_BYTE;
8853 dgst_pos0 = 0;
8854 dgst_pos1 = 1;
8855 dgst_pos2 = 2;
8856 dgst_pos3 = 3;
8857 break;
8858
8859 case 5300: hash_type = HASH_TYPE_MD5;
8860 salt_type = SALT_TYPE_EMBEDDED;
8861 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8862 opts_type = OPTS_TYPE_PT_GENERATE_LE
8863 | OPTS_TYPE_ST_ADD80;
8864 kern_type = KERN_TYPE_IKEPSK_MD5;
8865 dgst_size = DGST_SIZE_4_4;
8866 parse_func = ikepsk_md5_parse_hash;
8867 sort_by_digest = sort_by_digest_4_4;
8868 opti_type = OPTI_TYPE_ZERO_BYTE;
8869 dgst_pos0 = 0;
8870 dgst_pos1 = 3;
8871 dgst_pos2 = 2;
8872 dgst_pos3 = 1;
8873 break;
8874
8875 case 5400: hash_type = HASH_TYPE_SHA1;
8876 salt_type = SALT_TYPE_EMBEDDED;
8877 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8878 opts_type = OPTS_TYPE_PT_GENERATE_BE
8879 | OPTS_TYPE_ST_ADD80;
8880 kern_type = KERN_TYPE_IKEPSK_SHA1;
8881 dgst_size = DGST_SIZE_4_5;
8882 parse_func = ikepsk_sha1_parse_hash;
8883 sort_by_digest = sort_by_digest_4_5;
8884 opti_type = OPTI_TYPE_ZERO_BYTE;
8885 dgst_pos0 = 3;
8886 dgst_pos1 = 4;
8887 dgst_pos2 = 2;
8888 dgst_pos3 = 1;
8889 break;
8890
8891 case 5500: hash_type = HASH_TYPE_NETNTLM;
8892 salt_type = SALT_TYPE_EMBEDDED;
8893 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8894 opts_type = OPTS_TYPE_PT_GENERATE_LE
8895 | OPTS_TYPE_PT_ADD80
8896 | OPTS_TYPE_PT_ADDBITS14
8897 | OPTS_TYPE_PT_UNICODE
8898 | OPTS_TYPE_ST_HEX;
8899 kern_type = KERN_TYPE_NETNTLMv1;
8900 dgst_size = DGST_SIZE_4_4;
8901 parse_func = netntlmv1_parse_hash;
8902 sort_by_digest = sort_by_digest_4_4;
8903 opti_type = OPTI_TYPE_ZERO_BYTE
8904 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8905 dgst_pos0 = 0;
8906 dgst_pos1 = 1;
8907 dgst_pos2 = 2;
8908 dgst_pos3 = 3;
8909 break;
8910
8911 case 5600: hash_type = HASH_TYPE_MD5;
8912 salt_type = SALT_TYPE_EMBEDDED;
8913 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8914 opts_type = OPTS_TYPE_PT_GENERATE_LE
8915 | OPTS_TYPE_PT_ADD80
8916 | OPTS_TYPE_PT_ADDBITS14
8917 | OPTS_TYPE_PT_UNICODE;
8918 kern_type = KERN_TYPE_NETNTLMv2;
8919 dgst_size = DGST_SIZE_4_4;
8920 parse_func = netntlmv2_parse_hash;
8921 sort_by_digest = sort_by_digest_4_4;
8922 opti_type = OPTI_TYPE_ZERO_BYTE;
8923 dgst_pos0 = 0;
8924 dgst_pos1 = 3;
8925 dgst_pos2 = 2;
8926 dgst_pos3 = 1;
8927 break;
8928
8929 case 5700: hash_type = HASH_TYPE_SHA256;
8930 salt_type = SALT_TYPE_NONE;
8931 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8932 opts_type = OPTS_TYPE_PT_GENERATE_BE
8933 | OPTS_TYPE_PT_ADD80
8934 | OPTS_TYPE_PT_ADDBITS15;
8935 kern_type = KERN_TYPE_SHA256;
8936 dgst_size = DGST_SIZE_4_8;
8937 parse_func = cisco4_parse_hash;
8938 sort_by_digest = sort_by_digest_4_8;
8939 opti_type = OPTI_TYPE_ZERO_BYTE
8940 | OPTI_TYPE_PRECOMPUTE_INIT
8941 | OPTI_TYPE_PRECOMPUTE_MERKLE
8942 | OPTI_TYPE_EARLY_SKIP
8943 | OPTI_TYPE_NOT_ITERATED
8944 | OPTI_TYPE_NOT_SALTED
8945 | OPTI_TYPE_RAW_HASH;
8946 dgst_pos0 = 3;
8947 dgst_pos1 = 7;
8948 dgst_pos2 = 2;
8949 dgst_pos3 = 6;
8950 break;
8951
8952 case 5800: hash_type = HASH_TYPE_SHA1;
8953 salt_type = SALT_TYPE_INTERN;
8954 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8955 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8956 | OPTS_TYPE_ST_ADD80;
8957 kern_type = KERN_TYPE_ANDROIDPIN;
8958 dgst_size = DGST_SIZE_4_5;
8959 parse_func = androidpin_parse_hash;
8960 sort_by_digest = sort_by_digest_4_5;
8961 opti_type = OPTI_TYPE_ZERO_BYTE;
8962 dgst_pos0 = 0;
8963 dgst_pos1 = 1;
8964 dgst_pos2 = 2;
8965 dgst_pos3 = 3;
8966 break;
8967
8968 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8969 salt_type = SALT_TYPE_NONE;
8970 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8971 opts_type = OPTS_TYPE_PT_GENERATE_LE
8972 | OPTS_TYPE_PT_ADD80;
8973 kern_type = KERN_TYPE_RIPEMD160;
8974 dgst_size = DGST_SIZE_4_5;
8975 parse_func = ripemd160_parse_hash;
8976 sort_by_digest = sort_by_digest_4_5;
8977 opti_type = OPTI_TYPE_ZERO_BYTE;
8978 dgst_pos0 = 0;
8979 dgst_pos1 = 1;
8980 dgst_pos2 = 2;
8981 dgst_pos3 = 3;
8982 break;
8983
8984 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8985 salt_type = SALT_TYPE_NONE;
8986 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8987 opts_type = OPTS_TYPE_PT_GENERATE_BE
8988 | OPTS_TYPE_PT_ADD80;
8989 kern_type = KERN_TYPE_WHIRLPOOL;
8990 dgst_size = DGST_SIZE_4_16;
8991 parse_func = whirlpool_parse_hash;
8992 sort_by_digest = sort_by_digest_4_16;
8993 opti_type = OPTI_TYPE_ZERO_BYTE;
8994 dgst_pos0 = 0;
8995 dgst_pos1 = 1;
8996 dgst_pos2 = 2;
8997 dgst_pos3 = 3;
8998 break;
8999
9000 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9001 salt_type = SALT_TYPE_EMBEDDED;
9002 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9003 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9004 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9005 dgst_size = DGST_SIZE_4_5;
9006 parse_func = truecrypt_parse_hash_2k;
9007 sort_by_digest = sort_by_digest_4_5;
9008 opti_type = OPTI_TYPE_ZERO_BYTE;
9009 dgst_pos0 = 0;
9010 dgst_pos1 = 1;
9011 dgst_pos2 = 2;
9012 dgst_pos3 = 3;
9013 break;
9014
9015 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9016 salt_type = SALT_TYPE_EMBEDDED;
9017 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9018 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9019 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9020 dgst_size = DGST_SIZE_4_5;
9021 parse_func = truecrypt_parse_hash_2k;
9022 sort_by_digest = sort_by_digest_4_5;
9023 opti_type = OPTI_TYPE_ZERO_BYTE;
9024 dgst_pos0 = 0;
9025 dgst_pos1 = 1;
9026 dgst_pos2 = 2;
9027 dgst_pos3 = 3;
9028 break;
9029
9030 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9031 salt_type = SALT_TYPE_EMBEDDED;
9032 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9033 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9034 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9035 dgst_size = DGST_SIZE_4_5;
9036 parse_func = truecrypt_parse_hash_2k;
9037 sort_by_digest = sort_by_digest_4_5;
9038 opti_type = OPTI_TYPE_ZERO_BYTE;
9039 dgst_pos0 = 0;
9040 dgst_pos1 = 1;
9041 dgst_pos2 = 2;
9042 dgst_pos3 = 3;
9043 break;
9044
9045 case 6221: hash_type = HASH_TYPE_SHA512;
9046 salt_type = SALT_TYPE_EMBEDDED;
9047 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9048 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9049 kern_type = KERN_TYPE_TCSHA512_XTS512;
9050 dgst_size = DGST_SIZE_8_8;
9051 parse_func = truecrypt_parse_hash_1k;
9052 sort_by_digest = sort_by_digest_8_8;
9053 opti_type = OPTI_TYPE_ZERO_BYTE
9054 | OPTI_TYPE_USES_BITS_64;
9055 dgst_pos0 = 0;
9056 dgst_pos1 = 1;
9057 dgst_pos2 = 2;
9058 dgst_pos3 = 3;
9059 break;
9060
9061 case 6222: hash_type = HASH_TYPE_SHA512;
9062 salt_type = SALT_TYPE_EMBEDDED;
9063 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9064 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9065 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9066 dgst_size = DGST_SIZE_8_8;
9067 parse_func = truecrypt_parse_hash_1k;
9068 sort_by_digest = sort_by_digest_8_8;
9069 opti_type = OPTI_TYPE_ZERO_BYTE
9070 | OPTI_TYPE_USES_BITS_64;
9071 dgst_pos0 = 0;
9072 dgst_pos1 = 1;
9073 dgst_pos2 = 2;
9074 dgst_pos3 = 3;
9075 break;
9076
9077 case 6223: hash_type = HASH_TYPE_SHA512;
9078 salt_type = SALT_TYPE_EMBEDDED;
9079 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9080 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9081 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9082 dgst_size = DGST_SIZE_8_8;
9083 parse_func = truecrypt_parse_hash_1k;
9084 sort_by_digest = sort_by_digest_8_8;
9085 opti_type = OPTI_TYPE_ZERO_BYTE
9086 | OPTI_TYPE_USES_BITS_64;
9087 dgst_pos0 = 0;
9088 dgst_pos1 = 1;
9089 dgst_pos2 = 2;
9090 dgst_pos3 = 3;
9091 break;
9092
9093 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9094 salt_type = SALT_TYPE_EMBEDDED;
9095 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9096 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9097 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9098 dgst_size = DGST_SIZE_4_8;
9099 parse_func = truecrypt_parse_hash_1k;
9100 sort_by_digest = sort_by_digest_4_8;
9101 opti_type = OPTI_TYPE_ZERO_BYTE;
9102 dgst_pos0 = 0;
9103 dgst_pos1 = 1;
9104 dgst_pos2 = 2;
9105 dgst_pos3 = 3;
9106 break;
9107
9108 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9109 salt_type = SALT_TYPE_EMBEDDED;
9110 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9111 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9112 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9113 dgst_size = DGST_SIZE_4_8;
9114 parse_func = truecrypt_parse_hash_1k;
9115 sort_by_digest = sort_by_digest_4_8;
9116 opti_type = OPTI_TYPE_ZERO_BYTE;
9117 dgst_pos0 = 0;
9118 dgst_pos1 = 1;
9119 dgst_pos2 = 2;
9120 dgst_pos3 = 3;
9121 break;
9122
9123 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9124 salt_type = SALT_TYPE_EMBEDDED;
9125 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9126 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9127 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9128 dgst_size = DGST_SIZE_4_8;
9129 parse_func = truecrypt_parse_hash_1k;
9130 sort_by_digest = sort_by_digest_4_8;
9131 opti_type = OPTI_TYPE_ZERO_BYTE;
9132 dgst_pos0 = 0;
9133 dgst_pos1 = 1;
9134 dgst_pos2 = 2;
9135 dgst_pos3 = 3;
9136 break;
9137
9138 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9139 salt_type = SALT_TYPE_EMBEDDED;
9140 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9141 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9142 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9143 dgst_size = DGST_SIZE_4_5;
9144 parse_func = truecrypt_parse_hash_1k;
9145 sort_by_digest = sort_by_digest_4_5;
9146 opti_type = OPTI_TYPE_ZERO_BYTE;
9147 dgst_pos0 = 0;
9148 dgst_pos1 = 1;
9149 dgst_pos2 = 2;
9150 dgst_pos3 = 3;
9151 break;
9152
9153 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9154 salt_type = SALT_TYPE_EMBEDDED;
9155 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9156 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9157 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9158 dgst_size = DGST_SIZE_4_5;
9159 parse_func = truecrypt_parse_hash_1k;
9160 sort_by_digest = sort_by_digest_4_5;
9161 opti_type = OPTI_TYPE_ZERO_BYTE;
9162 dgst_pos0 = 0;
9163 dgst_pos1 = 1;
9164 dgst_pos2 = 2;
9165 dgst_pos3 = 3;
9166 break;
9167
9168 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9169 salt_type = SALT_TYPE_EMBEDDED;
9170 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9171 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9172 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9173 dgst_size = DGST_SIZE_4_5;
9174 parse_func = truecrypt_parse_hash_1k;
9175 sort_by_digest = sort_by_digest_4_5;
9176 opti_type = OPTI_TYPE_ZERO_BYTE;
9177 dgst_pos0 = 0;
9178 dgst_pos1 = 1;
9179 dgst_pos2 = 2;
9180 dgst_pos3 = 3;
9181 break;
9182
9183 case 6300: hash_type = HASH_TYPE_MD5;
9184 salt_type = SALT_TYPE_EMBEDDED;
9185 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9186 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9187 kern_type = KERN_TYPE_MD5AIX;
9188 dgst_size = DGST_SIZE_4_4;
9189 parse_func = md5aix_parse_hash;
9190 sort_by_digest = sort_by_digest_4_4;
9191 opti_type = OPTI_TYPE_ZERO_BYTE;
9192 dgst_pos0 = 0;
9193 dgst_pos1 = 1;
9194 dgst_pos2 = 2;
9195 dgst_pos3 = 3;
9196 break;
9197
9198 case 6400: hash_type = HASH_TYPE_SHA256;
9199 salt_type = SALT_TYPE_EMBEDDED;
9200 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9201 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9202 kern_type = KERN_TYPE_SHA256AIX;
9203 dgst_size = DGST_SIZE_4_8;
9204 parse_func = sha256aix_parse_hash;
9205 sort_by_digest = sort_by_digest_4_8;
9206 opti_type = OPTI_TYPE_ZERO_BYTE;
9207 dgst_pos0 = 0;
9208 dgst_pos1 = 1;
9209 dgst_pos2 = 2;
9210 dgst_pos3 = 3;
9211 break;
9212
9213 case 6500: hash_type = HASH_TYPE_SHA512;
9214 salt_type = SALT_TYPE_EMBEDDED;
9215 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9216 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9217 kern_type = KERN_TYPE_SHA512AIX;
9218 dgst_size = DGST_SIZE_8_8;
9219 parse_func = sha512aix_parse_hash;
9220 sort_by_digest = sort_by_digest_8_8;
9221 opti_type = OPTI_TYPE_ZERO_BYTE
9222 | OPTI_TYPE_USES_BITS_64;
9223 dgst_pos0 = 0;
9224 dgst_pos1 = 1;
9225 dgst_pos2 = 2;
9226 dgst_pos3 = 3;
9227 break;
9228
9229 case 6600: hash_type = HASH_TYPE_AES;
9230 salt_type = SALT_TYPE_EMBEDDED;
9231 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9232 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9233 kern_type = KERN_TYPE_AGILEKEY;
9234 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9235 parse_func = agilekey_parse_hash;
9236 sort_by_digest = sort_by_digest_4_5;
9237 opti_type = OPTI_TYPE_ZERO_BYTE;
9238 dgst_pos0 = 0;
9239 dgst_pos1 = 1;
9240 dgst_pos2 = 2;
9241 dgst_pos3 = 3;
9242 break;
9243
9244 case 6700: hash_type = HASH_TYPE_SHA1;
9245 salt_type = SALT_TYPE_EMBEDDED;
9246 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9247 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9248 kern_type = KERN_TYPE_SHA1AIX;
9249 dgst_size = DGST_SIZE_4_5;
9250 parse_func = sha1aix_parse_hash;
9251 sort_by_digest = sort_by_digest_4_5;
9252 opti_type = OPTI_TYPE_ZERO_BYTE;
9253 dgst_pos0 = 0;
9254 dgst_pos1 = 1;
9255 dgst_pos2 = 2;
9256 dgst_pos3 = 3;
9257 break;
9258
9259 case 6800: hash_type = HASH_TYPE_AES;
9260 salt_type = SALT_TYPE_EMBEDDED;
9261 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9262 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9263 kern_type = KERN_TYPE_LASTPASS;
9264 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9265 parse_func = lastpass_parse_hash;
9266 sort_by_digest = sort_by_digest_4_8;
9267 opti_type = OPTI_TYPE_ZERO_BYTE;
9268 dgst_pos0 = 0;
9269 dgst_pos1 = 1;
9270 dgst_pos2 = 2;
9271 dgst_pos3 = 3;
9272 break;
9273
9274 case 6900: hash_type = HASH_TYPE_GOST;
9275 salt_type = SALT_TYPE_NONE;
9276 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9277 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9278 kern_type = KERN_TYPE_GOST;
9279 dgst_size = DGST_SIZE_4_8;
9280 parse_func = gost_parse_hash;
9281 sort_by_digest = sort_by_digest_4_8;
9282 opti_type = OPTI_TYPE_ZERO_BYTE;
9283 dgst_pos0 = 0;
9284 dgst_pos1 = 1;
9285 dgst_pos2 = 2;
9286 dgst_pos3 = 3;
9287 break;
9288
9289 case 7100: hash_type = HASH_TYPE_SHA512;
9290 salt_type = SALT_TYPE_EMBEDDED;
9291 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9292 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9293 kern_type = KERN_TYPE_PBKDF2_SHA512;
9294 dgst_size = DGST_SIZE_8_16;
9295 parse_func = sha512osx_parse_hash;
9296 sort_by_digest = sort_by_digest_8_16;
9297 opti_type = OPTI_TYPE_ZERO_BYTE
9298 | OPTI_TYPE_USES_BITS_64
9299 | OPTI_TYPE_SLOW_HASH_SIMD;
9300 dgst_pos0 = 0;
9301 dgst_pos1 = 1;
9302 dgst_pos2 = 2;
9303 dgst_pos3 = 3;
9304 break;
9305
9306 case 7200: hash_type = HASH_TYPE_SHA512;
9307 salt_type = SALT_TYPE_EMBEDDED;
9308 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9309 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9310 kern_type = KERN_TYPE_PBKDF2_SHA512;
9311 dgst_size = DGST_SIZE_8_16;
9312 parse_func = sha512grub_parse_hash;
9313 sort_by_digest = sort_by_digest_8_16;
9314 opti_type = OPTI_TYPE_ZERO_BYTE
9315 | OPTI_TYPE_USES_BITS_64
9316 | OPTI_TYPE_SLOW_HASH_SIMD;
9317 dgst_pos0 = 0;
9318 dgst_pos1 = 1;
9319 dgst_pos2 = 2;
9320 dgst_pos3 = 3;
9321 break;
9322
9323 case 7300: hash_type = HASH_TYPE_SHA1;
9324 salt_type = SALT_TYPE_EMBEDDED;
9325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9326 opts_type = OPTS_TYPE_PT_GENERATE_BE
9327 | OPTS_TYPE_ST_ADD80
9328 | OPTS_TYPE_ST_ADDBITS15;
9329 kern_type = KERN_TYPE_RAKP;
9330 dgst_size = DGST_SIZE_4_5;
9331 parse_func = rakp_parse_hash;
9332 sort_by_digest = sort_by_digest_4_5;
9333 opti_type = OPTI_TYPE_ZERO_BYTE
9334 | OPTI_TYPE_NOT_ITERATED;
9335 dgst_pos0 = 3;
9336 dgst_pos1 = 4;
9337 dgst_pos2 = 2;
9338 dgst_pos3 = 1;
9339 break;
9340
9341 case 7400: hash_type = HASH_TYPE_SHA256;
9342 salt_type = SALT_TYPE_EMBEDDED;
9343 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9344 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9345 kern_type = KERN_TYPE_SHA256CRYPT;
9346 dgst_size = DGST_SIZE_4_8;
9347 parse_func = sha256crypt_parse_hash;
9348 sort_by_digest = sort_by_digest_4_8;
9349 opti_type = OPTI_TYPE_ZERO_BYTE;
9350 dgst_pos0 = 0;
9351 dgst_pos1 = 1;
9352 dgst_pos2 = 2;
9353 dgst_pos3 = 3;
9354 break;
9355
9356 case 7500: hash_type = HASH_TYPE_KRB5PA;
9357 salt_type = SALT_TYPE_EMBEDDED;
9358 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9359 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9360 kern_type = KERN_TYPE_KRB5PA;
9361 dgst_size = DGST_SIZE_4_4;
9362 parse_func = krb5pa_parse_hash;
9363 sort_by_digest = sort_by_digest_4_4;
9364 opti_type = OPTI_TYPE_ZERO_BYTE
9365 | OPTI_TYPE_NOT_ITERATED;
9366 dgst_pos0 = 0;
9367 dgst_pos1 = 1;
9368 dgst_pos2 = 2;
9369 dgst_pos3 = 3;
9370 break;
9371
9372 case 7600: hash_type = HASH_TYPE_SHA1;
9373 salt_type = SALT_TYPE_INTERN;
9374 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9375 opts_type = OPTS_TYPE_PT_GENERATE_BE
9376 | OPTS_TYPE_PT_ADD80
9377 | OPTS_TYPE_PT_ADDBITS15;
9378 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9379 dgst_size = DGST_SIZE_4_5;
9380 parse_func = redmine_parse_hash;
9381 sort_by_digest = sort_by_digest_4_5;
9382 opti_type = OPTI_TYPE_ZERO_BYTE
9383 | OPTI_TYPE_PRECOMPUTE_INIT
9384 | OPTI_TYPE_EARLY_SKIP
9385 | OPTI_TYPE_NOT_ITERATED
9386 | OPTI_TYPE_PREPENDED_SALT;
9387 dgst_pos0 = 3;
9388 dgst_pos1 = 4;
9389 dgst_pos2 = 2;
9390 dgst_pos3 = 1;
9391 break;
9392
9393 case 7700: hash_type = HASH_TYPE_SAPB;
9394 salt_type = SALT_TYPE_EMBEDDED;
9395 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9396 opts_type = OPTS_TYPE_PT_GENERATE_LE
9397 | OPTS_TYPE_PT_UPPER
9398 | OPTS_TYPE_ST_UPPER;
9399 kern_type = KERN_TYPE_SAPB;
9400 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9401 parse_func = sapb_parse_hash;
9402 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9403 opti_type = OPTI_TYPE_ZERO_BYTE
9404 | OPTI_TYPE_PRECOMPUTE_INIT
9405 | OPTI_TYPE_NOT_ITERATED;
9406 dgst_pos0 = 0;
9407 dgst_pos1 = 1;
9408 dgst_pos2 = 2;
9409 dgst_pos3 = 3;
9410 break;
9411
9412 case 7800: hash_type = HASH_TYPE_SAPG;
9413 salt_type = SALT_TYPE_EMBEDDED;
9414 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9415 opts_type = OPTS_TYPE_PT_GENERATE_BE
9416 | OPTS_TYPE_ST_ADD80
9417 | OPTS_TYPE_ST_UPPER;
9418 kern_type = KERN_TYPE_SAPG;
9419 dgst_size = DGST_SIZE_4_5;
9420 parse_func = sapg_parse_hash;
9421 sort_by_digest = sort_by_digest_4_5;
9422 opti_type = OPTI_TYPE_ZERO_BYTE
9423 | OPTI_TYPE_PRECOMPUTE_INIT
9424 | OPTI_TYPE_NOT_ITERATED;
9425 dgst_pos0 = 3;
9426 dgst_pos1 = 4;
9427 dgst_pos2 = 2;
9428 dgst_pos3 = 1;
9429 break;
9430
9431 case 7900: hash_type = HASH_TYPE_SHA512;
9432 salt_type = SALT_TYPE_EMBEDDED;
9433 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9434 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9435 kern_type = KERN_TYPE_DRUPAL7;
9436 dgst_size = DGST_SIZE_8_8;
9437 parse_func = drupal7_parse_hash;
9438 sort_by_digest = sort_by_digest_8_8;
9439 opti_type = OPTI_TYPE_ZERO_BYTE
9440 | OPTI_TYPE_USES_BITS_64;
9441 dgst_pos0 = 0;
9442 dgst_pos1 = 1;
9443 dgst_pos2 = 2;
9444 dgst_pos3 = 3;
9445 break;
9446
9447 case 8000: hash_type = HASH_TYPE_SHA256;
9448 salt_type = SALT_TYPE_EMBEDDED;
9449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9450 opts_type = OPTS_TYPE_PT_GENERATE_BE
9451 | OPTS_TYPE_PT_UNICODE
9452 | OPTS_TYPE_ST_ADD80
9453 | OPTS_TYPE_ST_HEX;
9454 kern_type = KERN_TYPE_SYBASEASE;
9455 dgst_size = DGST_SIZE_4_8;
9456 parse_func = sybasease_parse_hash;
9457 sort_by_digest = sort_by_digest_4_8;
9458 opti_type = OPTI_TYPE_ZERO_BYTE
9459 | OPTI_TYPE_PRECOMPUTE_INIT
9460 | OPTI_TYPE_EARLY_SKIP
9461 | OPTI_TYPE_NOT_ITERATED
9462 | OPTI_TYPE_RAW_HASH;
9463 dgst_pos0 = 3;
9464 dgst_pos1 = 7;
9465 dgst_pos2 = 2;
9466 dgst_pos3 = 6;
9467 break;
9468
9469 case 8100: hash_type = HASH_TYPE_SHA1;
9470 salt_type = SALT_TYPE_EMBEDDED;
9471 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9472 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9473 kern_type = KERN_TYPE_NETSCALER;
9474 dgst_size = DGST_SIZE_4_5;
9475 parse_func = netscaler_parse_hash;
9476 sort_by_digest = sort_by_digest_4_5;
9477 opti_type = OPTI_TYPE_ZERO_BYTE
9478 | OPTI_TYPE_PRECOMPUTE_INIT
9479 | OPTI_TYPE_PRECOMPUTE_MERKLE
9480 | OPTI_TYPE_EARLY_SKIP
9481 | OPTI_TYPE_NOT_ITERATED
9482 | OPTI_TYPE_PREPENDED_SALT
9483 | OPTI_TYPE_RAW_HASH;
9484 dgst_pos0 = 3;
9485 dgst_pos1 = 4;
9486 dgst_pos2 = 2;
9487 dgst_pos3 = 1;
9488 break;
9489
9490 case 8200: hash_type = HASH_TYPE_SHA256;
9491 salt_type = SALT_TYPE_EMBEDDED;
9492 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9493 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9494 kern_type = KERN_TYPE_CLOUDKEY;
9495 dgst_size = DGST_SIZE_4_8;
9496 parse_func = cloudkey_parse_hash;
9497 sort_by_digest = sort_by_digest_4_8;
9498 opti_type = OPTI_TYPE_ZERO_BYTE;
9499 dgst_pos0 = 0;
9500 dgst_pos1 = 1;
9501 dgst_pos2 = 2;
9502 dgst_pos3 = 3;
9503 break;
9504
9505 case 8300: hash_type = HASH_TYPE_SHA1;
9506 salt_type = SALT_TYPE_EMBEDDED;
9507 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9508 opts_type = OPTS_TYPE_PT_GENERATE_BE
9509 | OPTS_TYPE_ST_HEX
9510 | OPTS_TYPE_ST_ADD80;
9511 kern_type = KERN_TYPE_NSEC3;
9512 dgst_size = DGST_SIZE_4_5;
9513 parse_func = nsec3_parse_hash;
9514 sort_by_digest = sort_by_digest_4_5;
9515 opti_type = OPTI_TYPE_ZERO_BYTE;
9516 dgst_pos0 = 3;
9517 dgst_pos1 = 4;
9518 dgst_pos2 = 2;
9519 dgst_pos3 = 1;
9520 break;
9521
9522 case 8400: hash_type = HASH_TYPE_SHA1;
9523 salt_type = SALT_TYPE_INTERN;
9524 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9525 opts_type = OPTS_TYPE_PT_GENERATE_BE
9526 | OPTS_TYPE_PT_ADD80
9527 | OPTS_TYPE_PT_ADDBITS15;
9528 kern_type = KERN_TYPE_WBB3;
9529 dgst_size = DGST_SIZE_4_5;
9530 parse_func = wbb3_parse_hash;
9531 sort_by_digest = sort_by_digest_4_5;
9532 opti_type = OPTI_TYPE_ZERO_BYTE
9533 | OPTI_TYPE_PRECOMPUTE_INIT
9534 | OPTI_TYPE_NOT_ITERATED;
9535 dgst_pos0 = 3;
9536 dgst_pos1 = 4;
9537 dgst_pos2 = 2;
9538 dgst_pos3 = 1;
9539 break;
9540
9541 case 8500: hash_type = HASH_TYPE_DESRACF;
9542 salt_type = SALT_TYPE_EMBEDDED;
9543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9544 opts_type = OPTS_TYPE_PT_GENERATE_LE
9545 | OPTS_TYPE_ST_UPPER;
9546 kern_type = KERN_TYPE_RACF;
9547 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9548 parse_func = racf_parse_hash;
9549 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9550 opti_type = OPTI_TYPE_ZERO_BYTE
9551 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9552 dgst_pos0 = 0;
9553 dgst_pos1 = 1;
9554 dgst_pos2 = 2;
9555 dgst_pos3 = 3;
9556 break;
9557
9558 case 8600: hash_type = HASH_TYPE_LOTUS5;
9559 salt_type = SALT_TYPE_NONE;
9560 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9561 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9562 kern_type = KERN_TYPE_LOTUS5;
9563 dgst_size = DGST_SIZE_4_4;
9564 parse_func = lotus5_parse_hash;
9565 sort_by_digest = sort_by_digest_4_4;
9566 opti_type = OPTI_TYPE_EARLY_SKIP
9567 | OPTI_TYPE_NOT_ITERATED
9568 | OPTI_TYPE_NOT_SALTED
9569 | OPTI_TYPE_RAW_HASH;
9570 dgst_pos0 = 0;
9571 dgst_pos1 = 1;
9572 dgst_pos2 = 2;
9573 dgst_pos3 = 3;
9574 break;
9575
9576 case 8700: hash_type = HASH_TYPE_LOTUS6;
9577 salt_type = SALT_TYPE_EMBEDDED;
9578 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9579 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9580 kern_type = KERN_TYPE_LOTUS6;
9581 dgst_size = DGST_SIZE_4_4;
9582 parse_func = lotus6_parse_hash;
9583 sort_by_digest = sort_by_digest_4_4;
9584 opti_type = OPTI_TYPE_EARLY_SKIP
9585 | OPTI_TYPE_NOT_ITERATED
9586 | OPTI_TYPE_RAW_HASH;
9587 dgst_pos0 = 0;
9588 dgst_pos1 = 1;
9589 dgst_pos2 = 2;
9590 dgst_pos3 = 3;
9591 break;
9592
9593 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9594 salt_type = SALT_TYPE_EMBEDDED;
9595 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9596 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9597 kern_type = KERN_TYPE_ANDROIDFDE;
9598 dgst_size = DGST_SIZE_4_4;
9599 parse_func = androidfde_parse_hash;
9600 sort_by_digest = sort_by_digest_4_4;
9601 opti_type = OPTI_TYPE_ZERO_BYTE;
9602 dgst_pos0 = 0;
9603 dgst_pos1 = 1;
9604 dgst_pos2 = 2;
9605 dgst_pos3 = 3;
9606 break;
9607
9608 case 8900: hash_type = HASH_TYPE_SCRYPT;
9609 salt_type = SALT_TYPE_EMBEDDED;
9610 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9611 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9612 kern_type = KERN_TYPE_SCRYPT;
9613 dgst_size = DGST_SIZE_4_8;
9614 parse_func = scrypt_parse_hash;
9615 sort_by_digest = sort_by_digest_4_8;
9616 opti_type = OPTI_TYPE_ZERO_BYTE;
9617 dgst_pos0 = 0;
9618 dgst_pos1 = 1;
9619 dgst_pos2 = 2;
9620 dgst_pos3 = 3;
9621 break;
9622
9623 case 9000: hash_type = HASH_TYPE_SHA1;
9624 salt_type = SALT_TYPE_EMBEDDED;
9625 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9626 opts_type = OPTS_TYPE_PT_GENERATE_LE
9627 | OPTS_TYPE_ST_GENERATE_LE;
9628 kern_type = KERN_TYPE_PSAFE2;
9629 dgst_size = DGST_SIZE_4_5;
9630 parse_func = psafe2_parse_hash;
9631 sort_by_digest = sort_by_digest_4_5;
9632 opti_type = OPTI_TYPE_ZERO_BYTE;
9633 dgst_pos0 = 0;
9634 dgst_pos1 = 1;
9635 dgst_pos2 = 2;
9636 dgst_pos3 = 3;
9637 break;
9638
9639 case 9100: hash_type = HASH_TYPE_LOTUS8;
9640 salt_type = SALT_TYPE_EMBEDDED;
9641 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9642 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9643 kern_type = KERN_TYPE_LOTUS8;
9644 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9645 parse_func = lotus8_parse_hash;
9646 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9647 opti_type = OPTI_TYPE_ZERO_BYTE;
9648 dgst_pos0 = 0;
9649 dgst_pos1 = 1;
9650 dgst_pos2 = 2;
9651 dgst_pos3 = 3;
9652 break;
9653
9654 case 9200: hash_type = HASH_TYPE_SHA256;
9655 salt_type = SALT_TYPE_EMBEDDED;
9656 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9657 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9658 kern_type = KERN_TYPE_PBKDF2_SHA256;
9659 dgst_size = DGST_SIZE_4_32;
9660 parse_func = cisco8_parse_hash;
9661 sort_by_digest = sort_by_digest_4_32;
9662 opti_type = OPTI_TYPE_ZERO_BYTE
9663 | OPTI_TYPE_SLOW_HASH_SIMD;
9664 dgst_pos0 = 0;
9665 dgst_pos1 = 1;
9666 dgst_pos2 = 2;
9667 dgst_pos3 = 3;
9668 break;
9669
9670 case 9300: hash_type = HASH_TYPE_SCRYPT;
9671 salt_type = SALT_TYPE_EMBEDDED;
9672 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9673 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9674 kern_type = KERN_TYPE_SCRYPT;
9675 dgst_size = DGST_SIZE_4_8;
9676 parse_func = cisco9_parse_hash;
9677 sort_by_digest = sort_by_digest_4_8;
9678 opti_type = OPTI_TYPE_ZERO_BYTE;
9679 dgst_pos0 = 0;
9680 dgst_pos1 = 1;
9681 dgst_pos2 = 2;
9682 dgst_pos3 = 3;
9683 break;
9684
9685 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9686 salt_type = SALT_TYPE_EMBEDDED;
9687 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9688 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9689 kern_type = KERN_TYPE_OFFICE2007;
9690 dgst_size = DGST_SIZE_4_4;
9691 parse_func = office2007_parse_hash;
9692 sort_by_digest = sort_by_digest_4_4;
9693 opti_type = OPTI_TYPE_ZERO_BYTE;
9694 dgst_pos0 = 0;
9695 dgst_pos1 = 1;
9696 dgst_pos2 = 2;
9697 dgst_pos3 = 3;
9698 break;
9699
9700 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9701 salt_type = SALT_TYPE_EMBEDDED;
9702 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9703 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9704 kern_type = KERN_TYPE_OFFICE2010;
9705 dgst_size = DGST_SIZE_4_4;
9706 parse_func = office2010_parse_hash;
9707 sort_by_digest = sort_by_digest_4_4;
9708 opti_type = OPTI_TYPE_ZERO_BYTE;
9709 dgst_pos0 = 0;
9710 dgst_pos1 = 1;
9711 dgst_pos2 = 2;
9712 dgst_pos3 = 3;
9713 break;
9714
9715 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9716 salt_type = SALT_TYPE_EMBEDDED;
9717 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9718 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9719 kern_type = KERN_TYPE_OFFICE2013;
9720 dgst_size = DGST_SIZE_4_4;
9721 parse_func = office2013_parse_hash;
9722 sort_by_digest = sort_by_digest_4_4;
9723 opti_type = OPTI_TYPE_ZERO_BYTE;
9724 dgst_pos0 = 0;
9725 dgst_pos1 = 1;
9726 dgst_pos2 = 2;
9727 dgst_pos3 = 3;
9728 break;
9729
9730 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9731 salt_type = SALT_TYPE_EMBEDDED;
9732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9733 opts_type = OPTS_TYPE_PT_GENERATE_LE
9734 | OPTS_TYPE_PT_ADD80
9735 | OPTS_TYPE_PT_UNICODE;
9736 kern_type = KERN_TYPE_OLDOFFICE01;
9737 dgst_size = DGST_SIZE_4_4;
9738 parse_func = oldoffice01_parse_hash;
9739 sort_by_digest = sort_by_digest_4_4;
9740 opti_type = OPTI_TYPE_ZERO_BYTE
9741 | OPTI_TYPE_PRECOMPUTE_INIT
9742 | OPTI_TYPE_NOT_ITERATED;
9743 dgst_pos0 = 0;
9744 dgst_pos1 = 1;
9745 dgst_pos2 = 2;
9746 dgst_pos3 = 3;
9747 break;
9748
9749 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9750 salt_type = SALT_TYPE_EMBEDDED;
9751 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9752 opts_type = OPTS_TYPE_PT_GENERATE_LE
9753 | OPTS_TYPE_PT_ADD80;
9754 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9755 dgst_size = DGST_SIZE_4_4;
9756 parse_func = oldoffice01cm1_parse_hash;
9757 sort_by_digest = sort_by_digest_4_4;
9758 opti_type = OPTI_TYPE_ZERO_BYTE
9759 | OPTI_TYPE_PRECOMPUTE_INIT
9760 | OPTI_TYPE_NOT_ITERATED;
9761 dgst_pos0 = 0;
9762 dgst_pos1 = 1;
9763 dgst_pos2 = 2;
9764 dgst_pos3 = 3;
9765 break;
9766
9767 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9768 salt_type = SALT_TYPE_EMBEDDED;
9769 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9770 opts_type = OPTS_TYPE_PT_GENERATE_LE
9771 | OPTS_TYPE_PT_ADD80
9772 | OPTS_TYPE_PT_UNICODE
9773 | OPTS_TYPE_PT_NEVERCRACK;
9774 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9775 dgst_size = DGST_SIZE_4_4;
9776 parse_func = oldoffice01cm2_parse_hash;
9777 sort_by_digest = sort_by_digest_4_4;
9778 opti_type = OPTI_TYPE_ZERO_BYTE
9779 | OPTI_TYPE_PRECOMPUTE_INIT
9780 | OPTI_TYPE_NOT_ITERATED;
9781 dgst_pos0 = 0;
9782 dgst_pos1 = 1;
9783 dgst_pos2 = 2;
9784 dgst_pos3 = 3;
9785 break;
9786
9787 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9788 salt_type = SALT_TYPE_EMBEDDED;
9789 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9790 opts_type = OPTS_TYPE_PT_GENERATE_BE
9791 | OPTS_TYPE_PT_ADD80
9792 | OPTS_TYPE_PT_UNICODE;
9793 kern_type = KERN_TYPE_OLDOFFICE34;
9794 dgst_size = DGST_SIZE_4_4;
9795 parse_func = oldoffice34_parse_hash;
9796 sort_by_digest = sort_by_digest_4_4;
9797 opti_type = OPTI_TYPE_ZERO_BYTE
9798 | OPTI_TYPE_PRECOMPUTE_INIT
9799 | OPTI_TYPE_NOT_ITERATED;
9800 dgst_pos0 = 0;
9801 dgst_pos1 = 1;
9802 dgst_pos2 = 2;
9803 dgst_pos3 = 3;
9804 break;
9805
9806 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9807 salt_type = SALT_TYPE_EMBEDDED;
9808 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9809 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9810 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9811 dgst_size = DGST_SIZE_4_4;
9812 parse_func = oldoffice34cm1_parse_hash;
9813 sort_by_digest = sort_by_digest_4_4;
9814 opti_type = OPTI_TYPE_ZERO_BYTE
9815 | OPTI_TYPE_PRECOMPUTE_INIT
9816 | OPTI_TYPE_NOT_ITERATED;
9817 dgst_pos0 = 0;
9818 dgst_pos1 = 1;
9819 dgst_pos2 = 2;
9820 dgst_pos3 = 3;
9821 break;
9822
9823 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9824 salt_type = SALT_TYPE_EMBEDDED;
9825 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9826 opts_type = OPTS_TYPE_PT_GENERATE_BE
9827 | OPTS_TYPE_PT_ADD80
9828 | OPTS_TYPE_PT_UNICODE
9829 | OPTS_TYPE_PT_NEVERCRACK;
9830 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9831 dgst_size = DGST_SIZE_4_4;
9832 parse_func = oldoffice34cm2_parse_hash;
9833 sort_by_digest = sort_by_digest_4_4;
9834 opti_type = OPTI_TYPE_ZERO_BYTE
9835 | OPTI_TYPE_PRECOMPUTE_INIT
9836 | OPTI_TYPE_NOT_ITERATED;
9837 dgst_pos0 = 0;
9838 dgst_pos1 = 1;
9839 dgst_pos2 = 2;
9840 dgst_pos3 = 3;
9841 break;
9842
9843 case 9900: hash_type = HASH_TYPE_MD5;
9844 salt_type = SALT_TYPE_NONE;
9845 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9846 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9847 kern_type = KERN_TYPE_RADMIN2;
9848 dgst_size = DGST_SIZE_4_4;
9849 parse_func = radmin2_parse_hash;
9850 sort_by_digest = sort_by_digest_4_4;
9851 opti_type = OPTI_TYPE_ZERO_BYTE
9852 | OPTI_TYPE_PRECOMPUTE_INIT
9853 | OPTI_TYPE_EARLY_SKIP
9854 | OPTI_TYPE_NOT_ITERATED
9855 | OPTI_TYPE_NOT_SALTED;
9856 dgst_pos0 = 0;
9857 dgst_pos1 = 3;
9858 dgst_pos2 = 2;
9859 dgst_pos3 = 1;
9860 break;
9861
9862 case 10000: hash_type = HASH_TYPE_SHA256;
9863 salt_type = SALT_TYPE_EMBEDDED;
9864 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9865 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9866 kern_type = KERN_TYPE_PBKDF2_SHA256;
9867 dgst_size = DGST_SIZE_4_32;
9868 parse_func = djangopbkdf2_parse_hash;
9869 sort_by_digest = sort_by_digest_4_32;
9870 opti_type = OPTI_TYPE_ZERO_BYTE
9871 | OPTI_TYPE_SLOW_HASH_SIMD;
9872 dgst_pos0 = 0;
9873 dgst_pos1 = 1;
9874 dgst_pos2 = 2;
9875 dgst_pos3 = 3;
9876 break;
9877
9878 case 10100: hash_type = HASH_TYPE_SIPHASH;
9879 salt_type = SALT_TYPE_EMBEDDED;
9880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9881 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9882 kern_type = KERN_TYPE_SIPHASH;
9883 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9884 parse_func = siphash_parse_hash;
9885 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9886 opti_type = OPTI_TYPE_ZERO_BYTE
9887 | OPTI_TYPE_NOT_ITERATED
9888 | OPTI_TYPE_RAW_HASH;
9889 dgst_pos0 = 0;
9890 dgst_pos1 = 1;
9891 dgst_pos2 = 2;
9892 dgst_pos3 = 3;
9893 break;
9894
9895 case 10200: hash_type = HASH_TYPE_MD5;
9896 salt_type = SALT_TYPE_EMBEDDED;
9897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9898 opts_type = OPTS_TYPE_PT_GENERATE_LE
9899 | OPTS_TYPE_ST_ADD80
9900 | OPTS_TYPE_ST_ADDBITS14;
9901 kern_type = KERN_TYPE_HMACMD5_PW;
9902 dgst_size = DGST_SIZE_4_4;
9903 parse_func = crammd5_parse_hash;
9904 sort_by_digest = sort_by_digest_4_4;
9905 opti_type = OPTI_TYPE_ZERO_BYTE
9906 | OPTI_TYPE_NOT_ITERATED;
9907 dgst_pos0 = 0;
9908 dgst_pos1 = 3;
9909 dgst_pos2 = 2;
9910 dgst_pos3 = 1;
9911 break;
9912
9913 case 10300: hash_type = HASH_TYPE_SHA1;
9914 salt_type = SALT_TYPE_EMBEDDED;
9915 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9916 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9917 kern_type = KERN_TYPE_SAPH_SHA1;
9918 dgst_size = DGST_SIZE_4_5;
9919 parse_func = saph_sha1_parse_hash;
9920 sort_by_digest = sort_by_digest_4_5;
9921 opti_type = OPTI_TYPE_ZERO_BYTE;
9922 dgst_pos0 = 0;
9923 dgst_pos1 = 1;
9924 dgst_pos2 = 2;
9925 dgst_pos3 = 3;
9926 break;
9927
9928 case 10400: hash_type = HASH_TYPE_PDFU16;
9929 salt_type = SALT_TYPE_EMBEDDED;
9930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9931 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9932 kern_type = KERN_TYPE_PDF11;
9933 dgst_size = DGST_SIZE_4_4;
9934 parse_func = pdf11_parse_hash;
9935 sort_by_digest = sort_by_digest_4_4;
9936 opti_type = OPTI_TYPE_ZERO_BYTE
9937 | OPTI_TYPE_NOT_ITERATED;
9938 dgst_pos0 = 0;
9939 dgst_pos1 = 1;
9940 dgst_pos2 = 2;
9941 dgst_pos3 = 3;
9942 break;
9943
9944 case 10410: hash_type = HASH_TYPE_PDFU16;
9945 salt_type = SALT_TYPE_EMBEDDED;
9946 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9947 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9948 kern_type = KERN_TYPE_PDF11CM1;
9949 dgst_size = DGST_SIZE_4_4;
9950 parse_func = pdf11cm1_parse_hash;
9951 sort_by_digest = sort_by_digest_4_4;
9952 opti_type = OPTI_TYPE_ZERO_BYTE
9953 | OPTI_TYPE_NOT_ITERATED;
9954 dgst_pos0 = 0;
9955 dgst_pos1 = 1;
9956 dgst_pos2 = 2;
9957 dgst_pos3 = 3;
9958 break;
9959
9960 case 10420: hash_type = HASH_TYPE_PDFU16;
9961 salt_type = SALT_TYPE_EMBEDDED;
9962 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9963 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9964 kern_type = KERN_TYPE_PDF11CM2;
9965 dgst_size = DGST_SIZE_4_4;
9966 parse_func = pdf11cm2_parse_hash;
9967 sort_by_digest = sort_by_digest_4_4;
9968 opti_type = OPTI_TYPE_ZERO_BYTE
9969 | OPTI_TYPE_NOT_ITERATED;
9970 dgst_pos0 = 0;
9971 dgst_pos1 = 1;
9972 dgst_pos2 = 2;
9973 dgst_pos3 = 3;
9974 break;
9975
9976 case 10500: hash_type = HASH_TYPE_PDFU16;
9977 salt_type = SALT_TYPE_EMBEDDED;
9978 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9979 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9980 kern_type = KERN_TYPE_PDF14;
9981 dgst_size = DGST_SIZE_4_4;
9982 parse_func = pdf14_parse_hash;
9983 sort_by_digest = sort_by_digest_4_4;
9984 opti_type = OPTI_TYPE_ZERO_BYTE
9985 | OPTI_TYPE_NOT_ITERATED;
9986 dgst_pos0 = 0;
9987 dgst_pos1 = 1;
9988 dgst_pos2 = 2;
9989 dgst_pos3 = 3;
9990 break;
9991
9992 case 10600: hash_type = HASH_TYPE_SHA256;
9993 salt_type = SALT_TYPE_EMBEDDED;
9994 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9995 opts_type = OPTS_TYPE_PT_GENERATE_BE
9996 | OPTS_TYPE_ST_ADD80
9997 | OPTS_TYPE_ST_ADDBITS15
9998 | OPTS_TYPE_HASH_COPY;
9999 kern_type = KERN_TYPE_SHA256_PWSLT;
10000 dgst_size = DGST_SIZE_4_8;
10001 parse_func = pdf17l3_parse_hash;
10002 sort_by_digest = sort_by_digest_4_8;
10003 opti_type = OPTI_TYPE_ZERO_BYTE
10004 | OPTI_TYPE_PRECOMPUTE_INIT
10005 | OPTI_TYPE_PRECOMPUTE_MERKLE
10006 | OPTI_TYPE_EARLY_SKIP
10007 | OPTI_TYPE_NOT_ITERATED
10008 | OPTI_TYPE_APPENDED_SALT
10009 | OPTI_TYPE_RAW_HASH;
10010 dgst_pos0 = 3;
10011 dgst_pos1 = 7;
10012 dgst_pos2 = 2;
10013 dgst_pos3 = 6;
10014 break;
10015
10016 case 10700: hash_type = HASH_TYPE_PDFU32;
10017 salt_type = SALT_TYPE_EMBEDDED;
10018 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10019 opts_type = OPTS_TYPE_PT_GENERATE_LE
10020 | OPTS_TYPE_HASH_COPY;
10021 kern_type = KERN_TYPE_PDF17L8;
10022 dgst_size = DGST_SIZE_4_8;
10023 parse_func = pdf17l8_parse_hash;
10024 sort_by_digest = sort_by_digest_4_8;
10025 opti_type = OPTI_TYPE_ZERO_BYTE
10026 | OPTI_TYPE_NOT_ITERATED;
10027 dgst_pos0 = 0;
10028 dgst_pos1 = 1;
10029 dgst_pos2 = 2;
10030 dgst_pos3 = 3;
10031 break;
10032
10033 case 10800: hash_type = HASH_TYPE_SHA384;
10034 salt_type = SALT_TYPE_NONE;
10035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10036 opts_type = OPTS_TYPE_PT_GENERATE_BE
10037 | OPTS_TYPE_PT_ADD80
10038 | OPTS_TYPE_PT_ADDBITS15;
10039 kern_type = KERN_TYPE_SHA384;
10040 dgst_size = DGST_SIZE_8_8;
10041 parse_func = sha384_parse_hash;
10042 sort_by_digest = sort_by_digest_8_8;
10043 opti_type = OPTI_TYPE_ZERO_BYTE
10044 | OPTI_TYPE_PRECOMPUTE_INIT
10045 | OPTI_TYPE_PRECOMPUTE_MERKLE
10046 | OPTI_TYPE_EARLY_SKIP
10047 | OPTI_TYPE_NOT_ITERATED
10048 | OPTI_TYPE_NOT_SALTED
10049 | OPTI_TYPE_USES_BITS_64
10050 | OPTI_TYPE_RAW_HASH;
10051 dgst_pos0 = 6;
10052 dgst_pos1 = 7;
10053 dgst_pos2 = 4;
10054 dgst_pos3 = 5;
10055 break;
10056
10057 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10058 salt_type = SALT_TYPE_EMBEDDED;
10059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10060 opts_type = OPTS_TYPE_PT_GENERATE_LE
10061 | OPTS_TYPE_ST_BASE64
10062 | OPTS_TYPE_HASH_COPY;
10063 kern_type = KERN_TYPE_PBKDF2_SHA256;
10064 dgst_size = DGST_SIZE_4_32;
10065 parse_func = pbkdf2_sha256_parse_hash;
10066 sort_by_digest = sort_by_digest_4_32;
10067 opti_type = OPTI_TYPE_ZERO_BYTE
10068 | OPTI_TYPE_SLOW_HASH_SIMD;
10069 dgst_pos0 = 0;
10070 dgst_pos1 = 1;
10071 dgst_pos2 = 2;
10072 dgst_pos3 = 3;
10073 break;
10074
10075 case 11000: hash_type = HASH_TYPE_MD5;
10076 salt_type = SALT_TYPE_INTERN;
10077 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10078 opts_type = OPTS_TYPE_PT_GENERATE_LE
10079 | OPTS_TYPE_PT_ADD80;
10080 kern_type = KERN_TYPE_PRESTASHOP;
10081 dgst_size = DGST_SIZE_4_4;
10082 parse_func = prestashop_parse_hash;
10083 sort_by_digest = sort_by_digest_4_4;
10084 opti_type = OPTI_TYPE_ZERO_BYTE
10085 | OPTI_TYPE_PRECOMPUTE_INIT
10086 | OPTI_TYPE_NOT_ITERATED
10087 | OPTI_TYPE_PREPENDED_SALT;
10088 dgst_pos0 = 0;
10089 dgst_pos1 = 3;
10090 dgst_pos2 = 2;
10091 dgst_pos3 = 1;
10092 break;
10093
10094 case 11100: hash_type = HASH_TYPE_MD5;
10095 salt_type = SALT_TYPE_EMBEDDED;
10096 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10097 opts_type = OPTS_TYPE_PT_GENERATE_LE
10098 | OPTS_TYPE_ST_ADD80;
10099 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10100 dgst_size = DGST_SIZE_4_4;
10101 parse_func = postgresql_auth_parse_hash;
10102 sort_by_digest = sort_by_digest_4_4;
10103 opti_type = OPTI_TYPE_ZERO_BYTE
10104 | OPTI_TYPE_PRECOMPUTE_INIT
10105 | OPTI_TYPE_PRECOMPUTE_MERKLE
10106 | OPTI_TYPE_EARLY_SKIP;
10107 dgst_pos0 = 0;
10108 dgst_pos1 = 3;
10109 dgst_pos2 = 2;
10110 dgst_pos3 = 1;
10111 break;
10112
10113 case 11200: hash_type = HASH_TYPE_SHA1;
10114 salt_type = SALT_TYPE_EMBEDDED;
10115 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10116 opts_type = OPTS_TYPE_PT_GENERATE_BE
10117 | OPTS_TYPE_PT_ADD80
10118 | OPTS_TYPE_ST_HEX;
10119 kern_type = KERN_TYPE_MYSQL_AUTH;
10120 dgst_size = DGST_SIZE_4_5;
10121 parse_func = mysql_auth_parse_hash;
10122 sort_by_digest = sort_by_digest_4_5;
10123 opti_type = OPTI_TYPE_ZERO_BYTE
10124 | OPTI_TYPE_EARLY_SKIP;
10125 dgst_pos0 = 3;
10126 dgst_pos1 = 4;
10127 dgst_pos2 = 2;
10128 dgst_pos3 = 1;
10129 break;
10130
10131 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10132 salt_type = SALT_TYPE_EMBEDDED;
10133 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10134 opts_type = OPTS_TYPE_PT_GENERATE_LE
10135 | OPTS_TYPE_ST_HEX
10136 | OPTS_TYPE_ST_ADD80;
10137 kern_type = KERN_TYPE_BITCOIN_WALLET;
10138 dgst_size = DGST_SIZE_4_4;
10139 parse_func = bitcoin_wallet_parse_hash;
10140 sort_by_digest = sort_by_digest_4_4;
10141 opti_type = OPTI_TYPE_ZERO_BYTE;
10142 dgst_pos0 = 0;
10143 dgst_pos1 = 1;
10144 dgst_pos2 = 2;
10145 dgst_pos3 = 3;
10146 break;
10147
10148 case 11400: hash_type = HASH_TYPE_MD5;
10149 salt_type = SALT_TYPE_EMBEDDED;
10150 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10151 opts_type = OPTS_TYPE_PT_GENERATE_LE
10152 | OPTS_TYPE_PT_ADD80
10153 | OPTS_TYPE_HASH_COPY;
10154 kern_type = KERN_TYPE_SIP_AUTH;
10155 dgst_size = DGST_SIZE_4_4;
10156 parse_func = sip_auth_parse_hash;
10157 sort_by_digest = sort_by_digest_4_4;
10158 opti_type = OPTI_TYPE_ZERO_BYTE;
10159 dgst_pos0 = 0;
10160 dgst_pos1 = 3;
10161 dgst_pos2 = 2;
10162 dgst_pos3 = 1;
10163 break;
10164
10165 case 11500: hash_type = HASH_TYPE_CRC32;
10166 salt_type = SALT_TYPE_INTERN;
10167 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10168 opts_type = OPTS_TYPE_PT_GENERATE_LE
10169 | OPTS_TYPE_ST_GENERATE_LE
10170 | OPTS_TYPE_ST_HEX;
10171 kern_type = KERN_TYPE_CRC32;
10172 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10173 parse_func = crc32_parse_hash;
10174 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10175 opti_type = OPTI_TYPE_ZERO_BYTE;
10176 dgst_pos0 = 0;
10177 dgst_pos1 = 1;
10178 dgst_pos2 = 2;
10179 dgst_pos3 = 3;
10180 break;
10181
10182 case 11600: hash_type = HASH_TYPE_AES;
10183 salt_type = SALT_TYPE_EMBEDDED;
10184 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10185 opts_type = OPTS_TYPE_PT_GENERATE_LE
10186 | OPTS_TYPE_PT_NEVERCRACK;
10187 kern_type = KERN_TYPE_SEVEN_ZIP;
10188 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10189 parse_func = seven_zip_parse_hash;
10190 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10191 opti_type = OPTI_TYPE_ZERO_BYTE;
10192 dgst_pos0 = 0;
10193 dgst_pos1 = 1;
10194 dgst_pos2 = 2;
10195 dgst_pos3 = 3;
10196 break;
10197
10198 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10199 salt_type = SALT_TYPE_NONE;
10200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10201 opts_type = OPTS_TYPE_PT_GENERATE_LE
10202 | OPTS_TYPE_PT_ADD01;
10203 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10204 dgst_size = DGST_SIZE_4_8;
10205 parse_func = gost2012sbog_256_parse_hash;
10206 sort_by_digest = sort_by_digest_4_8;
10207 opti_type = OPTI_TYPE_ZERO_BYTE;
10208 dgst_pos0 = 0;
10209 dgst_pos1 = 1;
10210 dgst_pos2 = 2;
10211 dgst_pos3 = 3;
10212 break;
10213
10214 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10215 salt_type = SALT_TYPE_NONE;
10216 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10217 opts_type = OPTS_TYPE_PT_GENERATE_LE
10218 | OPTS_TYPE_PT_ADD01;
10219 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10220 dgst_size = DGST_SIZE_4_16;
10221 parse_func = gost2012sbog_512_parse_hash;
10222 sort_by_digest = sort_by_digest_4_16;
10223 opti_type = OPTI_TYPE_ZERO_BYTE;
10224 dgst_pos0 = 0;
10225 dgst_pos1 = 1;
10226 dgst_pos2 = 2;
10227 dgst_pos3 = 3;
10228 break;
10229
10230 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10231 salt_type = SALT_TYPE_EMBEDDED;
10232 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10233 opts_type = OPTS_TYPE_PT_GENERATE_LE
10234 | OPTS_TYPE_ST_BASE64
10235 | OPTS_TYPE_HASH_COPY;
10236 kern_type = KERN_TYPE_PBKDF2_MD5;
10237 dgst_size = DGST_SIZE_4_32;
10238 parse_func = pbkdf2_md5_parse_hash;
10239 sort_by_digest = sort_by_digest_4_32;
10240 opti_type = OPTI_TYPE_ZERO_BYTE
10241 | OPTI_TYPE_SLOW_HASH_SIMD;
10242 dgst_pos0 = 0;
10243 dgst_pos1 = 1;
10244 dgst_pos2 = 2;
10245 dgst_pos3 = 3;
10246 break;
10247
10248 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10249 salt_type = SALT_TYPE_EMBEDDED;
10250 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10251 opts_type = OPTS_TYPE_PT_GENERATE_LE
10252 | OPTS_TYPE_ST_BASE64
10253 | OPTS_TYPE_HASH_COPY;
10254 kern_type = KERN_TYPE_PBKDF2_SHA1;
10255 dgst_size = DGST_SIZE_4_32;
10256 parse_func = pbkdf2_sha1_parse_hash;
10257 sort_by_digest = sort_by_digest_4_32;
10258 opti_type = OPTI_TYPE_ZERO_BYTE
10259 | OPTI_TYPE_SLOW_HASH_SIMD;
10260 dgst_pos0 = 0;
10261 dgst_pos1 = 1;
10262 dgst_pos2 = 2;
10263 dgst_pos3 = 3;
10264 break;
10265
10266 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10267 salt_type = SALT_TYPE_EMBEDDED;
10268 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10269 opts_type = OPTS_TYPE_PT_GENERATE_LE
10270 | OPTS_TYPE_ST_BASE64
10271 | OPTS_TYPE_HASH_COPY;
10272 kern_type = KERN_TYPE_PBKDF2_SHA512;
10273 dgst_size = DGST_SIZE_8_16;
10274 parse_func = pbkdf2_sha512_parse_hash;
10275 sort_by_digest = sort_by_digest_8_16;
10276 opti_type = OPTI_TYPE_ZERO_BYTE
10277 | OPTI_TYPE_USES_BITS_64
10278 | OPTI_TYPE_SLOW_HASH_SIMD;
10279 dgst_pos0 = 0;
10280 dgst_pos1 = 1;
10281 dgst_pos2 = 2;
10282 dgst_pos3 = 3;
10283 break;
10284
10285 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10286 salt_type = SALT_TYPE_EMBEDDED;
10287 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10288 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10289 kern_type = KERN_TYPE_ECRYPTFS;
10290 dgst_size = DGST_SIZE_8_8;
10291 parse_func = ecryptfs_parse_hash;
10292 sort_by_digest = sort_by_digest_8_8;
10293 opti_type = OPTI_TYPE_ZERO_BYTE
10294 | OPTI_TYPE_USES_BITS_64;
10295 dgst_pos0 = 0;
10296 dgst_pos1 = 1;
10297 dgst_pos2 = 2;
10298 dgst_pos3 = 3;
10299 break;
10300
10301 case 12300: hash_type = HASH_TYPE_ORACLET;
10302 salt_type = SALT_TYPE_EMBEDDED;
10303 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10304 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10305 kern_type = KERN_TYPE_ORACLET;
10306 dgst_size = DGST_SIZE_8_16;
10307 parse_func = oraclet_parse_hash;
10308 sort_by_digest = sort_by_digest_8_16;
10309 opti_type = OPTI_TYPE_ZERO_BYTE
10310 | OPTI_TYPE_USES_BITS_64;
10311 dgst_pos0 = 0;
10312 dgst_pos1 = 1;
10313 dgst_pos2 = 2;
10314 dgst_pos3 = 3;
10315 break;
10316
10317 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10318 salt_type = SALT_TYPE_EMBEDDED;
10319 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10320 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10321 kern_type = KERN_TYPE_BSDICRYPT;
10322 dgst_size = DGST_SIZE_4_4;
10323 parse_func = bsdicrypt_parse_hash;
10324 sort_by_digest = sort_by_digest_4_4;
10325 opti_type = OPTI_TYPE_ZERO_BYTE
10326 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10327 dgst_pos0 = 0;
10328 dgst_pos1 = 1;
10329 dgst_pos2 = 2;
10330 dgst_pos3 = 3;
10331 break;
10332
10333 case 12500: hash_type = HASH_TYPE_RAR3HP;
10334 salt_type = SALT_TYPE_EMBEDDED;
10335 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10336 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10337 kern_type = KERN_TYPE_RAR3;
10338 dgst_size = DGST_SIZE_4_4;
10339 parse_func = rar3hp_parse_hash;
10340 sort_by_digest = sort_by_digest_4_4;
10341 opti_type = OPTI_TYPE_ZERO_BYTE;
10342 dgst_pos0 = 0;
10343 dgst_pos1 = 1;
10344 dgst_pos2 = 2;
10345 dgst_pos3 = 3;
10346 break;
10347
10348 case 12600: hash_type = HASH_TYPE_SHA256;
10349 salt_type = SALT_TYPE_INTERN;
10350 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10351 opts_type = OPTS_TYPE_PT_GENERATE_BE
10352 | OPTS_TYPE_PT_ADD80;
10353 kern_type = KERN_TYPE_CF10;
10354 dgst_size = DGST_SIZE_4_8;
10355 parse_func = cf10_parse_hash;
10356 sort_by_digest = sort_by_digest_4_8;
10357 opti_type = OPTI_TYPE_ZERO_BYTE
10358 | OPTI_TYPE_PRECOMPUTE_INIT
10359 | OPTI_TYPE_EARLY_SKIP
10360 | OPTI_TYPE_NOT_ITERATED;
10361 dgst_pos0 = 3;
10362 dgst_pos1 = 7;
10363 dgst_pos2 = 2;
10364 dgst_pos3 = 6;
10365 break;
10366
10367 case 12700: hash_type = HASH_TYPE_AES;
10368 salt_type = SALT_TYPE_EMBEDDED;
10369 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10370 opts_type = OPTS_TYPE_PT_GENERATE_LE
10371 | OPTS_TYPE_HASH_COPY;
10372 kern_type = KERN_TYPE_MYWALLET;
10373 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10374 parse_func = mywallet_parse_hash;
10375 sort_by_digest = sort_by_digest_4_5;
10376 opti_type = OPTI_TYPE_ZERO_BYTE;
10377 dgst_pos0 = 0;
10378 dgst_pos1 = 1;
10379 dgst_pos2 = 2;
10380 dgst_pos3 = 3;
10381 break;
10382
10383 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10384 salt_type = SALT_TYPE_EMBEDDED;
10385 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10386 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10387 kern_type = KERN_TYPE_MS_DRSR;
10388 dgst_size = DGST_SIZE_4_8;
10389 parse_func = ms_drsr_parse_hash;
10390 sort_by_digest = sort_by_digest_4_8;
10391 opti_type = OPTI_TYPE_ZERO_BYTE;
10392 dgst_pos0 = 0;
10393 dgst_pos1 = 1;
10394 dgst_pos2 = 2;
10395 dgst_pos3 = 3;
10396 break;
10397
10398 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10399 salt_type = SALT_TYPE_EMBEDDED;
10400 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10401 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10402 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10403 dgst_size = DGST_SIZE_4_8;
10404 parse_func = androidfde_samsung_parse_hash;
10405 sort_by_digest = sort_by_digest_4_8;
10406 opti_type = OPTI_TYPE_ZERO_BYTE;
10407 dgst_pos0 = 0;
10408 dgst_pos1 = 1;
10409 dgst_pos2 = 2;
10410 dgst_pos3 = 3;
10411 break;
10412
10413 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10414 salt_type = SALT_TYPE_EMBEDDED;
10415 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10416 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10417 kern_type = KERN_TYPE_RAR5;
10418 dgst_size = DGST_SIZE_4_4;
10419 parse_func = rar5_parse_hash;
10420 sort_by_digest = sort_by_digest_4_4;
10421 opti_type = OPTI_TYPE_ZERO_BYTE;
10422 dgst_pos0 = 0;
10423 dgst_pos1 = 1;
10424 dgst_pos2 = 2;
10425 dgst_pos3 = 3;
10426 break;
10427
10428 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10429 salt_type = SALT_TYPE_EMBEDDED;
10430 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10431 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10432 kern_type = KERN_TYPE_KRB5TGS;
10433 dgst_size = DGST_SIZE_4_4;
10434 parse_func = krb5tgs_parse_hash;
10435 sort_by_digest = sort_by_digest_4_4;
10436 opti_type = OPTI_TYPE_ZERO_BYTE
10437 | OPTI_TYPE_NOT_ITERATED;
10438 dgst_pos0 = 0;
10439 dgst_pos1 = 1;
10440 dgst_pos2 = 2;
10441 dgst_pos3 = 3;
10442 break;
10443
10444 case 13200: hash_type = HASH_TYPE_AES;
10445 salt_type = SALT_TYPE_EMBEDDED;
10446 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10447 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10448 kern_type = KERN_TYPE_AXCRYPT;
10449 dgst_size = DGST_SIZE_4_4;
10450 parse_func = axcrypt_parse_hash;
10451 sort_by_digest = sort_by_digest_4_4;
10452 opti_type = OPTI_TYPE_ZERO_BYTE;
10453 dgst_pos0 = 0;
10454 dgst_pos1 = 1;
10455 dgst_pos2 = 2;
10456 dgst_pos3 = 3;
10457 break;
10458
10459 case 13300: hash_type = HASH_TYPE_SHA1;
10460 salt_type = SALT_TYPE_NONE;
10461 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10462 opts_type = OPTS_TYPE_PT_GENERATE_BE
10463 | OPTS_TYPE_PT_ADD80
10464 | OPTS_TYPE_PT_ADDBITS15;
10465 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10466 dgst_size = DGST_SIZE_4_5;
10467 parse_func = sha1axcrypt_parse_hash;
10468 sort_by_digest = sort_by_digest_4_5;
10469 opti_type = OPTI_TYPE_ZERO_BYTE
10470 | OPTI_TYPE_PRECOMPUTE_INIT
10471 | OPTI_TYPE_EARLY_SKIP
10472 | OPTI_TYPE_NOT_ITERATED
10473 | OPTI_TYPE_NOT_SALTED;
10474 dgst_pos0 = 0;
10475 dgst_pos1 = 4;
10476 dgst_pos2 = 3;
10477 dgst_pos3 = 2;
10478 break;
10479
10480 case 13400: hash_type = HASH_TYPE_AES;
10481 salt_type = SALT_TYPE_EMBEDDED;
10482 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10483 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10484 kern_type = KERN_TYPE_KEEPASS;
10485 dgst_size = DGST_SIZE_4_4;
10486 parse_func = keepass_parse_hash;
10487 sort_by_digest = sort_by_digest_4_4;
10488 opti_type = OPTI_TYPE_ZERO_BYTE;
10489 dgst_pos0 = 0;
10490 dgst_pos1 = 1;
10491 dgst_pos2 = 2;
10492 dgst_pos3 = 3;
10493 break;
10494
10495 case 13500: hash_type = HASH_TYPE_SHA1;
10496 salt_type = SALT_TYPE_EMBEDDED;
10497 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10498 opts_type = OPTS_TYPE_PT_GENERATE_BE
10499 | OPTS_TYPE_PT_UNICODE
10500 | OPTS_TYPE_PT_ADD80;
10501 kern_type = KERN_TYPE_PSTOKEN;
10502 dgst_size = DGST_SIZE_4_5;
10503 parse_func = pstoken_parse_hash;
10504 sort_by_digest = sort_by_digest_4_5;
10505 opti_type = OPTI_TYPE_ZERO_BYTE
10506 | OPTI_TYPE_PRECOMPUTE_INIT
10507 | OPTI_TYPE_EARLY_SKIP
10508 | OPTI_TYPE_NOT_ITERATED
10509 | OPTI_TYPE_PREPENDED_SALT
10510 | OPTI_TYPE_RAW_HASH;
10511 dgst_pos0 = 3;
10512 dgst_pos1 = 4;
10513 dgst_pos2 = 2;
10514 dgst_pos3 = 1;
10515 break;
10516
10517 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10518 salt_type = SALT_TYPE_EMBEDDED;
10519 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10520 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10521 kern_type = KERN_TYPE_ZIP2;
10522 dgst_size = DGST_SIZE_4_4;
10523 parse_func = zip2_parse_hash;
10524 sort_by_digest = sort_by_digest_4_4;
10525 opti_type = OPTI_TYPE_ZERO_BYTE;
10526 dgst_pos0 = 0;
10527 dgst_pos1 = 1;
10528 dgst_pos2 = 2;
10529 dgst_pos3 = 3;
10530 break;
10531
10532 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10533 salt_type = SALT_TYPE_EMBEDDED;
10534 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10535 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10536 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10537 dgst_size = DGST_SIZE_4_5;
10538 parse_func = veracrypt_parse_hash_655331;
10539 sort_by_digest = sort_by_digest_4_5;
10540 opti_type = OPTI_TYPE_ZERO_BYTE;
10541 dgst_pos0 = 0;
10542 dgst_pos1 = 1;
10543 dgst_pos2 = 2;
10544 dgst_pos3 = 3;
10545 break;
10546
10547 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10548 salt_type = SALT_TYPE_EMBEDDED;
10549 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10550 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10551 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10552 dgst_size = DGST_SIZE_4_5;
10553 parse_func = veracrypt_parse_hash_655331;
10554 sort_by_digest = sort_by_digest_4_5;
10555 opti_type = OPTI_TYPE_ZERO_BYTE;
10556 dgst_pos0 = 0;
10557 dgst_pos1 = 1;
10558 dgst_pos2 = 2;
10559 dgst_pos3 = 3;
10560 break;
10561
10562 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10563 salt_type = SALT_TYPE_EMBEDDED;
10564 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10565 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10566 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10567 dgst_size = DGST_SIZE_4_5;
10568 parse_func = veracrypt_parse_hash_655331;
10569 sort_by_digest = sort_by_digest_4_5;
10570 opti_type = OPTI_TYPE_ZERO_BYTE;
10571 dgst_pos0 = 0;
10572 dgst_pos1 = 1;
10573 dgst_pos2 = 2;
10574 dgst_pos3 = 3;
10575 break;
10576
10577 case 13721: hash_type = HASH_TYPE_SHA512;
10578 salt_type = SALT_TYPE_EMBEDDED;
10579 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10580 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10581 kern_type = KERN_TYPE_TCSHA512_XTS512;
10582 dgst_size = DGST_SIZE_8_8;
10583 parse_func = veracrypt_parse_hash_500000;
10584 sort_by_digest = sort_by_digest_8_8;
10585 opti_type = OPTI_TYPE_ZERO_BYTE
10586 | OPTI_TYPE_USES_BITS_64;
10587 dgst_pos0 = 0;
10588 dgst_pos1 = 1;
10589 dgst_pos2 = 2;
10590 dgst_pos3 = 3;
10591 break;
10592
10593 case 13722: hash_type = HASH_TYPE_SHA512;
10594 salt_type = SALT_TYPE_EMBEDDED;
10595 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10596 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10597 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10598 dgst_size = DGST_SIZE_8_8;
10599 parse_func = veracrypt_parse_hash_500000;
10600 sort_by_digest = sort_by_digest_8_8;
10601 opti_type = OPTI_TYPE_ZERO_BYTE
10602 | OPTI_TYPE_USES_BITS_64;
10603 dgst_pos0 = 0;
10604 dgst_pos1 = 1;
10605 dgst_pos2 = 2;
10606 dgst_pos3 = 3;
10607 break;
10608
10609 case 13723: hash_type = HASH_TYPE_SHA512;
10610 salt_type = SALT_TYPE_EMBEDDED;
10611 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10612 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10613 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10614 dgst_size = DGST_SIZE_8_8;
10615 parse_func = veracrypt_parse_hash_500000;
10616 sort_by_digest = sort_by_digest_8_8;
10617 opti_type = OPTI_TYPE_ZERO_BYTE
10618 | OPTI_TYPE_USES_BITS_64;
10619 dgst_pos0 = 0;
10620 dgst_pos1 = 1;
10621 dgst_pos2 = 2;
10622 dgst_pos3 = 3;
10623 break;
10624
10625 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10626 salt_type = SALT_TYPE_EMBEDDED;
10627 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10628 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10629 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10630 dgst_size = DGST_SIZE_4_8;
10631 parse_func = veracrypt_parse_hash_500000;
10632 sort_by_digest = sort_by_digest_4_8;
10633 opti_type = OPTI_TYPE_ZERO_BYTE;
10634 dgst_pos0 = 0;
10635 dgst_pos1 = 1;
10636 dgst_pos2 = 2;
10637 dgst_pos3 = 3;
10638 break;
10639
10640 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10641 salt_type = SALT_TYPE_EMBEDDED;
10642 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10643 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10644 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10645 dgst_size = DGST_SIZE_4_8;
10646 parse_func = veracrypt_parse_hash_500000;
10647 sort_by_digest = sort_by_digest_4_8;
10648 opti_type = OPTI_TYPE_ZERO_BYTE;
10649 dgst_pos0 = 0;
10650 dgst_pos1 = 1;
10651 dgst_pos2 = 2;
10652 dgst_pos3 = 3;
10653 break;
10654
10655 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10656 salt_type = SALT_TYPE_EMBEDDED;
10657 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10658 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10659 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10660 dgst_size = DGST_SIZE_4_8;
10661 parse_func = veracrypt_parse_hash_500000;
10662 sort_by_digest = sort_by_digest_4_8;
10663 opti_type = OPTI_TYPE_ZERO_BYTE;
10664 dgst_pos0 = 0;
10665 dgst_pos1 = 1;
10666 dgst_pos2 = 2;
10667 dgst_pos3 = 3;
10668 break;
10669
10670 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10671 salt_type = SALT_TYPE_EMBEDDED;
10672 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10673 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10674 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10675 dgst_size = DGST_SIZE_4_5;
10676 parse_func = veracrypt_parse_hash_327661;
10677 sort_by_digest = sort_by_digest_4_5;
10678 opti_type = OPTI_TYPE_ZERO_BYTE;
10679 dgst_pos0 = 0;
10680 dgst_pos1 = 1;
10681 dgst_pos2 = 2;
10682 dgst_pos3 = 3;
10683 break;
10684
10685 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10686 salt_type = SALT_TYPE_EMBEDDED;
10687 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10688 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10689 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10690 dgst_size = DGST_SIZE_4_5;
10691 parse_func = veracrypt_parse_hash_327661;
10692 sort_by_digest = sort_by_digest_4_5;
10693 opti_type = OPTI_TYPE_ZERO_BYTE;
10694 dgst_pos0 = 0;
10695 dgst_pos1 = 1;
10696 dgst_pos2 = 2;
10697 dgst_pos3 = 3;
10698 break;
10699
10700 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10701 salt_type = SALT_TYPE_EMBEDDED;
10702 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10703 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10704 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10705 dgst_size = DGST_SIZE_4_5;
10706 parse_func = veracrypt_parse_hash_327661;
10707 sort_by_digest = sort_by_digest_4_5;
10708 opti_type = OPTI_TYPE_ZERO_BYTE;
10709 dgst_pos0 = 0;
10710 dgst_pos1 = 1;
10711 dgst_pos2 = 2;
10712 dgst_pos3 = 3;
10713 break;
10714
10715 case 13751: hash_type = HASH_TYPE_SHA256;
10716 salt_type = SALT_TYPE_EMBEDDED;
10717 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10718 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10719 kern_type = KERN_TYPE_VCSHA256_XTS512;
10720 dgst_size = DGST_SIZE_4_8;
10721 parse_func = veracrypt_parse_hash_500000;
10722 sort_by_digest = sort_by_digest_4_8;
10723 opti_type = OPTI_TYPE_ZERO_BYTE;
10724 dgst_pos0 = 0;
10725 dgst_pos1 = 1;
10726 dgst_pos2 = 2;
10727 dgst_pos3 = 3;
10728 break;
10729
10730 case 13752: hash_type = HASH_TYPE_SHA256;
10731 salt_type = SALT_TYPE_EMBEDDED;
10732 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10733 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10734 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10735 dgst_size = DGST_SIZE_4_8;
10736 parse_func = veracrypt_parse_hash_500000;
10737 sort_by_digest = sort_by_digest_4_8;
10738 opti_type = OPTI_TYPE_ZERO_BYTE;
10739 dgst_pos0 = 0;
10740 dgst_pos1 = 1;
10741 dgst_pos2 = 2;
10742 dgst_pos3 = 3;
10743 break;
10744
10745 case 13753: hash_type = HASH_TYPE_SHA256;
10746 salt_type = SALT_TYPE_EMBEDDED;
10747 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10748 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10749 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10750 dgst_size = DGST_SIZE_4_8;
10751 parse_func = veracrypt_parse_hash_500000;
10752 sort_by_digest = sort_by_digest_4_8;
10753 opti_type = OPTI_TYPE_ZERO_BYTE;
10754 dgst_pos0 = 0;
10755 dgst_pos1 = 1;
10756 dgst_pos2 = 2;
10757 dgst_pos3 = 3;
10758 break;
10759
10760 case 13761: hash_type = HASH_TYPE_SHA256;
10761 salt_type = SALT_TYPE_EMBEDDED;
10762 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10763 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10764 kern_type = KERN_TYPE_VCSHA256_XTS512;
10765 dgst_size = DGST_SIZE_4_8;
10766 parse_func = veracrypt_parse_hash_200000;
10767 sort_by_digest = sort_by_digest_4_8;
10768 opti_type = OPTI_TYPE_ZERO_BYTE;
10769 dgst_pos0 = 0;
10770 dgst_pos1 = 1;
10771 dgst_pos2 = 2;
10772 dgst_pos3 = 3;
10773 break;
10774
10775 case 13762: hash_type = HASH_TYPE_SHA256;
10776 salt_type = SALT_TYPE_EMBEDDED;
10777 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10778 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10779 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10780 dgst_size = DGST_SIZE_4_8;
10781 parse_func = veracrypt_parse_hash_200000;
10782 sort_by_digest = sort_by_digest_4_8;
10783 opti_type = OPTI_TYPE_ZERO_BYTE;
10784 dgst_pos0 = 0;
10785 dgst_pos1 = 1;
10786 dgst_pos2 = 2;
10787 dgst_pos3 = 3;
10788 break;
10789
10790 case 13763: hash_type = HASH_TYPE_SHA256;
10791 salt_type = SALT_TYPE_EMBEDDED;
10792 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10793 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10794 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10795 dgst_size = DGST_SIZE_4_8;
10796 parse_func = veracrypt_parse_hash_200000;
10797 sort_by_digest = sort_by_digest_4_8;
10798 opti_type = OPTI_TYPE_ZERO_BYTE;
10799 dgst_pos0 = 0;
10800 dgst_pos1 = 1;
10801 dgst_pos2 = 2;
10802 dgst_pos3 = 3;
10803 break;
10804
10805
10806 default: usage_mini_print (PROGNAME); return (-1);
10807 }
10808
10809 /**
10810 * parser
10811 */
10812
10813 data.parse_func = parse_func;
10814
10815 /**
10816 * misc stuff
10817 */
10818
10819 if (hex_salt)
10820 {
10821 if (salt_type == SALT_TYPE_INTERN)
10822 {
10823 opts_type |= OPTS_TYPE_ST_HEX;
10824 }
10825 else
10826 {
10827 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10828
10829 return (-1);
10830 }
10831 }
10832
10833 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10834 | (salt_type == SALT_TYPE_EXTERN)
10835 | (salt_type == SALT_TYPE_EMBEDDED)
10836 | (salt_type == SALT_TYPE_VIRTUAL));
10837
10838 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10839
10840 data.hash_type = hash_type;
10841 data.attack_mode = attack_mode;
10842 data.attack_kern = attack_kern;
10843 data.attack_exec = attack_exec;
10844 data.kern_type = kern_type;
10845 data.opts_type = opts_type;
10846 data.dgst_size = dgst_size;
10847 data.salt_type = salt_type;
10848 data.isSalted = isSalted;
10849 data.sort_by_digest = sort_by_digest;
10850 data.dgst_pos0 = dgst_pos0;
10851 data.dgst_pos1 = dgst_pos1;
10852 data.dgst_pos2 = dgst_pos2;
10853 data.dgst_pos3 = dgst_pos3;
10854
10855 esalt_size = 0;
10856
10857 switch (hash_mode)
10858 {
10859 case 2500: esalt_size = sizeof (wpa_t); break;
10860 case 5300: esalt_size = sizeof (ikepsk_t); break;
10861 case 5400: esalt_size = sizeof (ikepsk_t); break;
10862 case 5500: esalt_size = sizeof (netntlm_t); break;
10863 case 5600: esalt_size = sizeof (netntlm_t); break;
10864 case 6211: esalt_size = sizeof (tc_t); break;
10865 case 6212: esalt_size = sizeof (tc_t); break;
10866 case 6213: esalt_size = sizeof (tc_t); break;
10867 case 6221: esalt_size = sizeof (tc_t); break;
10868 case 6222: esalt_size = sizeof (tc_t); break;
10869 case 6223: esalt_size = sizeof (tc_t); break;
10870 case 6231: esalt_size = sizeof (tc_t); break;
10871 case 6232: esalt_size = sizeof (tc_t); break;
10872 case 6233: esalt_size = sizeof (tc_t); break;
10873 case 6241: esalt_size = sizeof (tc_t); break;
10874 case 6242: esalt_size = sizeof (tc_t); break;
10875 case 6243: esalt_size = sizeof (tc_t); break;
10876 case 6600: esalt_size = sizeof (agilekey_t); break;
10877 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10878 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10879 case 7300: esalt_size = sizeof (rakp_t); break;
10880 case 7500: esalt_size = sizeof (krb5pa_t); break;
10881 case 8200: esalt_size = sizeof (cloudkey_t); break;
10882 case 8800: esalt_size = sizeof (androidfde_t); break;
10883 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10884 case 9400: esalt_size = sizeof (office2007_t); break;
10885 case 9500: esalt_size = sizeof (office2010_t); break;
10886 case 9600: esalt_size = sizeof (office2013_t); break;
10887 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10888 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10889 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10890 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10891 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10892 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10893 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10894 case 10200: esalt_size = sizeof (cram_md5_t); break;
10895 case 10400: esalt_size = sizeof (pdf_t); break;
10896 case 10410: esalt_size = sizeof (pdf_t); break;
10897 case 10420: esalt_size = sizeof (pdf_t); break;
10898 case 10500: esalt_size = sizeof (pdf_t); break;
10899 case 10600: esalt_size = sizeof (pdf_t); break;
10900 case 10700: esalt_size = sizeof (pdf_t); break;
10901 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10902 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10903 case 11400: esalt_size = sizeof (sip_t); break;
10904 case 11600: esalt_size = sizeof (seven_zip_t); break;
10905 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10906 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10907 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10908 case 13000: esalt_size = sizeof (rar5_t); break;
10909 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10910 case 13400: esalt_size = sizeof (keepass_t); break;
10911 case 13500: esalt_size = sizeof (pstoken_t); break;
10912 case 13600: esalt_size = sizeof (zip2_t); break;
10913 case 13711: esalt_size = sizeof (tc_t); break;
10914 case 13712: esalt_size = sizeof (tc_t); break;
10915 case 13713: esalt_size = sizeof (tc_t); break;
10916 case 13721: esalt_size = sizeof (tc_t); break;
10917 case 13722: esalt_size = sizeof (tc_t); break;
10918 case 13723: esalt_size = sizeof (tc_t); break;
10919 case 13731: esalt_size = sizeof (tc_t); break;
10920 case 13732: esalt_size = sizeof (tc_t); break;
10921 case 13733: esalt_size = sizeof (tc_t); break;
10922 case 13741: esalt_size = sizeof (tc_t); break;
10923 case 13742: esalt_size = sizeof (tc_t); break;
10924 case 13743: esalt_size = sizeof (tc_t); break;
10925 case 13751: esalt_size = sizeof (tc_t); break;
10926 case 13752: esalt_size = sizeof (tc_t); break;
10927 case 13753: esalt_size = sizeof (tc_t); break;
10928 case 13761: esalt_size = sizeof (tc_t); break;
10929 case 13762: esalt_size = sizeof (tc_t); break;
10930 case 13763: esalt_size = sizeof (tc_t); break;
10931 }
10932
10933 data.esalt_size = esalt_size;
10934
10935 /**
10936 * choose dictionary parser
10937 */
10938
10939 if (hash_type == HASH_TYPE_LM)
10940 {
10941 get_next_word_func = get_next_word_lm;
10942 }
10943 else if (opts_type & OPTS_TYPE_PT_UPPER)
10944 {
10945 get_next_word_func = get_next_word_uc;
10946 }
10947 else
10948 {
10949 get_next_word_func = get_next_word_std;
10950 }
10951
10952 /**
10953 * dictstat
10954 */
10955
10956 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10957
10958 #ifdef _POSIX
10959 size_t dictstat_nmemb = 0;
10960 #endif
10961
10962 #ifdef _WIN
10963 uint dictstat_nmemb = 0;
10964 #endif
10965
10966 char dictstat[256] = { 0 };
10967
10968 FILE *dictstat_fp = NULL;
10969
10970 if (keyspace == 0)
10971 {
10972 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10973
10974 dictstat_fp = fopen (dictstat, "rb");
10975
10976 if (dictstat_fp)
10977 {
10978 #ifdef _POSIX
10979 struct stat tmpstat;
10980
10981 fstat (fileno (dictstat_fp), &tmpstat);
10982 #endif
10983
10984 #ifdef _WIN
10985 struct stat64 tmpstat;
10986
10987 _fstat64 (fileno (dictstat_fp), &tmpstat);
10988 #endif
10989
10990 if (tmpstat.st_mtime < COMPTIME)
10991 {
10992 /* with v0.15 the format changed so we have to ensure user is using a good version
10993 since there is no version-header in the dictstat file */
10994
10995 fclose (dictstat_fp);
10996
10997 unlink (dictstat);
10998 }
10999 else
11000 {
11001 while (!feof (dictstat_fp))
11002 {
11003 dictstat_t d;
11004
11005 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11006
11007 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11008
11009 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11010 {
11011 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11012
11013 return -1;
11014 }
11015 }
11016
11017 fclose (dictstat_fp);
11018 }
11019 }
11020 }
11021
11022 /**
11023 * potfile
11024 */
11025
11026 char potfile[256] = { 0 };
11027
11028 if (potfile_path == NULL)
11029 {
11030 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11031 }
11032 else
11033 {
11034 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11035 }
11036
11037 data.pot_fp = NULL;
11038
11039 FILE *out_fp = NULL;
11040 FILE *pot_fp = NULL;
11041
11042 if (show == 1 || left == 1)
11043 {
11044 pot_fp = fopen (potfile, "rb");
11045
11046 if (pot_fp == NULL)
11047 {
11048 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11049
11050 return (-1);
11051 }
11052
11053 if (outfile != NULL)
11054 {
11055 if ((out_fp = fopen (outfile, "ab")) == NULL)
11056 {
11057 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11058
11059 fclose (pot_fp);
11060
11061 return (-1);
11062 }
11063 }
11064 else
11065 {
11066 out_fp = stdout;
11067 }
11068 }
11069 else
11070 {
11071 if (potfile_disable == 0)
11072 {
11073 pot_fp = fopen (potfile, "ab");
11074
11075 if (pot_fp == NULL)
11076 {
11077 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11078
11079 return (-1);
11080 }
11081
11082 data.pot_fp = pot_fp;
11083 }
11084 }
11085
11086 pot_t *pot = NULL;
11087
11088 uint pot_cnt = 0;
11089 uint pot_avail = 0;
11090
11091 if (show == 1 || left == 1)
11092 {
11093 SUPPRESS_OUTPUT = 1;
11094
11095 pot_avail = count_lines (pot_fp);
11096
11097 rewind (pot_fp);
11098
11099 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11100
11101 uint pot_hashes_avail = 0;
11102
11103 uint line_num = 0;
11104
11105 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11106
11107 while (!feof (pot_fp))
11108 {
11109 line_num++;
11110
11111 int line_len = fgetl (pot_fp, line_buf);
11112
11113 if (line_len == 0) continue;
11114
11115 char *plain_buf = line_buf + line_len;
11116
11117 pot_t *pot_ptr = &pot[pot_cnt];
11118
11119 hash_t *hashes_buf = &pot_ptr->hash;
11120
11121 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11122 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11123
11124 if (pot_cnt == pot_hashes_avail)
11125 {
11126 uint pos = 0;
11127
11128 for (pos = 0; pos < INCR_POT; pos++)
11129 {
11130 if ((pot_cnt + pos) >= pot_avail) break;
11131
11132 pot_t *tmp_pot = &pot[pot_cnt + pos];
11133
11134 hash_t *tmp_hash = &tmp_pot->hash;
11135
11136 tmp_hash->digest = mymalloc (dgst_size);
11137
11138 if (isSalted)
11139 {
11140 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11141 }
11142
11143 if (esalt_size)
11144 {
11145 tmp_hash->esalt = mymalloc (esalt_size);
11146 }
11147
11148 pot_hashes_avail++;
11149 }
11150 }
11151
11152 int plain_len = 0;
11153
11154 int parser_status;
11155
11156 int iter = MAX_CUT_TRIES;
11157
11158 do
11159 {
11160 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11161 {
11162 if (line_buf[i] == ':')
11163 {
11164 line_len--;
11165
11166 break;
11167 }
11168 }
11169
11170 if (data.hash_mode != 2500)
11171 {
11172 parser_status = parse_func (line_buf, line_len, hashes_buf);
11173 }
11174 else
11175 {
11176 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11177
11178 if (line_len > max_salt_size)
11179 {
11180 parser_status = PARSER_GLOBAL_LENGTH;
11181 }
11182 else
11183 {
11184 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11185
11186 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11187
11188 hashes_buf->salt->salt_len = line_len;
11189
11190 parser_status = PARSER_OK;
11191 }
11192 }
11193
11194 // if NOT parsed without error, we add the ":" to the plain
11195
11196 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11197 {
11198 plain_len++;
11199 plain_buf--;
11200 }
11201
11202 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11203
11204 if (parser_status < PARSER_GLOBAL_ZERO)
11205 {
11206 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11207
11208 continue;
11209 }
11210
11211 if (plain_len >= 255) continue;
11212
11213 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11214
11215 pot_ptr->plain_len = plain_len;
11216
11217 pot_cnt++;
11218 }
11219
11220 myfree (line_buf);
11221
11222 fclose (pot_fp);
11223
11224 SUPPRESS_OUTPUT = 0;
11225
11226 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11227 }
11228
11229 /**
11230 * word len
11231 */
11232
11233 uint pw_min = PW_MIN;
11234 uint pw_max = PW_MAX;
11235
11236 switch (hash_mode)
11237 {
11238 case 125: if (pw_max > 32) pw_max = 32;
11239 break;
11240 case 400: if (pw_max > 40) pw_max = 40;
11241 break;
11242 case 500: if (pw_max > 16) pw_max = 16;
11243 break;
11244 case 1500: if (pw_max > 8) pw_max = 8;
11245 break;
11246 case 1600: if (pw_max > 16) pw_max = 16;
11247 break;
11248 case 1800: if (pw_max > 16) pw_max = 16;
11249 break;
11250 case 2100: if (pw_max > 16) pw_max = 16;
11251 break;
11252 case 2500: if (pw_min < 8) pw_min = 8;
11253 break;
11254 case 3000: if (pw_max > 7) pw_max = 7;
11255 break;
11256 case 5200: if (pw_max > 24) pw_max = 24;
11257 break;
11258 case 5800: if (pw_max > 16) pw_max = 16;
11259 break;
11260 case 6300: if (pw_max > 16) pw_max = 16;
11261 break;
11262 case 7400: if (pw_max > 16) pw_max = 16;
11263 break;
11264 case 7500: if (pw_max > 8) pw_max = 8;
11265 break;
11266 case 7900: if (pw_max > 48) pw_max = 48;
11267 break;
11268 case 8500: if (pw_max > 8) pw_max = 8;
11269 break;
11270 case 8600: if (pw_max > 16) pw_max = 16;
11271 break;
11272 case 9710: pw_min = 5;
11273 pw_max = 5;
11274 break;
11275 case 9810: pw_min = 5;
11276 pw_max = 5;
11277 break;
11278 case 10410: pw_min = 5;
11279 pw_max = 5;
11280 break;
11281 case 10300: if (pw_max < 3) pw_min = 3;
11282 if (pw_max > 40) pw_max = 40;
11283 break;
11284 case 10500: if (pw_max < 3) pw_min = 3;
11285 if (pw_max > 40) pw_max = 40;
11286 break;
11287 case 10700: if (pw_max > 16) pw_max = 16;
11288 break;
11289 case 11300: if (pw_max > 40) pw_max = 40;
11290 break;
11291 case 11600: if (pw_max > 32) pw_max = 32;
11292 break;
11293 case 12500: if (pw_max > 20) pw_max = 20;
11294 break;
11295 case 12800: if (pw_max > 24) pw_max = 24;
11296 break;
11297 }
11298
11299 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11300 {
11301 switch (attack_kern)
11302 {
11303 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11304 break;
11305 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11306 break;
11307 }
11308 }
11309
11310 /**
11311 * charsets : keep them together for more easy maintainnce
11312 */
11313
11314 cs_t mp_sys[6] = { { { 0 }, 0 } };
11315 cs_t mp_usr[4] = { { { 0 }, 0 } };
11316
11317 mp_setup_sys (mp_sys);
11318
11319 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11320 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11321 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11322 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11323
11324 /**
11325 * load hashes, part I: find input mode, count hashes
11326 */
11327
11328 uint hashlist_mode = 0;
11329 uint hashlist_format = HLFMT_HASHCAT;
11330
11331 uint hashes_avail = 0;
11332
11333 if (benchmark == 0)
11334 {
11335 struct stat f;
11336
11337 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11338
11339 if ((hash_mode == 2500) ||
11340 (hash_mode == 5200) ||
11341 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11342 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11343 (hash_mode == 9000))
11344 {
11345 hashlist_mode = HL_MODE_ARG;
11346
11347 char *hashfile = myargv[optind];
11348
11349 data.hashfile = hashfile;
11350
11351 logfile_top_var_string ("target", hashfile);
11352 }
11353
11354 if (hashlist_mode == HL_MODE_ARG)
11355 {
11356 if (hash_mode == 2500)
11357 {
11358 struct stat st;
11359
11360 if (stat (data.hashfile, &st) == -1)
11361 {
11362 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11363
11364 return (-1);
11365 }
11366
11367 hashes_avail = st.st_size / sizeof (hccap_t);
11368 }
11369 else
11370 {
11371 hashes_avail = 1;
11372 }
11373 }
11374 else if (hashlist_mode == HL_MODE_FILE)
11375 {
11376 char *hashfile = myargv[optind];
11377
11378 data.hashfile = hashfile;
11379
11380 logfile_top_var_string ("target", hashfile);
11381
11382 FILE *fp = NULL;
11383
11384 if ((fp = fopen (hashfile, "rb")) == NULL)
11385 {
11386 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11387
11388 return (-1);
11389 }
11390
11391 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11392
11393 hashes_avail = count_lines (fp);
11394
11395 rewind (fp);
11396
11397 if (hashes_avail == 0)
11398 {
11399 log_error ("ERROR: hashfile is empty or corrupt");
11400
11401 fclose (fp);
11402
11403 return (-1);
11404 }
11405
11406 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11407
11408 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11409 {
11410 log_error ("ERROR: remove not supported in native hashfile-format mode");
11411
11412 fclose (fp);
11413
11414 return (-1);
11415 }
11416
11417 fclose (fp);
11418 }
11419 }
11420 else
11421 {
11422 hashlist_mode = HL_MODE_ARG;
11423
11424 hashes_avail = 1;
11425 }
11426
11427 if (hash_mode == 3000) hashes_avail *= 2;
11428
11429 data.hashlist_mode = hashlist_mode;
11430 data.hashlist_format = hashlist_format;
11431
11432 logfile_top_uint (hashlist_mode);
11433 logfile_top_uint (hashlist_format);
11434
11435 /**
11436 * load hashes, part II: allocate required memory, set pointers
11437 */
11438
11439 hash_t *hashes_buf = NULL;
11440 void *digests_buf = NULL;
11441 salt_t *salts_buf = NULL;
11442 void *esalts_buf = NULL;
11443
11444 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11445
11446 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11447
11448 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11449 {
11450 u32 hash_pos;
11451
11452 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11453 {
11454 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11455
11456 hashes_buf[hash_pos].hash_info = hash_info;
11457
11458 if (username && (remove || show || left))
11459 {
11460 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11461 }
11462
11463 if (benchmark)
11464 {
11465 hash_info->orighash = (char *) mymalloc (256);
11466 }
11467 }
11468 }
11469
11470 if (isSalted)
11471 {
11472 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11473
11474 if (esalt_size)
11475 {
11476 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11477 }
11478 }
11479 else
11480 {
11481 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11482 }
11483
11484 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11485 {
11486 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11487
11488 if (isSalted)
11489 {
11490 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11491
11492 if (esalt_size)
11493 {
11494 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11495 }
11496 }
11497 else
11498 {
11499 hashes_buf[hash_pos].salt = &salts_buf[0];
11500 }
11501 }
11502
11503 /**
11504 * load hashes, part III: parse hashes or generate them if benchmark
11505 */
11506
11507 uint hashes_cnt = 0;
11508
11509 if (benchmark == 0)
11510 {
11511 if (keyspace == 1)
11512 {
11513 // useless to read hash file for keyspace, cheat a little bit w/ optind
11514 }
11515 else if (hashes_avail == 0)
11516 {
11517 }
11518 else if (hashlist_mode == HL_MODE_ARG)
11519 {
11520 char *input_buf = myargv[optind];
11521
11522 uint input_len = strlen (input_buf);
11523
11524 logfile_top_var_string ("target", input_buf);
11525
11526 char *hash_buf = NULL;
11527 int hash_len = 0;
11528
11529 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11530
11531 bool hash_fmt_error = 0;
11532
11533 if (hash_len < 1) hash_fmt_error = 1;
11534 if (hash_buf == NULL) hash_fmt_error = 1;
11535
11536 if (hash_fmt_error)
11537 {
11538 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11539 }
11540 else
11541 {
11542 if (opts_type & OPTS_TYPE_HASH_COPY)
11543 {
11544 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11545
11546 hash_info_tmp->orighash = mystrdup (hash_buf);
11547 }
11548
11549 if (isSalted)
11550 {
11551 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11552 }
11553
11554 int parser_status = PARSER_OK;
11555
11556 if (hash_mode == 2500)
11557 {
11558 if (hash_len == 0)
11559 {
11560 log_error ("ERROR: hccap file not specified");
11561
11562 return (-1);
11563 }
11564
11565 hashlist_mode = HL_MODE_FILE;
11566
11567 data.hashlist_mode = hashlist_mode;
11568
11569 FILE *fp = fopen (hash_buf, "rb");
11570
11571 if (fp == NULL)
11572 {
11573 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11574
11575 return (-1);
11576 }
11577
11578 if (hashes_avail < 1)
11579 {
11580 log_error ("ERROR: hccap file is empty or corrupt");
11581
11582 fclose (fp);
11583
11584 return (-1);
11585 }
11586
11587 uint hccap_size = sizeof (hccap_t);
11588
11589 char *in = (char *) mymalloc (hccap_size);
11590
11591 while (!feof (fp))
11592 {
11593 int n = fread (in, hccap_size, 1, fp);
11594
11595 if (n != 1)
11596 {
11597 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11598
11599 break;
11600 }
11601
11602 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11603
11604 if (parser_status != PARSER_OK)
11605 {
11606 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11607
11608 continue;
11609 }
11610
11611 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11612
11613 if ((show == 1) || (left == 1))
11614 {
11615 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11616
11617 char *salt_ptr = (char *) tmp_salt->salt_buf;
11618
11619 int cur_pos = tmp_salt->salt_len;
11620 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11621
11622 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11623
11624 // do the appending task
11625
11626 snprintf (salt_ptr + cur_pos,
11627 rem_len,
11628 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11629 wpa->orig_mac1[0],
11630 wpa->orig_mac1[1],
11631 wpa->orig_mac1[2],
11632 wpa->orig_mac1[3],
11633 wpa->orig_mac1[4],
11634 wpa->orig_mac1[5],
11635 wpa->orig_mac2[0],
11636 wpa->orig_mac2[1],
11637 wpa->orig_mac2[2],
11638 wpa->orig_mac2[3],
11639 wpa->orig_mac2[4],
11640 wpa->orig_mac2[5]);
11641
11642 // memset () the remaining part of the salt
11643
11644 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11645 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11646
11647 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11648
11649 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11650 }
11651
11652 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);
11653 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);
11654
11655 hashes_cnt++;
11656 }
11657
11658 fclose (fp);
11659
11660 myfree (in);
11661 }
11662 else if (hash_mode == 3000)
11663 {
11664 if (hash_len == 32)
11665 {
11666 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11667
11668 hash_t *lm_hash_left = NULL;
11669
11670 if (parser_status == PARSER_OK)
11671 {
11672 lm_hash_left = &hashes_buf[hashes_cnt];
11673
11674 hashes_cnt++;
11675 }
11676 else
11677 {
11678 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11679 }
11680
11681 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11682
11683 hash_t *lm_hash_right = NULL;
11684
11685 if (parser_status == PARSER_OK)
11686 {
11687 lm_hash_right = &hashes_buf[hashes_cnt];
11688
11689 hashes_cnt++;
11690 }
11691 else
11692 {
11693 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11694 }
11695
11696 // show / left
11697
11698 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11699 {
11700 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);
11701 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);
11702 }
11703 }
11704 else
11705 {
11706 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11707
11708 if (parser_status == PARSER_OK)
11709 {
11710 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11711 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11712 }
11713
11714 if (parser_status == PARSER_OK)
11715 {
11716 hashes_cnt++;
11717 }
11718 else
11719 {
11720 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11721 }
11722 }
11723 }
11724 else
11725 {
11726 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11727
11728 if (parser_status == PARSER_OK)
11729 {
11730 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11731 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11732 }
11733
11734 if (parser_status == PARSER_OK)
11735 {
11736 hashes_cnt++;
11737 }
11738 else
11739 {
11740 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11741 }
11742 }
11743 }
11744 }
11745 else if (hashlist_mode == HL_MODE_FILE)
11746 {
11747 char *hashfile = data.hashfile;
11748
11749 FILE *fp;
11750
11751 if ((fp = fopen (hashfile, "rb")) == NULL)
11752 {
11753 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11754
11755 return (-1);
11756 }
11757
11758 uint line_num = 0;
11759
11760 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11761
11762 while (!feof (fp))
11763 {
11764 line_num++;
11765
11766 int line_len = fgetl (fp, line_buf);
11767
11768 if (line_len == 0) continue;
11769
11770 char *hash_buf = NULL;
11771 int hash_len = 0;
11772
11773 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11774
11775 bool hash_fmt_error = 0;
11776
11777 if (hash_len < 1) hash_fmt_error = 1;
11778 if (hash_buf == NULL) hash_fmt_error = 1;
11779
11780 if (hash_fmt_error)
11781 {
11782 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11783
11784 continue;
11785 }
11786
11787 if (username)
11788 {
11789 char *user_buf = NULL;
11790 int user_len = 0;
11791
11792 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11793
11794 if (remove || show)
11795 {
11796 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11797
11798 *user = (user_t *) mymalloc (sizeof (user_t));
11799
11800 user_t *user_ptr = *user;
11801
11802 if (user_buf != NULL)
11803 {
11804 user_ptr->user_name = mystrdup (user_buf);
11805 }
11806 else
11807 {
11808 user_ptr->user_name = mystrdup ("");
11809 }
11810
11811 user_ptr->user_len = user_len;
11812 }
11813 }
11814
11815 if (opts_type & OPTS_TYPE_HASH_COPY)
11816 {
11817 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11818
11819 hash_info_tmp->orighash = mystrdup (hash_buf);
11820 }
11821
11822 if (isSalted)
11823 {
11824 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11825 }
11826
11827 if (hash_mode == 3000)
11828 {
11829 if (hash_len == 32)
11830 {
11831 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11832
11833 if (parser_status < PARSER_GLOBAL_ZERO)
11834 {
11835 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11836
11837 continue;
11838 }
11839
11840 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11841
11842 hashes_cnt++;
11843
11844 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11845
11846 if (parser_status < PARSER_GLOBAL_ZERO)
11847 {
11848 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11849
11850 continue;
11851 }
11852
11853 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11854
11855 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);
11856
11857 hashes_cnt++;
11858
11859 // show / left
11860
11861 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);
11862 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);
11863 }
11864 else
11865 {
11866 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11867
11868 if (parser_status < PARSER_GLOBAL_ZERO)
11869 {
11870 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11871
11872 continue;
11873 }
11874
11875 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);
11876
11877 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11878 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11879
11880 hashes_cnt++;
11881 }
11882 }
11883 else
11884 {
11885 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11886
11887 if (parser_status < PARSER_GLOBAL_ZERO)
11888 {
11889 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11890
11891 continue;
11892 }
11893
11894 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);
11895
11896 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11897 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11898
11899 hashes_cnt++;
11900 }
11901 }
11902
11903 myfree (line_buf);
11904
11905 fclose (fp);
11906
11907 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11908
11909 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11910 }
11911 }
11912 else
11913 {
11914 if (isSalted)
11915 {
11916 hashes_buf[0].salt->salt_len = 8;
11917
11918 // special salt handling
11919
11920 switch (hash_mode)
11921 {
11922 case 1500: hashes_buf[0].salt->salt_len = 2;
11923 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11924 break;
11925 case 1731: hashes_buf[0].salt->salt_len = 4;
11926 break;
11927 case 2410: hashes_buf[0].salt->salt_len = 4;
11928 break;
11929 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11930 break;
11931 case 3100: hashes_buf[0].salt->salt_len = 1;
11932 break;
11933 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11934 break;
11935 case 5800: hashes_buf[0].salt->salt_len = 16;
11936 break;
11937 case 6800: hashes_buf[0].salt->salt_len = 32;
11938 break;
11939 case 8400: hashes_buf[0].salt->salt_len = 40;
11940 break;
11941 case 8800: hashes_buf[0].salt->salt_len = 16;
11942 break;
11943 case 8900: hashes_buf[0].salt->salt_len = 16;
11944 hashes_buf[0].salt->scrypt_N = 1024;
11945 hashes_buf[0].salt->scrypt_r = 1;
11946 hashes_buf[0].salt->scrypt_p = 1;
11947 break;
11948 case 9100: hashes_buf[0].salt->salt_len = 16;
11949 break;
11950 case 9300: hashes_buf[0].salt->salt_len = 14;
11951 hashes_buf[0].salt->scrypt_N = 16384;
11952 hashes_buf[0].salt->scrypt_r = 1;
11953 hashes_buf[0].salt->scrypt_p = 1;
11954 break;
11955 case 9400: hashes_buf[0].salt->salt_len = 16;
11956 break;
11957 case 9500: hashes_buf[0].salt->salt_len = 16;
11958 break;
11959 case 9600: hashes_buf[0].salt->salt_len = 16;
11960 break;
11961 case 9700: hashes_buf[0].salt->salt_len = 16;
11962 break;
11963 case 9710: hashes_buf[0].salt->salt_len = 16;
11964 break;
11965 case 9720: hashes_buf[0].salt->salt_len = 16;
11966 break;
11967 case 9800: hashes_buf[0].salt->salt_len = 16;
11968 break;
11969 case 9810: hashes_buf[0].salt->salt_len = 16;
11970 break;
11971 case 9820: hashes_buf[0].salt->salt_len = 16;
11972 break;
11973 case 10300: hashes_buf[0].salt->salt_len = 12;
11974 break;
11975 case 11500: hashes_buf[0].salt->salt_len = 4;
11976 break;
11977 case 11600: hashes_buf[0].salt->salt_len = 4;
11978 break;
11979 case 12400: hashes_buf[0].salt->salt_len = 4;
11980 break;
11981 case 12500: hashes_buf[0].salt->salt_len = 8;
11982 break;
11983 case 12600: hashes_buf[0].salt->salt_len = 64;
11984 break;
11985 }
11986
11987 // special esalt handling
11988
11989 switch (hash_mode)
11990 {
11991 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11992 break;
11993 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11994 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11995 break;
11996 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11997 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11998 break;
11999 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12000 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12001 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12002 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12003 break;
12004 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12005 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12006 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12007 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12008 break;
12009 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12010 break;
12011 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12012 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12013 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12014 break;
12015 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12016 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12017 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12018 break;
12019 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12020 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12021 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12022 break;
12023 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12024 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12025 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12026 break;
12027 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12028 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12029 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12030 break;
12031 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12032 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12033 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12034 break;
12035 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12036 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12037 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12038 break;
12039 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12040 break;
12041 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12042 break;
12043 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12044 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12045 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12046 break;
12047 }
12048 }
12049
12050 // set hashfile
12051
12052 switch (hash_mode)
12053 {
12054 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12055 break;
12056 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12057 break;
12058 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12059 break;
12060 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12061 break;
12062 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12063 break;
12064 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12065 break;
12066 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12067 break;
12068 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12069 break;
12070 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12071 break;
12072 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12073 break;
12074 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12075 break;
12076 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12077 break;
12078 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12079 break;
12080 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12081 break;
12082 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12083 break;
12084 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12085 break;
12086 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12087 break;
12088 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12089 break;
12090 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12091 break;
12092 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12093 break;
12094 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12095 break;
12096 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12097 break;
12098 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12099 break;
12100 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12101 break;
12102 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12103 break;
12104 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12105 break;
12106 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12107 break;
12108 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12109 break;
12110 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12111 break;
12112 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12113 break;
12114 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12115 break;
12116 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12117 break;
12118 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12119 break;
12120 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12121 break;
12122 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12123 break;
12124 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12125 break;
12126 }
12127
12128 // set default iterations
12129
12130 switch (hash_mode)
12131 {
12132 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12133 break;
12134 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12135 break;
12136 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12137 break;
12138 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12139 break;
12140 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12141 break;
12142 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12143 break;
12144 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12145 break;
12146 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12147 break;
12148 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12149 break;
12150 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12151 break;
12152 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12153 break;
12154 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12155 break;
12156 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12157 break;
12158 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12159 break;
12160 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12161 break;
12162 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12163 break;
12164 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12165 break;
12166 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12167 break;
12168 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12169 break;
12170 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12171 break;
12172 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12173 break;
12174 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12175 break;
12176 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12177 break;
12178 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12179 break;
12180 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12181 break;
12182 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12183 break;
12184 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12185 break;
12186 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12187 break;
12188 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12189 break;
12190 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12191 break;
12192 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12193 break;
12194 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12195 break;
12196 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12197 break;
12198 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12199 break;
12200 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12201 break;
12202 case 8900: hashes_buf[0].salt->salt_iter = 1;
12203 break;
12204 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12205 break;
12206 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12207 break;
12208 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12209 break;
12210 case 9300: hashes_buf[0].salt->salt_iter = 1;
12211 break;
12212 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12213 break;
12214 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12215 break;
12216 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12217 break;
12218 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12219 break;
12220 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12221 break;
12222 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12223 break;
12224 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12225 break;
12226 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12227 break;
12228 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12229 break;
12230 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12231 break;
12232 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12233 break;
12234 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12235 break;
12236 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12237 break;
12238 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12239 break;
12240 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12241 break;
12242 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12243 break;
12244 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12245 break;
12246 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12247 break;
12248 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12249 break;
12250 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12251 break;
12252 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12253 break;
12254 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12255 break;
12256 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12257 break;
12258 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12259 break;
12260 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12261 break;
12262 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12263 break;
12264 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12265 break;
12266 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12267 break;
12268 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12269 break;
12270 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12271 break;
12272 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12273 break;
12274 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12275 break;
12276 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12277 break;
12278 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12279 break;
12280 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12281 break;
12282 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12283 break;
12284 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12285 break;
12286 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12287 break;
12288 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12289 break;
12290 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12291 break;
12292 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12293 break;
12294 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12295 break;
12296 }
12297
12298 hashes_cnt = 1;
12299 }
12300
12301 if (show == 1 || left == 1)
12302 {
12303 for (uint i = 0; i < pot_cnt; i++)
12304 {
12305 pot_t *pot_ptr = &pot[i];
12306
12307 hash_t *hashes_buf = &pot_ptr->hash;
12308
12309 local_free (hashes_buf->digest);
12310
12311 if (isSalted)
12312 {
12313 local_free (hashes_buf->salt);
12314 }
12315 }
12316
12317 local_free (pot);
12318
12319 if (data.quiet == 0) log_info_nn ("");
12320
12321 return (0);
12322 }
12323
12324 if (keyspace == 0)
12325 {
12326 if (hashes_cnt == 0)
12327 {
12328 log_error ("ERROR: No hashes loaded");
12329
12330 return (-1);
12331 }
12332 }
12333
12334 /**
12335 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12336 */
12337
12338 if (data.outfile != NULL)
12339 {
12340 if (data.hashfile != NULL)
12341 {
12342 #ifdef _POSIX
12343 struct stat tmpstat_outfile;
12344 struct stat tmpstat_hashfile;
12345 #endif
12346
12347 #ifdef _WIN
12348 struct stat64 tmpstat_outfile;
12349 struct stat64 tmpstat_hashfile;
12350 #endif
12351
12352 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12353
12354 if (tmp_outfile_fp)
12355 {
12356 #ifdef _POSIX
12357 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12358 #endif
12359
12360 #ifdef _WIN
12361 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12362 #endif
12363
12364 fclose (tmp_outfile_fp);
12365 }
12366
12367 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12368
12369 if (tmp_hashfile_fp)
12370 {
12371 #ifdef _POSIX
12372 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12373 #endif
12374
12375 #ifdef _WIN
12376 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12377 #endif
12378
12379 fclose (tmp_hashfile_fp);
12380 }
12381
12382 if (tmp_outfile_fp && tmp_outfile_fp)
12383 {
12384 tmpstat_outfile.st_mode = 0;
12385 tmpstat_outfile.st_nlink = 0;
12386 tmpstat_outfile.st_uid = 0;
12387 tmpstat_outfile.st_gid = 0;
12388 tmpstat_outfile.st_rdev = 0;
12389 tmpstat_outfile.st_atime = 0;
12390
12391 tmpstat_hashfile.st_mode = 0;
12392 tmpstat_hashfile.st_nlink = 0;
12393 tmpstat_hashfile.st_uid = 0;
12394 tmpstat_hashfile.st_gid = 0;
12395 tmpstat_hashfile.st_rdev = 0;
12396 tmpstat_hashfile.st_atime = 0;
12397
12398 #ifdef _POSIX
12399 tmpstat_outfile.st_blksize = 0;
12400 tmpstat_outfile.st_blocks = 0;
12401
12402 tmpstat_hashfile.st_blksize = 0;
12403 tmpstat_hashfile.st_blocks = 0;
12404 #endif
12405
12406 #ifdef _POSIX
12407 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12408 {
12409 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12410
12411 return (-1);
12412 }
12413 #endif
12414
12415 #ifdef _WIN
12416 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12417 {
12418 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12419
12420 return (-1);
12421 }
12422 #endif
12423 }
12424 }
12425 }
12426
12427 /**
12428 * Remove duplicates
12429 */
12430
12431 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12432
12433 if (isSalted)
12434 {
12435 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12436 }
12437 else
12438 {
12439 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12440 }
12441
12442 uint hashes_cnt_orig = hashes_cnt;
12443
12444 hashes_cnt = 1;
12445
12446 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12447 {
12448 if (isSalted)
12449 {
12450 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12451 {
12452 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12453 }
12454 }
12455 else
12456 {
12457 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12458 }
12459
12460 if (hashes_pos > hashes_cnt)
12461 {
12462 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12463 }
12464
12465 hashes_cnt++;
12466 }
12467
12468 /**
12469 * Potfile removes
12470 */
12471
12472 uint potfile_remove_cracks = 0;
12473
12474 if (potfile_disable == 0)
12475 {
12476 hash_t hash_buf;
12477
12478 hash_buf.digest = mymalloc (dgst_size);
12479 hash_buf.salt = NULL;
12480 hash_buf.esalt = NULL;
12481 hash_buf.hash_info = NULL;
12482 hash_buf.cracked = 0;
12483
12484 if (isSalted)
12485 {
12486 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12487 }
12488
12489 if (esalt_size)
12490 {
12491 hash_buf.esalt = mymalloc (esalt_size);
12492 }
12493
12494 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12495
12496 // no solution for these special hash types (for instane because they use hashfile in output etc)
12497 if ((hash_mode != 5200) &&
12498 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12499 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12500 (hash_mode != 9000))
12501 {
12502 FILE *fp = fopen (potfile, "rb");
12503
12504 if (fp != NULL)
12505 {
12506 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12507
12508 // to be safe work with a copy (because of line_len loop, i etc)
12509 // moved up here because it's easier to handle continue case
12510 // it's just 64kb
12511
12512 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12513
12514 while (!feof (fp))
12515 {
12516 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12517
12518 if (ptr == NULL) break;
12519
12520 int line_len = strlen (line_buf);
12521
12522 if (line_len == 0) continue;
12523
12524 int iter = MAX_CUT_TRIES;
12525
12526 for (int i = line_len - 1; i && iter; i--, line_len--)
12527 {
12528 if (line_buf[i] != ':') continue;
12529
12530 if (isSalted)
12531 {
12532 memset (hash_buf.salt, 0, sizeof (salt_t));
12533 }
12534
12535 hash_t *found = NULL;
12536
12537 if (hash_mode == 6800)
12538 {
12539 if (i < 64) // 64 = 16 * uint in salt_buf[]
12540 {
12541 // manipulate salt_buf
12542 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12543
12544 hash_buf.salt->salt_len = i;
12545
12546 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12547 }
12548 }
12549 else if (hash_mode == 2500)
12550 {
12551 if (i < 64) // 64 = 16 * uint in salt_buf[]
12552 {
12553 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12554 // manipulate salt_buf
12555
12556 memcpy (line_buf_cpy, line_buf, i);
12557
12558 char *mac2_pos = strrchr (line_buf_cpy, ':');
12559
12560 if (mac2_pos == NULL) continue;
12561
12562 mac2_pos[0] = 0;
12563 mac2_pos++;
12564
12565 if (strlen (mac2_pos) != 12) continue;
12566
12567 char *mac1_pos = strrchr (line_buf_cpy, ':');
12568
12569 if (mac1_pos == NULL) continue;
12570
12571 mac1_pos[0] = 0;
12572 mac1_pos++;
12573
12574 if (strlen (mac1_pos) != 12) continue;
12575
12576 uint essid_length = mac1_pos - line_buf_cpy - 1;
12577
12578 // here we need the ESSID
12579 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12580
12581 hash_buf.salt->salt_len = essid_length;
12582
12583 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12584
12585 if (found)
12586 {
12587 wpa_t *wpa = (wpa_t *) found->esalt;
12588
12589 // compare hex string(s) vs binary MAC address(es)
12590
12591 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12592 {
12593 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12594 {
12595 found = NULL;
12596
12597 break;
12598 }
12599 }
12600
12601 // early skip ;)
12602 if (!found) continue;
12603
12604 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12605 {
12606 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12607 {
12608 found = NULL;
12609
12610 break;
12611 }
12612 }
12613 }
12614 }
12615 }
12616 else
12617 {
12618 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12619
12620 if (parser_status == PARSER_OK)
12621 {
12622 if (isSalted)
12623 {
12624 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12625 }
12626 else
12627 {
12628 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12629 }
12630 }
12631 }
12632
12633 if (found == NULL) continue;
12634
12635 if (!found->cracked) potfile_remove_cracks++;
12636
12637 found->cracked = 1;
12638
12639 if (found) break;
12640
12641 iter--;
12642 }
12643 }
12644
12645 myfree (line_buf_cpy);
12646
12647 myfree (line_buf);
12648
12649 fclose (fp);
12650 }
12651 }
12652
12653 if (esalt_size)
12654 {
12655 local_free (hash_buf.esalt);
12656 }
12657
12658 if (isSalted)
12659 {
12660 local_free (hash_buf.salt);
12661 }
12662
12663 local_free (hash_buf.digest);
12664 }
12665
12666 /**
12667 * Now generate all the buffers required for later
12668 */
12669
12670 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12671
12672 salt_t *salts_buf_new = NULL;
12673 void *esalts_buf_new = NULL;
12674
12675 if (isSalted)
12676 {
12677 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12678
12679 if (esalt_size)
12680 {
12681 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12682 }
12683 }
12684 else
12685 {
12686 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12687 }
12688
12689 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12690
12691 uint digests_cnt = hashes_cnt;
12692 uint digests_done = 0;
12693
12694 size_t size_digests = digests_cnt * dgst_size;
12695 size_t size_shown = digests_cnt * sizeof (uint);
12696
12697 uint *digests_shown = (uint *) mymalloc (size_shown);
12698 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12699
12700 uint salts_cnt = 0;
12701 uint salts_done = 0;
12702
12703 hashinfo_t **hash_info = NULL;
12704
12705 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12706 {
12707 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12708
12709 if (username && (remove || show))
12710 {
12711 uint user_pos;
12712
12713 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12714 {
12715 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12716
12717 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12718 }
12719 }
12720 }
12721
12722 uint *salts_shown = (uint *) mymalloc (size_shown);
12723
12724 salt_t *salt_buf;
12725
12726 {
12727 // copied from inner loop
12728
12729 salt_buf = &salts_buf_new[salts_cnt];
12730
12731 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12732
12733 if (esalt_size)
12734 {
12735 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12736 }
12737
12738 salt_buf->digests_cnt = 0;
12739 salt_buf->digests_done = 0;
12740 salt_buf->digests_offset = 0;
12741
12742 salts_cnt++;
12743 }
12744
12745 if (hashes_buf[0].cracked == 1)
12746 {
12747 digests_shown[0] = 1;
12748
12749 digests_done++;
12750
12751 salt_buf->digests_done++;
12752 }
12753
12754 salt_buf->digests_cnt++;
12755
12756 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12757
12758 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12759 {
12760 hash_info[0] = hashes_buf[0].hash_info;
12761 }
12762
12763 // copy from inner loop
12764
12765 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12766 {
12767 if (isSalted)
12768 {
12769 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12770 {
12771 salt_buf = &salts_buf_new[salts_cnt];
12772
12773 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12774
12775 if (esalt_size)
12776 {
12777 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12778 }
12779
12780 salt_buf->digests_cnt = 0;
12781 salt_buf->digests_done = 0;
12782 salt_buf->digests_offset = hashes_pos;
12783
12784 salts_cnt++;
12785 }
12786 }
12787
12788 if (hashes_buf[hashes_pos].cracked == 1)
12789 {
12790 digests_shown[hashes_pos] = 1;
12791
12792 digests_done++;
12793
12794 salt_buf->digests_done++;
12795 }
12796
12797 salt_buf->digests_cnt++;
12798
12799 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12800
12801 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12802 {
12803 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12804 }
12805 }
12806
12807 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12808 {
12809 salt_t *salt_buf = &salts_buf_new[salt_pos];
12810
12811 if (salt_buf->digests_done == salt_buf->digests_cnt)
12812 {
12813 salts_shown[salt_pos] = 1;
12814
12815 salts_done++;
12816 }
12817
12818 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12819 }
12820
12821 local_free (digests_buf);
12822 local_free (salts_buf);
12823 local_free (esalts_buf);
12824
12825 digests_buf = digests_buf_new;
12826 salts_buf = salts_buf_new;
12827 esalts_buf = esalts_buf_new;
12828
12829 local_free (hashes_buf);
12830
12831 /**
12832 * special modification not set from parser
12833 */
12834
12835 switch (hash_mode)
12836 {
12837 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12838 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12839 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12840 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12841 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12842 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12843 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12844 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12845 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12846 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12847 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12848 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12849 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12850 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12851 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12852 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12853 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12854 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12855 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12856 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12857 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12858 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12859 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12860 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12861 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12862 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12863 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12864 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12865 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12866 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12867 }
12868
12869 if (truecrypt_keyfiles)
12870 {
12871 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12872
12873 char *keyfiles = strdup (truecrypt_keyfiles);
12874
12875 char *keyfile = strtok (keyfiles, ",");
12876
12877 do
12878 {
12879 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12880
12881 } while ((keyfile = strtok (NULL, ",")) != NULL);
12882
12883 free (keyfiles);
12884 }
12885
12886 if (veracrypt_keyfiles)
12887 {
12888 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12889
12890 char *keyfiles = strdup (veracrypt_keyfiles);
12891
12892 char *keyfile = strtok (keyfiles, ",");
12893
12894 do
12895 {
12896 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12897
12898 } while ((keyfile = strtok (NULL, ",")) != NULL);
12899
12900 free (keyfiles);
12901 }
12902
12903 data.digests_cnt = digests_cnt;
12904 data.digests_done = digests_done;
12905 data.digests_buf = digests_buf;
12906 data.digests_shown = digests_shown;
12907 data.digests_shown_tmp = digests_shown_tmp;
12908
12909 data.salts_cnt = salts_cnt;
12910 data.salts_done = salts_done;
12911 data.salts_buf = salts_buf;
12912 data.salts_shown = salts_shown;
12913
12914 data.esalts_buf = esalts_buf;
12915 data.hash_info = hash_info;
12916
12917 /**
12918 * Automatic Optimizers
12919 */
12920
12921 if (salts_cnt == 1)
12922 opti_type |= OPTI_TYPE_SINGLE_SALT;
12923
12924 if (digests_cnt == 1)
12925 opti_type |= OPTI_TYPE_SINGLE_HASH;
12926
12927 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12928 opti_type |= OPTI_TYPE_NOT_ITERATED;
12929
12930 if (attack_mode == ATTACK_MODE_BF)
12931 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12932
12933 data.opti_type = opti_type;
12934
12935 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12936 {
12937 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12938 {
12939 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12940 {
12941 if (opts_type & OPTS_TYPE_ST_ADD80)
12942 {
12943 opts_type &= ~OPTS_TYPE_ST_ADD80;
12944 opts_type |= OPTS_TYPE_PT_ADD80;
12945 }
12946
12947 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12948 {
12949 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12950 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12951 }
12952
12953 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12954 {
12955 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12956 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12957 }
12958 }
12959 }
12960 }
12961
12962 /**
12963 * Some algorithm, like descrypt, can benefit from JIT compilation
12964 */
12965
12966 int force_jit_compilation = -1;
12967
12968 if (hash_mode == 8900)
12969 {
12970 force_jit_compilation = 8900;
12971 }
12972 else if (hash_mode == 9300)
12973 {
12974 force_jit_compilation = 8900;
12975 }
12976 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12977 {
12978 force_jit_compilation = 1500;
12979 }
12980
12981 /**
12982 * generate bitmap tables
12983 */
12984
12985 const uint bitmap_shift1 = 5;
12986 const uint bitmap_shift2 = 13;
12987
12988 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12989
12990 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12991 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12992 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12993 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12994 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12995 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12996 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12997 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12998
12999 uint bitmap_bits;
13000 uint bitmap_nums;
13001 uint bitmap_mask;
13002 uint bitmap_size;
13003
13004 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13005 {
13006 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13007
13008 bitmap_nums = 1 << bitmap_bits;
13009
13010 bitmap_mask = bitmap_nums - 1;
13011
13012 bitmap_size = bitmap_nums * sizeof (uint);
13013
13014 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13015
13016 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;
13017 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;
13018
13019 break;
13020 }
13021
13022 bitmap_nums = 1 << bitmap_bits;
13023
13024 bitmap_mask = bitmap_nums - 1;
13025
13026 bitmap_size = bitmap_nums * sizeof (uint);
13027
13028 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);
13029 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);
13030
13031 /**
13032 * prepare quick rule
13033 */
13034
13035 data.rule_buf_l = rule_buf_l;
13036 data.rule_buf_r = rule_buf_r;
13037
13038 int rule_len_l = (int) strlen (rule_buf_l);
13039 int rule_len_r = (int) strlen (rule_buf_r);
13040
13041 data.rule_len_l = rule_len_l;
13042 data.rule_len_r = rule_len_r;
13043
13044 /**
13045 * load rules
13046 */
13047
13048 uint *all_kernel_rules_cnt = NULL;
13049
13050 kernel_rule_t **all_kernel_rules_buf = NULL;
13051
13052 if (rp_files_cnt)
13053 {
13054 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13055
13056 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13057 }
13058
13059 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13060
13061 int rule_len = 0;
13062
13063 for (uint i = 0; i < rp_files_cnt; i++)
13064 {
13065 uint kernel_rules_avail = 0;
13066
13067 uint kernel_rules_cnt = 0;
13068
13069 kernel_rule_t *kernel_rules_buf = NULL;
13070
13071 char *rp_file = rp_files[i];
13072
13073 char in[BLOCK_SIZE] = { 0 };
13074 char out[BLOCK_SIZE] = { 0 };
13075
13076 FILE *fp = NULL;
13077
13078 uint rule_line = 0;
13079
13080 if ((fp = fopen (rp_file, "rb")) == NULL)
13081 {
13082 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13083
13084 return (-1);
13085 }
13086
13087 while (!feof (fp))
13088 {
13089 memset (rule_buf, 0, HCBUFSIZ);
13090
13091 rule_len = fgetl (fp, rule_buf);
13092
13093 rule_line++;
13094
13095 if (rule_len == 0) continue;
13096
13097 if (rule_buf[0] == '#') continue;
13098
13099 if (kernel_rules_avail == kernel_rules_cnt)
13100 {
13101 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13102
13103 kernel_rules_avail += INCR_RULES;
13104 }
13105
13106 memset (in, 0, BLOCK_SIZE);
13107 memset (out, 0, BLOCK_SIZE);
13108
13109 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13110
13111 if (result == -1)
13112 {
13113 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13114
13115 continue;
13116 }
13117
13118 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13119 {
13120 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13121
13122 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13123
13124 continue;
13125 }
13126
13127 /* its so slow
13128 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13129 {
13130 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13131
13132 continue;
13133 }
13134 */
13135
13136 kernel_rules_cnt++;
13137 }
13138
13139 fclose (fp);
13140
13141 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13142
13143 all_kernel_rules_buf[i] = kernel_rules_buf;
13144 }
13145
13146 /**
13147 * merge rules or automatic rule generator
13148 */
13149
13150 uint kernel_rules_cnt = 0;
13151
13152 kernel_rule_t *kernel_rules_buf = NULL;
13153
13154 if (attack_mode == ATTACK_MODE_STRAIGHT)
13155 {
13156 if (rp_files_cnt)
13157 {
13158 kernel_rules_cnt = 1;
13159
13160 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13161
13162 repeats[0] = kernel_rules_cnt;
13163
13164 for (uint i = 0; i < rp_files_cnt; i++)
13165 {
13166 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13167
13168 repeats[i + 1] = kernel_rules_cnt;
13169 }
13170
13171 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13172
13173 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13174
13175 for (uint i = 0; i < kernel_rules_cnt; i++)
13176 {
13177 uint out_pos = 0;
13178
13179 kernel_rule_t *out = &kernel_rules_buf[i];
13180
13181 for (uint j = 0; j < rp_files_cnt; j++)
13182 {
13183 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13184 uint in_pos;
13185
13186 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13187
13188 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13189 {
13190 if (out_pos == RULES_MAX - 1)
13191 {
13192 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13193
13194 break;
13195 }
13196
13197 out->cmds[out_pos] = in->cmds[in_pos];
13198 }
13199 }
13200 }
13201
13202 local_free (repeats);
13203 }
13204 else if (rp_gen)
13205 {
13206 uint kernel_rules_avail = 0;
13207
13208 while (kernel_rules_cnt < rp_gen)
13209 {
13210 if (kernel_rules_avail == kernel_rules_cnt)
13211 {
13212 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13213
13214 kernel_rules_avail += INCR_RULES;
13215 }
13216
13217 memset (rule_buf, 0, HCBUFSIZ);
13218
13219 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13220
13221 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13222
13223 kernel_rules_cnt++;
13224 }
13225 }
13226 }
13227
13228 myfree (rule_buf);
13229
13230 /**
13231 * generate NOP rules
13232 */
13233
13234 if (kernel_rules_cnt == 0)
13235 {
13236 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13237
13238 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13239
13240 kernel_rules_cnt++;
13241 }
13242
13243 data.kernel_rules_cnt = kernel_rules_cnt;
13244 data.kernel_rules_buf = kernel_rules_buf;
13245
13246 /**
13247 * OpenCL platforms: detect
13248 */
13249
13250 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13251 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13252
13253 cl_uint platforms_cnt = 0;
13254 cl_uint platform_devices_cnt = 0;
13255
13256 if (keyspace == 0)
13257 {
13258 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13259
13260 if (platforms_cnt == 0)
13261 {
13262 log_info ("");
13263 log_info ("ATTENTION! No OpenCL compatible platform found");
13264 log_info ("");
13265 log_info ("You're probably missing the OpenCL runtime installation");
13266 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13267 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13268 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13269 log_info ("");
13270
13271 return (-1);
13272 }
13273
13274 if (opencl_platforms_filter != (uint) -1)
13275 {
13276 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13277
13278 if (opencl_platforms_filter > platform_cnt_mask)
13279 {
13280 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13281
13282 return (-1);
13283 }
13284 }
13285 }
13286
13287 /**
13288 * OpenCL device types:
13289 * 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.
13290 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13291 */
13292
13293 if (opencl_device_types == NULL)
13294 {
13295 cl_device_type device_types_all = 0;
13296
13297 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13298 {
13299 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13300
13301 cl_platform_id platform = platforms[platform_id];
13302
13303 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13304
13305 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13306 {
13307 cl_device_id device = platform_devices[platform_devices_id];
13308
13309 cl_device_type device_type;
13310
13311 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13312
13313 device_types_all |= device_type;
13314 }
13315 }
13316
13317 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13318 {
13319 device_types_filter |= CL_DEVICE_TYPE_CPU;
13320 }
13321 }
13322
13323 /**
13324 * OpenCL devices: simply push all devices from all platforms into the same device array
13325 */
13326
13327 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13328
13329 data.devices_param = devices_param;
13330
13331 uint devices_cnt = 0;
13332
13333 uint devices_active = 0;
13334
13335 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13336 {
13337 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13338
13339 cl_platform_id platform = platforms[platform_id];
13340
13341 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13342
13343 char platform_vendor[INFOSZ] = { 0 };
13344
13345 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13346
13347 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13348 // this causes trouble with vendor id based macros
13349 // we'll assign generic to those without special optimization available
13350
13351 cl_uint platform_vendor_id = 0;
13352
13353 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13354 {
13355 platform_vendor_id = VENDOR_ID_AMD;
13356 }
13357 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13358 {
13359 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13360 }
13361 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13362 {
13363 platform_vendor_id = VENDOR_ID_APPLE;
13364 }
13365 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13366 {
13367 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13368 }
13369 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13370 {
13371 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13372 }
13373 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13374 {
13375 platform_vendor_id = VENDOR_ID_MESA;
13376 }
13377 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13378 {
13379 platform_vendor_id = VENDOR_ID_NV;
13380 }
13381 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13382 {
13383 platform_vendor_id = VENDOR_ID_POCL;
13384 }
13385 else
13386 {
13387 platform_vendor_id = VENDOR_ID_GENERIC;
13388 }
13389
13390 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13391 {
13392 size_t param_value_size = 0;
13393
13394 const uint device_id = devices_cnt;
13395
13396 hc_device_param_t *device_param = &data.devices_param[device_id];
13397
13398 device_param->platform_vendor_id = platform_vendor_id;
13399
13400 device_param->device = platform_devices[platform_devices_id];
13401
13402 device_param->device_id = device_id;
13403
13404 device_param->platform_devices_id = platform_devices_id;
13405
13406 // device_type
13407
13408 cl_device_type device_type;
13409
13410 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13411
13412 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13413
13414 device_param->device_type = device_type;
13415
13416 // device_name
13417
13418 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13419
13420 char *device_name = (char *) mymalloc (param_value_size);
13421
13422 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13423
13424 device_param->device_name = device_name;
13425
13426 // device_vendor
13427
13428 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13429
13430 char *device_vendor = (char *) mymalloc (param_value_size);
13431
13432 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13433
13434 device_param->device_vendor = device_vendor;
13435
13436 cl_uint device_vendor_id = 0;
13437
13438 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13439 {
13440 device_vendor_id = VENDOR_ID_AMD;
13441 }
13442 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13443 {
13444 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13445 }
13446 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13447 {
13448 device_vendor_id = VENDOR_ID_APPLE;
13449 }
13450 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13451 {
13452 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13453 }
13454 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13455 {
13456 device_vendor_id = VENDOR_ID_INTEL_SDK;
13457 }
13458 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13459 {
13460 device_vendor_id = VENDOR_ID_MESA;
13461 }
13462 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13463 {
13464 device_vendor_id = VENDOR_ID_NV;
13465 }
13466 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13467 {
13468 device_vendor_id = VENDOR_ID_POCL;
13469 }
13470 else
13471 {
13472 device_vendor_id = VENDOR_ID_GENERIC;
13473 }
13474
13475 device_param->device_vendor_id = device_vendor_id;
13476
13477 // tuning db
13478
13479 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13480
13481 // device_version
13482
13483 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13484
13485 char *device_version = (char *) mymalloc (param_value_size);
13486
13487 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13488
13489 device_param->device_version = device_version;
13490
13491 // device_opencl_version
13492
13493 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13494
13495 char *device_opencl_version = (char *) mymalloc (param_value_size);
13496
13497 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13498
13499 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13500
13501 myfree (device_opencl_version);
13502
13503 // vector_width
13504
13505 cl_uint vector_width;
13506
13507 if (opencl_vector_width_chgd == 0)
13508 {
13509 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13510 {
13511 if (opti_type & OPTI_TYPE_USES_BITS_64)
13512 {
13513 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13514 }
13515 else
13516 {
13517 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13518 }
13519 }
13520 else
13521 {
13522 vector_width = (cl_uint) tuningdb_entry->vector_width;
13523 }
13524 }
13525 else
13526 {
13527 vector_width = opencl_vector_width;
13528 }
13529
13530 if (vector_width > 16) vector_width = 16;
13531
13532 device_param->vector_width = vector_width;
13533
13534 // max_compute_units
13535
13536 cl_uint device_processors;
13537
13538 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13539
13540 device_param->device_processors = device_processors;
13541
13542 // device_maxmem_alloc
13543 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13544
13545 cl_ulong device_maxmem_alloc;
13546
13547 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13548
13549 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13550
13551 // device_global_mem
13552
13553 cl_ulong device_global_mem;
13554
13555 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13556
13557 device_param->device_global_mem = device_global_mem;
13558
13559 // max_work_group_size
13560
13561 size_t device_maxworkgroup_size;
13562
13563 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13564
13565 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13566
13567 // max_clock_frequency
13568
13569 cl_uint device_maxclock_frequency;
13570
13571 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13572
13573 device_param->device_maxclock_frequency = device_maxclock_frequency;
13574
13575 // device_endian_little
13576
13577 cl_bool device_endian_little;
13578
13579 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13580
13581 if (device_endian_little == CL_FALSE)
13582 {
13583 if (data.quiet == 0) log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13584
13585 device_param->skipped = 1;
13586 }
13587
13588 // device_available
13589
13590 cl_bool device_available;
13591
13592 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13593
13594 if (device_available == CL_FALSE)
13595 {
13596 if (data.quiet == 0) log_info ("Device #%u: WARNING: device not available", device_id + 1);
13597
13598 device_param->skipped = 1;
13599 }
13600
13601 // device_compiler_available
13602
13603 cl_bool device_compiler_available;
13604
13605 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13606
13607 if (device_compiler_available == CL_FALSE)
13608 {
13609 if (data.quiet == 0) log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13610
13611 device_param->skipped = 1;
13612 }
13613
13614 // device_execution_capabilities
13615
13616 cl_device_exec_capabilities device_execution_capabilities;
13617
13618 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13619
13620 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13621 {
13622 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13623
13624 device_param->skipped = 1;
13625 }
13626
13627 // device_extensions
13628
13629 size_t device_extensions_size;
13630
13631 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13632
13633 char *device_extensions = mymalloc (device_extensions_size + 1);
13634
13635 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13636
13637 if (strstr (device_extensions, "base_atomics") == 0)
13638 {
13639 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13640
13641 device_param->skipped = 1;
13642 }
13643
13644 if (strstr (device_extensions, "byte_addressable_store") == 0)
13645 {
13646 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13647
13648 device_param->skipped = 1;
13649 }
13650
13651 myfree (device_extensions);
13652
13653 // device_local_mem_size
13654
13655 cl_ulong device_local_mem_size;
13656
13657 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13658
13659 if (device_local_mem_size < 32768)
13660 {
13661 if (data.quiet == 0) log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13662
13663 device_param->skipped = 1;
13664 }
13665
13666 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13667 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13668 // This results in both utilizing it for 50%
13669 // However, Intel has much better SIMD control over their own hardware
13670 // It makes sense to give them full control over their own hardware
13671
13672 if (device_type & CL_DEVICE_TYPE_CPU)
13673 {
13674 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13675 {
13676 if (data.quiet == 0) log_info ("Device #%u: WARNING: not native intel opencl platform", device_id + 1);
13677
13678 device_param->skipped = 1;
13679 }
13680 }
13681
13682 // skipped
13683
13684 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13685 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13686
13687 // driver_version
13688
13689 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13690
13691 char *driver_version = (char *) mymalloc (param_value_size);
13692
13693 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13694
13695 device_param->driver_version = driver_version;
13696
13697 // device_name_chksum
13698
13699 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13700
13701 #if __x86_64__
13702 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);
13703 #else
13704 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);
13705 #endif
13706
13707 uint device_name_digest[4] = { 0 };
13708
13709 md5_64 ((uint *) device_name_chksum, device_name_digest);
13710
13711 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13712
13713 device_param->device_name_chksum = device_name_chksum;
13714
13715 // device_processor_cores
13716
13717 if (device_type & CL_DEVICE_TYPE_CPU)
13718 {
13719 cl_uint device_processor_cores = 1;
13720
13721 device_param->device_processor_cores = device_processor_cores;
13722 }
13723
13724 if (device_type & CL_DEVICE_TYPE_GPU)
13725 {
13726 if (device_vendor_id == VENDOR_ID_AMD)
13727 {
13728 cl_uint device_processor_cores = 0;
13729
13730 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13731
13732 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13733
13734 device_param->device_processor_cores = device_processor_cores;
13735 }
13736 else if (device_vendor_id == VENDOR_ID_NV)
13737 {
13738 cl_uint kernel_exec_timeout = 0;
13739
13740 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13741
13742 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13743
13744 device_param->kernel_exec_timeout = kernel_exec_timeout;
13745
13746 cl_uint device_processor_cores = 0;
13747
13748 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13749
13750 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13751
13752 device_param->device_processor_cores = device_processor_cores;
13753
13754 cl_uint sm_minor = 0;
13755 cl_uint sm_major = 0;
13756
13757 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13758 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13759
13760 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13761 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13762
13763 device_param->sm_minor = sm_minor;
13764 device_param->sm_major = sm_major;
13765 }
13766 else
13767 {
13768 cl_uint device_processor_cores = 1;
13769
13770 device_param->device_processor_cores = device_processor_cores;
13771 }
13772 }
13773
13774 // display results
13775
13776 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13777 {
13778 if (machine_readable == 0)
13779 {
13780 if (device_param->skipped == 0)
13781 {
13782 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13783 device_id + 1,
13784 device_name,
13785 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13786 (unsigned int) (device_global_mem / 1024 / 1024),
13787 (unsigned int) device_processors);
13788 }
13789 else
13790 {
13791 log_info ("Device #%u: %s, skipped",
13792 device_id + 1,
13793 device_name);
13794 }
13795 }
13796 }
13797
13798 // common driver check
13799
13800 if (device_param->skipped == 0)
13801 {
13802 if (device_type & CL_DEVICE_TYPE_GPU)
13803 {
13804 if (platform_vendor_id == VENDOR_ID_AMD)
13805 {
13806 int catalyst_check = (force == 1) ? 0 : 1;
13807
13808 int catalyst_warn = 0;
13809
13810 int catalyst_broken = 0;
13811
13812 if (catalyst_check == 1)
13813 {
13814 catalyst_warn = 1;
13815
13816 // v14.9 and higher
13817 if (atoi (device_param->driver_version) >= 1573)
13818 {
13819 catalyst_warn = 0;
13820 }
13821
13822 catalyst_check = 0;
13823 }
13824
13825 if (catalyst_broken == 1)
13826 {
13827 log_info ("");
13828 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13829 log_info ("It will pass over cracked hashes and does not report them as cracked");
13830 log_info ("You are STRONGLY encouraged not to use it");
13831 log_info ("You can use --force to override this but do not post error reports if you do so");
13832 log_info ("");
13833
13834 return (-1);
13835 }
13836
13837 if (catalyst_warn == 1)
13838 {
13839 log_info ("");
13840 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13841 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13842 log_info ("See hashcat's homepage for official supported catalyst drivers");
13843 #ifdef _WIN
13844 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13845 #endif
13846 log_info ("You can use --force to override this but do not post error reports if you do so");
13847 log_info ("");
13848
13849 return (-1);
13850 }
13851 }
13852 else if (platform_vendor_id == VENDOR_ID_NV)
13853 {
13854 if (device_param->kernel_exec_timeout != 0)
13855 {
13856 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);
13857 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13858 }
13859 }
13860 }
13861
13862 /* turns out pocl still creates segfaults (because of llvm)
13863 if (device_type & CL_DEVICE_TYPE_CPU)
13864 {
13865 if (platform_vendor_id == VENDOR_ID_AMD)
13866 {
13867 if (force == 0)
13868 {
13869 log_info ("");
13870 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13871 log_info ("You are STRONGLY encouraged not to use it");
13872 log_info ("You can use --force to override this but do not post error reports if you do so");
13873 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13874 log_info ("");
13875
13876 return (-1);
13877 }
13878 }
13879 }
13880 */
13881
13882 /**
13883 * kernel accel and loops tuning db adjustment
13884 */
13885
13886 device_param->kernel_accel_min = 1;
13887 device_param->kernel_accel_max = 1024;
13888
13889 device_param->kernel_loops_min = 1;
13890 device_param->kernel_loops_max = 1024;
13891
13892 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13893
13894 if (tuningdb_entry)
13895 {
13896 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13897 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13898
13899 if (_kernel_accel)
13900 {
13901 device_param->kernel_accel_min = _kernel_accel;
13902 device_param->kernel_accel_max = _kernel_accel;
13903 }
13904
13905 if (_kernel_loops)
13906 {
13907 if (workload_profile == 1)
13908 {
13909 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13910 }
13911 else if (workload_profile == 2)
13912 {
13913 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13914 }
13915
13916 device_param->kernel_loops_min = _kernel_loops;
13917 device_param->kernel_loops_max = _kernel_loops;
13918 }
13919 }
13920
13921 // commandline parameters overwrite tuningdb entries
13922
13923 if (kernel_accel)
13924 {
13925 device_param->kernel_accel_min = kernel_accel;
13926 device_param->kernel_accel_max = kernel_accel;
13927 }
13928
13929 if (kernel_loops)
13930 {
13931 device_param->kernel_loops_min = kernel_loops;
13932 device_param->kernel_loops_max = kernel_loops;
13933 }
13934
13935 /**
13936 * activate device
13937 */
13938
13939 devices_active++;
13940 }
13941
13942 // next please
13943
13944 devices_cnt++;
13945 }
13946 }
13947
13948 if (keyspace == 0 && devices_active == 0)
13949 {
13950 log_error ("ERROR: No devices found/left");
13951
13952 return (-1);
13953 }
13954
13955 // 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)
13956
13957 if (devices_filter != (uint) -1)
13958 {
13959 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13960
13961 if (devices_filter > devices_cnt_mask)
13962 {
13963 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13964
13965 return (-1);
13966 }
13967 }
13968
13969 data.devices_cnt = devices_cnt;
13970
13971 data.devices_active = devices_active;
13972
13973 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13974 {
13975 if (machine_readable == 0)
13976 {
13977 log_info ("");
13978 }
13979 }
13980
13981 /**
13982 * HM devices: init
13983 */
13984
13985 #ifdef HAVE_HWMON
13986 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
13987 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
13988
13989 if (gpu_temp_disable == 0)
13990 {
13991 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13992
13993 if (nvml_init (nvml) == 0)
13994 data.hm_nv = nvml;
13995
13996 if (data.hm_nv)
13997 {
13998 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13999 {
14000 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
14001
14002 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
14003
14004 int tmp_out = 0;
14005
14006 for (int i = 0; i < tmp_in; i++)
14007 {
14008 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
14009 }
14010
14011 for (int i = 0; i < tmp_out; i++)
14012 {
14013 unsigned int speed;
14014
14015 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_get_supported = 1;
14016 }
14017 }
14018 }
14019
14020 data.hm_amd = NULL;
14021
14022 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14023
14024 if (adl_init (adl) == 0)
14025 data.hm_amd = adl;
14026
14027 if (data.hm_amd)
14028 {
14029 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14030 {
14031 // total number of adapters
14032
14033 int hm_adapters_num;
14034
14035 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
14036
14037 // adapter info
14038
14039 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
14040
14041 if (lpAdapterInfo == NULL) return (-1);
14042
14043 // get a list (of ids of) valid/usable adapters
14044
14045 int num_adl_adapters = 0;
14046
14047 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14048
14049 if (num_adl_adapters > 0)
14050 {
14051 hc_thread_mutex_lock (mux_adl);
14052
14053 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
14054
14055 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14056
14057 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14058 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14059
14060 hc_thread_mutex_unlock (mux_adl);
14061 }
14062
14063 myfree (valid_adl_device_list);
14064 myfree (lpAdapterInfo);
14065 }
14066 }
14067
14068 if (data.hm_amd == NULL && data.hm_nv == NULL)
14069 {
14070 gpu_temp_disable = 1;
14071 }
14072 }
14073
14074 /**
14075 * OpenCL devices: allocate buffer for device specific information
14076 */
14077
14078 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14079 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14080
14081 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14082
14083 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14084
14085 /**
14086 * User-defined GPU temp handling
14087 */
14088
14089 if (gpu_temp_disable == 1)
14090 {
14091 gpu_temp_abort = 0;
14092 gpu_temp_retain = 0;
14093 }
14094
14095 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14096 {
14097 if (gpu_temp_abort < gpu_temp_retain)
14098 {
14099 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14100
14101 return (-1);
14102 }
14103 }
14104
14105 data.gpu_temp_disable = gpu_temp_disable;
14106 data.gpu_temp_abort = gpu_temp_abort;
14107 data.gpu_temp_retain = gpu_temp_retain;
14108 #endif
14109
14110 /**
14111 * enable custom signal handler(s)
14112 */
14113
14114 if (benchmark == 0)
14115 {
14116 hc_signal (sigHandler_default);
14117 }
14118 else
14119 {
14120 hc_signal (sigHandler_benchmark);
14121 }
14122
14123 /**
14124 * inform the user
14125 */
14126
14127 if (data.quiet == 0)
14128 {
14129 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14130
14131 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);
14132
14133 if (attack_mode == ATTACK_MODE_STRAIGHT)
14134 {
14135 log_info ("Rules: %u", kernel_rules_cnt);
14136 }
14137
14138 if (opti_type)
14139 {
14140 log_info ("Applicable Optimizers:");
14141
14142 for (uint i = 0; i < 32; i++)
14143 {
14144 const uint opti_bit = 1u << i;
14145
14146 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14147 }
14148 }
14149
14150 /**
14151 * Watchdog and Temperature balance
14152 */
14153
14154 #ifdef HAVE_HWMON
14155 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
14156 {
14157 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14158 }
14159
14160 if (gpu_temp_abort == 0)
14161 {
14162 log_info ("Watchdog: Temperature abort trigger disabled");
14163 }
14164 else
14165 {
14166 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14167 }
14168
14169 if (gpu_temp_retain == 0)
14170 {
14171 log_info ("Watchdog: Temperature retain trigger disabled");
14172 }
14173 else
14174 {
14175 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14176 }
14177
14178 if (data.quiet == 0) log_info ("");
14179 #endif
14180 }
14181
14182 #ifdef HAVE_HWMON
14183
14184 /**
14185 * HM devices: copy
14186 */
14187
14188 if (gpu_temp_disable == 0)
14189 {
14190 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14191 {
14192 hc_device_param_t *device_param = &data.devices_param[device_id];
14193
14194 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14195
14196 if (device_param->skipped) continue;
14197
14198 const uint platform_devices_id = device_param->platform_devices_id;
14199
14200 if (device_param->device_vendor_id == VENDOR_ID_NV)
14201 {
14202 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14203 }
14204
14205 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14206 {
14207 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14208 }
14209 }
14210 }
14211
14212 /**
14213 * Temporary fix:
14214 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14215 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14216 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14217 * Driver / ADL bug?
14218 */
14219
14220 if (powertune_enable == 1)
14221 {
14222 hc_thread_mutex_lock (mux_adl);
14223
14224 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14225 {
14226 hc_device_param_t *device_param = &data.devices_param[device_id];
14227
14228 if (device_param->skipped) continue;
14229
14230 if (data.hm_device[device_id].od_version == 6)
14231 {
14232 // set powertune value only
14233
14234 int powertune_supported = 0;
14235
14236 int ADL_rc = 0;
14237
14238 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14239 {
14240 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14241
14242 return (-1);
14243 }
14244
14245 if (powertune_supported != 0)
14246 {
14247 // powertune set
14248 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14249
14250 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14251 {
14252 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14253
14254 return (-1);
14255 }
14256
14257 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14258 {
14259 log_error ("ERROR: Failed to set new ADL PowerControl values");
14260
14261 return (-1);
14262 }
14263 }
14264 }
14265 }
14266
14267 hc_thread_mutex_unlock (mux_adl);
14268 }
14269
14270 #endif // HAVE_HWMON
14271
14272 #ifdef DEBUG
14273 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14274 #endif
14275
14276 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14277
14278 uint kernel_power_all = 0;
14279
14280 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14281 {
14282 /**
14283 * host buffer
14284 */
14285
14286 hc_device_param_t *device_param = &data.devices_param[device_id];
14287
14288 if (device_param->skipped) continue;
14289
14290 /**
14291 * device properties
14292 */
14293
14294 const char *device_name_chksum = device_param->device_name_chksum;
14295 const u32 device_processors = device_param->device_processors;
14296 const u32 device_processor_cores = device_param->device_processor_cores;
14297
14298 /**
14299 * create context for each device
14300 */
14301
14302 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14303
14304 /**
14305 * create command-queue
14306 */
14307
14308 // not supported with NV
14309 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14310
14311 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14312
14313 /**
14314 * kernel threads: some algorithms need a fixed kernel-threads count
14315 * because of shared memory usage or bitslice
14316 * there needs to be some upper limit, otherwise there's too much overhead
14317 */
14318
14319 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14320
14321 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14322 {
14323 kernel_threads = KERNEL_THREADS_MAX_CPU;
14324 }
14325
14326 if (hash_mode == 1500) kernel_threads = 64; // DES
14327 if (hash_mode == 3000) kernel_threads = 64; // DES
14328 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14329 if (hash_mode == 7500) kernel_threads = 64; // RC4
14330 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14331 if (hash_mode == 9700) kernel_threads = 64; // RC4
14332 if (hash_mode == 9710) kernel_threads = 64; // RC4
14333 if (hash_mode == 9800) kernel_threads = 64; // RC4
14334 if (hash_mode == 9810) kernel_threads = 64; // RC4
14335 if (hash_mode == 10400) kernel_threads = 64; // RC4
14336 if (hash_mode == 10410) kernel_threads = 64; // RC4
14337 if (hash_mode == 10500) kernel_threads = 64; // RC4
14338 if (hash_mode == 13100) kernel_threads = 64; // RC4
14339
14340 /**
14341 * create input buffers on device : calculate size of fixed memory buffers
14342 */
14343
14344 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14345 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14346
14347 device_param->size_root_css = size_root_css;
14348 device_param->size_markov_css = size_markov_css;
14349
14350 size_t size_results = sizeof (uint);
14351
14352 device_param->size_results = size_results;
14353
14354 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14355 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14356
14357 size_t size_plains = digests_cnt * sizeof (plain_t);
14358 size_t size_salts = salts_cnt * sizeof (salt_t);
14359 size_t size_esalts = salts_cnt * esalt_size;
14360
14361 device_param->size_plains = size_plains;
14362 device_param->size_digests = size_digests;
14363 device_param->size_shown = size_shown;
14364 device_param->size_salts = size_salts;
14365
14366 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14367 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14368 size_t size_tm = 32 * sizeof (bs_word_t);
14369
14370 // scryptV stuff
14371
14372 size_t size_scryptV = 1;
14373
14374 if ((hash_mode == 8900) || (hash_mode == 9300))
14375 {
14376 uint tmto_start = 0;
14377 uint tmto_stop = 10;
14378
14379 if (scrypt_tmto)
14380 {
14381 tmto_start = scrypt_tmto;
14382 }
14383 else
14384 {
14385 // in case the user did not specify the tmto manually
14386 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14387 // but set the lower end only in case the user has a device with too less memory
14388
14389 if (hash_mode == 8900)
14390 {
14391 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14392 {
14393 tmto_start = 1;
14394 }
14395 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14396 {
14397 tmto_start = 2;
14398 }
14399 }
14400 else if (hash_mode == 9300)
14401 {
14402 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14403 {
14404 tmto_start = 2;
14405 }
14406 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14407 {
14408 tmto_start = 2;
14409 }
14410 }
14411 }
14412
14413 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14414 {
14415 // TODO: in theory the following calculation needs to be done per salt, not global
14416 // we assume all hashes have the same scrypt settings
14417
14418 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14419
14420 size_scryptV /= 1 << tmto;
14421
14422 size_scryptV *= device_processors * device_processor_cores;
14423
14424 if (size_scryptV > device_param->device_maxmem_alloc)
14425 {
14426 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14427
14428 continue;
14429 }
14430
14431 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14432 {
14433 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14434 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14435 }
14436
14437 break;
14438 }
14439
14440 if (data.salts_buf[0].scrypt_phy == 0)
14441 {
14442 log_error ("ERROR: can't allocate enough device memory");
14443
14444 return -1;
14445 }
14446
14447 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14448 }
14449
14450 /**
14451 * some algorithms need a fixed kernel-loops count
14452 */
14453
14454 if (hash_mode == 1500)
14455 {
14456 const u32 kernel_loops_fixed = 1024;
14457
14458 device_param->kernel_loops_min = kernel_loops_fixed;
14459 device_param->kernel_loops_max = kernel_loops_fixed;
14460 }
14461
14462 if (hash_mode == 3000)
14463 {
14464 const u32 kernel_loops_fixed = 1024;
14465
14466 device_param->kernel_loops_min = kernel_loops_fixed;
14467 device_param->kernel_loops_max = kernel_loops_fixed;
14468 }
14469
14470 if (hash_mode == 8900)
14471 {
14472 const u32 kernel_loops_fixed = 1;
14473
14474 device_param->kernel_loops_min = kernel_loops_fixed;
14475 device_param->kernel_loops_max = kernel_loops_fixed;
14476 }
14477
14478 if (hash_mode == 9300)
14479 {
14480 const u32 kernel_loops_fixed = 1;
14481
14482 device_param->kernel_loops_min = kernel_loops_fixed;
14483 device_param->kernel_loops_max = kernel_loops_fixed;
14484 }
14485
14486 if (hash_mode == 12500)
14487 {
14488 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14489
14490 device_param->kernel_loops_min = kernel_loops_fixed;
14491 device_param->kernel_loops_max = kernel_loops_fixed;
14492 }
14493
14494 /**
14495 * some algorithms have a maximum kernel-loops count
14496 */
14497
14498 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14499 {
14500 u32 innerloop_cnt = 0;
14501
14502 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14503 {
14504 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14505 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14506 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14507 }
14508 else
14509 {
14510 innerloop_cnt = data.salts_buf[0].salt_iter;
14511 }
14512
14513 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14514 (innerloop_cnt <= device_param->kernel_loops_max))
14515 {
14516 device_param->kernel_loops_max = innerloop_cnt;
14517 }
14518 }
14519
14520 u32 kernel_accel_min = device_param->kernel_accel_min;
14521 u32 kernel_accel_max = device_param->kernel_accel_max;
14522
14523 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14524
14525 size_t size_pws = 4;
14526 size_t size_tmps = 4;
14527 size_t size_hooks = 4;
14528
14529 while (kernel_accel_max >= kernel_accel_min)
14530 {
14531 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14532
14533 // size_pws
14534
14535 size_pws = kernel_power_max * sizeof (pw_t);
14536
14537 // size_tmps
14538
14539 switch (hash_mode)
14540 {
14541 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14542 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14543 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14544 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14545 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14546 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14547 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14548 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14549 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14550 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14551 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14552 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14553 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14554 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14555 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14556 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14557 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14558 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14559 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14560 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14561 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14562 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14563 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14564 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14565 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14566 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14567 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14568 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14569 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14570 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14571 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14572 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14573 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14574 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14575 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14576 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14577 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14578 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14579 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14580 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14581 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14582 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14583 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14584 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14585 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14586 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14587 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14588 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14589 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14590 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14591 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14592 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14593 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14594 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14595 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14596 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14597 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14598 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14599 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14600 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14601 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14602 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14603 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14604 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14605 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14606 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14607 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14608 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14609 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14610 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14611 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14612 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14613 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14614 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14615 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14616 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14617 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14618 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14619 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14620 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14621 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14622 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14623 };
14624
14625 // size_hooks
14626
14627 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14628 {
14629 // none yet
14630 }
14631
14632 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14633 // if not, decrease amplifier and try again
14634
14635 int skip = 0;
14636
14637 const u64 size_total
14638 = bitmap_size
14639 + bitmap_size
14640 + bitmap_size
14641 + bitmap_size
14642 + bitmap_size
14643 + bitmap_size
14644 + bitmap_size
14645 + bitmap_size
14646 + size_bfs
14647 + size_combs
14648 + size_digests
14649 + size_esalts
14650 + size_hooks
14651 + size_markov_css
14652 + size_plains
14653 + size_pws
14654 + size_pws // not a bug
14655 + size_results
14656 + size_root_css
14657 + size_rules
14658 + size_rules_c
14659 + size_salts
14660 + size_scryptV
14661 + size_shown
14662 + size_tm
14663 + size_tmps;
14664
14665 // Don't ask me, ask AMD!
14666
14667 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14668 if (size_total > device_param->device_global_mem) skip = 1;
14669
14670 if (skip == 1)
14671 {
14672 kernel_accel_max--;
14673
14674 continue;
14675 }
14676
14677 break;
14678 }
14679
14680 /*
14681 if (kernel_accel_max == 0)
14682 {
14683 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14684
14685 return -1;
14686 }
14687 */
14688
14689 device_param->kernel_accel_min = kernel_accel_min;
14690 device_param->kernel_accel_max = kernel_accel_max;
14691
14692 /*
14693 if (kernel_accel_max < kernel_accel)
14694 {
14695 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14696
14697 device_param->kernel_accel = kernel_accel_max;
14698 }
14699 */
14700
14701 device_param->size_bfs = size_bfs;
14702 device_param->size_combs = size_combs;
14703 device_param->size_rules = size_rules;
14704 device_param->size_rules_c = size_rules_c;
14705 device_param->size_pws = size_pws;
14706 device_param->size_tmps = size_tmps;
14707 device_param->size_hooks = size_hooks;
14708
14709 // do not confuse kernel_accel_max with kernel_accel here
14710
14711 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14712
14713 device_param->kernel_threads = kernel_threads;
14714 device_param->kernel_power_user = kernel_power;
14715
14716 kernel_power_all += kernel_power;
14717
14718 /**
14719 * default building options
14720 */
14721
14722 char build_opts[1024] = { 0 };
14723
14724 // we don't have sm_* on vendors not NV but it doesn't matter
14725
14726 #if _WIN
14727 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);
14728 #else
14729 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);
14730 #endif
14731
14732 char build_opts_new[1024] = { 0 };
14733
14734 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);
14735
14736 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14737
14738 /*
14739 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14740 {
14741 // we do vectorizing much better than the auto-vectorizer
14742
14743 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14744
14745 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14746 }
14747 */
14748
14749 #ifdef DEBUG
14750 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14751 #endif
14752
14753 /**
14754 * main kernel
14755 */
14756
14757 {
14758 /**
14759 * kernel source filename
14760 */
14761
14762 char source_file[256] = { 0 };
14763
14764 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14765
14766 struct stat sst;
14767
14768 if (stat (source_file, &sst) == -1)
14769 {
14770 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14771
14772 return -1;
14773 }
14774
14775 /**
14776 * kernel cached filename
14777 */
14778
14779 char cached_file[256] = { 0 };
14780
14781 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14782
14783 int cached = 1;
14784
14785 struct stat cst;
14786
14787 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14788 {
14789 cached = 0;
14790 }
14791
14792 /**
14793 * kernel compile or load
14794 */
14795
14796 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14797
14798 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14799
14800 if (force_jit_compilation == -1)
14801 {
14802 if (cached == 0)
14803 {
14804 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14805
14806 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14807
14808 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14809
14810 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14811
14812 #ifdef DEBUG
14813 size_t build_log_size = 0;
14814
14815 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14816
14817 if (build_log_size > 1)
14818 {
14819 char *build_log = (char *) malloc (build_log_size + 1);
14820
14821 memset (build_log, 0, build_log_size + 1);
14822
14823 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14824
14825 puts (build_log);
14826
14827 free (build_log);
14828 }
14829 #endif
14830
14831 if (rc != 0)
14832 {
14833 device_param->skipped = true;
14834
14835 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14836
14837 continue;
14838 }
14839
14840 size_t binary_size;
14841
14842 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14843
14844 u8 *binary = (u8 *) mymalloc (binary_size);
14845
14846 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14847
14848 writeProgramBin (cached_file, binary, binary_size);
14849
14850 local_free (binary);
14851 }
14852 else
14853 {
14854 #ifdef DEBUG
14855 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14856 #endif
14857
14858 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14859
14860 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14861
14862 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14863 }
14864 }
14865 else
14866 {
14867 #ifdef DEBUG
14868 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14869 #endif
14870
14871 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14872
14873 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14874
14875 char build_opts_update[1024] = { 0 };
14876
14877 if (force_jit_compilation == 1500)
14878 {
14879 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14880 }
14881 else if (force_jit_compilation == 8900)
14882 {
14883 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);
14884 }
14885 else
14886 {
14887 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14888 }
14889
14890 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14891
14892 #ifdef DEBUG
14893 size_t build_log_size = 0;
14894
14895 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14896
14897 if (build_log_size > 1)
14898 {
14899 char *build_log = (char *) malloc (build_log_size + 1);
14900
14901 memset (build_log, 0, build_log_size + 1);
14902
14903 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14904
14905 puts (build_log);
14906
14907 free (build_log);
14908 }
14909 #endif
14910
14911 if (rc != 0)
14912 {
14913 device_param->skipped = true;
14914
14915 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14916 }
14917 }
14918
14919 local_free (kernel_lengths);
14920 local_free (kernel_sources[0]);
14921 local_free (kernel_sources);
14922 }
14923
14924 /**
14925 * word generator kernel
14926 */
14927
14928 if (attack_mode != ATTACK_MODE_STRAIGHT)
14929 {
14930 /**
14931 * kernel mp source filename
14932 */
14933
14934 char source_file[256] = { 0 };
14935
14936 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14937
14938 struct stat sst;
14939
14940 if (stat (source_file, &sst) == -1)
14941 {
14942 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14943
14944 return -1;
14945 }
14946
14947 /**
14948 * kernel mp cached filename
14949 */
14950
14951 char cached_file[256] = { 0 };
14952
14953 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14954
14955 int cached = 1;
14956
14957 struct stat cst;
14958
14959 if (stat (cached_file, &cst) == -1)
14960 {
14961 cached = 0;
14962 }
14963
14964 /**
14965 * kernel compile or load
14966 */
14967
14968 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14969
14970 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14971
14972 if (cached == 0)
14973 {
14974 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14975 if (quiet == 0) log_info ("");
14976
14977 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14978
14979 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14980
14981 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14982
14983 if (rc != 0)
14984 {
14985 device_param->skipped = true;
14986
14987 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14988
14989 continue;
14990 }
14991
14992 size_t binary_size;
14993
14994 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14995
14996 u8 *binary = (u8 *) mymalloc (binary_size);
14997
14998 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14999
15000 writeProgramBin (cached_file, binary, binary_size);
15001
15002 local_free (binary);
15003 }
15004 else
15005 {
15006 #ifdef DEBUG
15007 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15008 #endif
15009
15010 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15011
15012 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15013
15014 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15015 }
15016
15017 local_free (kernel_lengths);
15018 local_free (kernel_sources[0]);
15019 local_free (kernel_sources);
15020 }
15021
15022 /**
15023 * amplifier kernel
15024 */
15025
15026 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15027 {
15028
15029 }
15030 else
15031 {
15032 /**
15033 * kernel amp source filename
15034 */
15035
15036 char source_file[256] = { 0 };
15037
15038 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15039
15040 struct stat sst;
15041
15042 if (stat (source_file, &sst) == -1)
15043 {
15044 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15045
15046 return -1;
15047 }
15048
15049 /**
15050 * kernel amp cached filename
15051 */
15052
15053 char cached_file[256] = { 0 };
15054
15055 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15056
15057 int cached = 1;
15058
15059 struct stat cst;
15060
15061 if (stat (cached_file, &cst) == -1)
15062 {
15063 cached = 0;
15064 }
15065
15066 /**
15067 * kernel compile or load
15068 */
15069
15070 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15071
15072 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15073
15074 if (cached == 0)
15075 {
15076 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15077 if (quiet == 0) log_info ("");
15078
15079 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15080
15081 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15082
15083 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15084
15085 if (rc != 0)
15086 {
15087 device_param->skipped = true;
15088
15089 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15090
15091 continue;
15092 }
15093
15094 size_t binary_size;
15095
15096 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15097
15098 u8 *binary = (u8 *) mymalloc (binary_size);
15099
15100 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15101
15102 writeProgramBin (cached_file, binary, binary_size);
15103
15104 local_free (binary);
15105 }
15106 else
15107 {
15108 #ifdef DEBUG
15109 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15110 #endif
15111
15112 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15113
15114 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15115
15116 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15117 }
15118
15119 local_free (kernel_lengths);
15120 local_free (kernel_sources[0]);
15121 local_free (kernel_sources);
15122 }
15123
15124 // some algorithm collide too fast, make that impossible
15125
15126 if (benchmark == 1)
15127 {
15128 ((uint *) digests_buf)[0] = -1;
15129 ((uint *) digests_buf)[1] = -1;
15130 ((uint *) digests_buf)[2] = -1;
15131 ((uint *) digests_buf)[3] = -1;
15132 }
15133
15134 /**
15135 * global buffers
15136 */
15137
15138 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15139 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15140 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15141 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15142 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15143 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15144 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15145 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15146 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15147 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15148 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15149 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15150 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15151 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15152 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15153 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15154 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15155 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15156
15157 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);
15158 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);
15159 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);
15160 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);
15161 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);
15162 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);
15163 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);
15164 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);
15165 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15166 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15167 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15168
15169 /**
15170 * special buffers
15171 */
15172
15173 if (attack_kern == ATTACK_KERN_STRAIGHT)
15174 {
15175 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15176 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15177
15178 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15179 }
15180 else if (attack_kern == ATTACK_KERN_COMBI)
15181 {
15182 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15183 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15184 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15185 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15186 }
15187 else if (attack_kern == ATTACK_KERN_BF)
15188 {
15189 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15190 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15191 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15192 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15193 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15194 }
15195
15196 if (size_esalts)
15197 {
15198 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15199
15200 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15201 }
15202
15203 /**
15204 * main host data
15205 */
15206
15207 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15208
15209 device_param->pws_buf = pws_buf;
15210
15211 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15212
15213 device_param->combs_buf = combs_buf;
15214
15215 void *hooks_buf = mymalloc (size_hooks);
15216
15217 device_param->hooks_buf = hooks_buf;
15218
15219 /**
15220 * kernel args
15221 */
15222
15223 device_param->kernel_params_buf32[21] = bitmap_mask;
15224 device_param->kernel_params_buf32[22] = bitmap_shift1;
15225 device_param->kernel_params_buf32[23] = bitmap_shift2;
15226 device_param->kernel_params_buf32[24] = 0; // salt_pos
15227 device_param->kernel_params_buf32[25] = 0; // loop_pos
15228 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15229 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15230 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15231 device_param->kernel_params_buf32[29] = 0; // digests_offset
15232 device_param->kernel_params_buf32[30] = 0; // combs_mode
15233 device_param->kernel_params_buf32[31] = 0; // gid_max
15234
15235 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15236 ? &device_param->d_pws_buf
15237 : &device_param->d_pws_amp_buf;
15238 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15239 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15240 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15241 device_param->kernel_params[ 4] = &device_param->d_tmps;
15242 device_param->kernel_params[ 5] = &device_param->d_hooks;
15243 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15244 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15245 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15246 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15247 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15248 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15249 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15250 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15251 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15252 device_param->kernel_params[15] = &device_param->d_digests_buf;
15253 device_param->kernel_params[16] = &device_param->d_digests_shown;
15254 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15255 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15256 device_param->kernel_params[19] = &device_param->d_result;
15257 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15258 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15259 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15260 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15261 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15262 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15263 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15264 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15265 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15266 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15267 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15268 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15269
15270 device_param->kernel_params_mp_buf64[3] = 0;
15271 device_param->kernel_params_mp_buf32[4] = 0;
15272 device_param->kernel_params_mp_buf32[5] = 0;
15273 device_param->kernel_params_mp_buf32[6] = 0;
15274 device_param->kernel_params_mp_buf32[7] = 0;
15275 device_param->kernel_params_mp_buf32[8] = 0;
15276
15277 device_param->kernel_params_mp[0] = NULL;
15278 device_param->kernel_params_mp[1] = NULL;
15279 device_param->kernel_params_mp[2] = NULL;
15280 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15281 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15282 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15283 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15284 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15285 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15286
15287 device_param->kernel_params_mp_l_buf64[3] = 0;
15288 device_param->kernel_params_mp_l_buf32[4] = 0;
15289 device_param->kernel_params_mp_l_buf32[5] = 0;
15290 device_param->kernel_params_mp_l_buf32[6] = 0;
15291 device_param->kernel_params_mp_l_buf32[7] = 0;
15292 device_param->kernel_params_mp_l_buf32[8] = 0;
15293 device_param->kernel_params_mp_l_buf32[9] = 0;
15294
15295 device_param->kernel_params_mp_l[0] = NULL;
15296 device_param->kernel_params_mp_l[1] = NULL;
15297 device_param->kernel_params_mp_l[2] = NULL;
15298 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15299 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15300 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15301 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15302 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15303 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15304 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15305
15306 device_param->kernel_params_mp_r_buf64[3] = 0;
15307 device_param->kernel_params_mp_r_buf32[4] = 0;
15308 device_param->kernel_params_mp_r_buf32[5] = 0;
15309 device_param->kernel_params_mp_r_buf32[6] = 0;
15310 device_param->kernel_params_mp_r_buf32[7] = 0;
15311 device_param->kernel_params_mp_r_buf32[8] = 0;
15312
15313 device_param->kernel_params_mp_r[0] = NULL;
15314 device_param->kernel_params_mp_r[1] = NULL;
15315 device_param->kernel_params_mp_r[2] = NULL;
15316 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15317 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15318 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15319 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15320 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15321 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15322
15323 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15324 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15325
15326 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15327 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15328 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15329 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15330 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15331 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15332 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15333
15334 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15335 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15336
15337 device_param->kernel_params_memset_buf32[1] = 0; // value
15338 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15339
15340 device_param->kernel_params_memset[0] = NULL;
15341 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15342 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15343
15344 /**
15345 * kernel name
15346 */
15347
15348 size_t kernel_wgs_tmp;
15349
15350 char kernel_name[64] = { 0 };
15351
15352 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15353 {
15354 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15355 {
15356 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15357
15358 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15359
15360 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15361
15362 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15363
15364 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15365
15366 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15367 }
15368 else
15369 {
15370 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15371
15372 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15373
15374 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15375
15376 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15377
15378 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15379
15380 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15381 }
15382
15383 if (data.attack_mode == ATTACK_MODE_BF)
15384 {
15385 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15386 {
15387 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15388
15389 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15390
15391 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);
15392 }
15393 }
15394 }
15395 else
15396 {
15397 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15398
15399 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15400
15401 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15402
15403 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15404
15405 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15406
15407 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15408
15409 if (opts_type & OPTS_TYPE_HOOK12)
15410 {
15411 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15412
15413 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15414
15415 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);
15416 }
15417
15418 if (opts_type & OPTS_TYPE_HOOK23)
15419 {
15420 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15421
15422 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15423
15424 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);
15425 }
15426 }
15427
15428 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);
15429 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);
15430 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);
15431
15432 for (uint i = 0; i <= 20; i++)
15433 {
15434 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15435 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15436 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15437
15438 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15439 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15440 }
15441
15442 for (uint i = 21; i <= 31; i++)
15443 {
15444 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15445 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15446 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15447
15448 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15449 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15450 }
15451
15452 // GPU memset
15453
15454 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15455
15456 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);
15457
15458 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15459 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15460 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15461
15462 // MP start
15463
15464 if (attack_mode == ATTACK_MODE_BF)
15465 {
15466 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15467 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15468
15469 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);
15470 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);
15471
15472 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15473 {
15474 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15475 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15476 }
15477 }
15478 else if (attack_mode == ATTACK_MODE_HYBRID1)
15479 {
15480 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15481
15482 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);
15483 }
15484 else if (attack_mode == ATTACK_MODE_HYBRID2)
15485 {
15486 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15487
15488 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);
15489 }
15490
15491 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15492 {
15493 // nothing to do
15494 }
15495 else
15496 {
15497 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15498
15499 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);
15500 }
15501
15502 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15503 {
15504 // nothing to do
15505 }
15506 else
15507 {
15508 for (uint i = 0; i < 5; i++)
15509 {
15510 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15511 }
15512
15513 for (uint i = 5; i < 7; i++)
15514 {
15515 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15516 }
15517 }
15518
15519 // maybe this has been updated by clGetKernelWorkGroupInfo()
15520 // value can only be decreased, so we don't need to reallocate buffers
15521
15522 device_param->kernel_threads = kernel_threads;
15523
15524 // zero some data buffers
15525
15526 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15527 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15528 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15529 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15530 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15531 run_kernel_bzero (device_param, device_param->d_result, size_results);
15532
15533 /**
15534 * special buffers
15535 */
15536
15537 if (attack_kern == ATTACK_KERN_STRAIGHT)
15538 {
15539 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15540 }
15541 else if (attack_kern == ATTACK_KERN_COMBI)
15542 {
15543 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15544 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15545 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15546 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15547 }
15548 else if (attack_kern == ATTACK_KERN_BF)
15549 {
15550 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15551 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15552 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15553 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15554 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15555 }
15556
15557 #if defined(HAVE_HWMON)
15558
15559 /**
15560 * Store thermal target temperature so we can send a notice to user
15561 */
15562
15563 if (gpu_temp_disable == 0)
15564 {
15565 const int gpu_temp_threshold_slowdown = hm_get_threshold_slowdown_with_device_id (device_id);
15566
15567 data.hm_device[device_id].gpu_temp_threshold_slowdown = (gpu_temp_threshold_slowdown == -1) ? 100000 : gpu_temp_threshold_slowdown;
15568 }
15569
15570 /**
15571 * Store initial fanspeed if gpu_temp_retain is enabled
15572 */
15573
15574 if (gpu_temp_disable == 0)
15575 {
15576 if (gpu_temp_retain != 0)
15577 {
15578 hc_thread_mutex_lock (mux_adl);
15579
15580 if (data.hm_device[device_id].fan_get_supported == 1)
15581 {
15582 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
15583 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
15584
15585 temp_retain_fanspeed_value[device_id] = fanspeed;
15586 temp_retain_fanpolicy_value[device_id] = fanpolicy;
15587
15588 // we also set it to tell the OS we take control over the fan and it's automatic controller
15589 // if it was set to automatic. we do not control user-defined fanspeeds.
15590
15591 if (fanpolicy == 1)
15592 {
15593 data.hm_device[device_id].fan_set_supported = 1;
15594
15595 int rc = -1;
15596
15597 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15598 {
15599 rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed, 1);
15600 }
15601 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15602 {
15603
15604 }
15605
15606 if (rc == 0)
15607 {
15608 data.hm_device[device_id].fan_set_supported = 1;
15609 }
15610 else
15611 {
15612 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
15613
15614 data.hm_device[device_id].fan_set_supported = 0;
15615 }
15616 }
15617 else
15618 {
15619 data.hm_device[device_id].fan_set_supported = 0;
15620 }
15621 }
15622
15623 hc_thread_mutex_unlock (mux_adl);
15624 }
15625 }
15626
15627 /**
15628 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15629 */
15630
15631 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15632 {
15633 hc_thread_mutex_lock (mux_adl);
15634
15635 if (data.hm_device[device_id].od_version == 6)
15636 {
15637 int ADL_rc;
15638
15639 // check powertune capabilities first, if not available then skip device
15640
15641 int powertune_supported = 0;
15642
15643 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15644 {
15645 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15646
15647 return (-1);
15648 }
15649
15650 if (powertune_supported != 0)
15651 {
15652 // powercontrol settings
15653
15654 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15655
15656 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15657 {
15658 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15659 }
15660
15661 if (ADL_rc != ADL_OK)
15662 {
15663 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15664
15665 return (-1);
15666 }
15667
15668 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15669 {
15670 log_error ("ERROR: Failed to set new ADL PowerControl values");
15671
15672 return (-1);
15673 }
15674
15675 // clocks
15676
15677 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15678
15679 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15680
15681 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)
15682 {
15683 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15684
15685 return (-1);
15686 }
15687
15688 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15689
15690 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15691
15692 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15693 {
15694 log_error ("ERROR: Failed to get ADL device capabilities");
15695
15696 return (-1);
15697 }
15698
15699 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15700 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15701
15702 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15703 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15704
15705 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15706 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15707
15708 // warning if profile has too low max values
15709
15710 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15711 {
15712 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15713 }
15714
15715 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15716 {
15717 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15718 }
15719
15720 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15721
15722 performance_state->iNumberOfPerformanceLevels = 2;
15723
15724 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15725 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15726 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15727 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15728
15729 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)
15730 {
15731 log_info ("ERROR: Failed to set ADL performance state");
15732
15733 return (-1);
15734 }
15735
15736 local_free (performance_state);
15737 }
15738 }
15739
15740 hc_thread_mutex_unlock (mux_adl);
15741 }
15742
15743 #endif // HAVE_HWMON
15744 }
15745
15746 data.kernel_power_all = kernel_power_all;
15747
15748 if (data.quiet == 0) log_info_nn ("");
15749
15750 /**
15751 * In benchmark-mode, inform user which algorithm is checked
15752 */
15753
15754 if (benchmark == 1)
15755 {
15756 if (machine_readable == 0)
15757 {
15758 quiet = 0;
15759
15760 data.quiet = quiet;
15761
15762 char *hash_type = strhashtype (data.hash_mode); // not a bug
15763
15764 log_info ("Hashtype: %s", hash_type);
15765 log_info ("");
15766 }
15767 }
15768
15769 /**
15770 * keep track of the progress
15771 */
15772
15773 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15774 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15775 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15776
15777 /**
15778 * open filehandles
15779 */
15780
15781 #if _WIN
15782 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15783 {
15784 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15785
15786 return (-1);
15787 }
15788
15789 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15790 {
15791 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15792
15793 return (-1);
15794 }
15795
15796 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15797 {
15798 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15799
15800 return (-1);
15801 }
15802 #endif
15803
15804 /**
15805 * dictionary pad
15806 */
15807
15808 segment_size *= (1024 * 1024);
15809
15810 data.segment_size = segment_size;
15811
15812 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15813
15814 wl_data->buf = (char *) mymalloc (segment_size);
15815 wl_data->avail = segment_size;
15816 wl_data->incr = segment_size;
15817 wl_data->cnt = 0;
15818 wl_data->pos = 0;
15819
15820 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15821
15822 data.wordlist_mode = wordlist_mode;
15823
15824 cs_t *css_buf = NULL;
15825 uint css_cnt = 0;
15826 uint dictcnt = 0;
15827 uint maskcnt = 1;
15828 char **masks = NULL;
15829 char **dictfiles = NULL;
15830
15831 uint mask_from_file = 0;
15832
15833 if (attack_mode == ATTACK_MODE_STRAIGHT)
15834 {
15835 if (wordlist_mode == WL_MODE_FILE)
15836 {
15837 int wls_left = myargc - (optind + 1);
15838
15839 for (int i = 0; i < wls_left; i++)
15840 {
15841 char *l0_filename = myargv[optind + 1 + i];
15842
15843 struct stat l0_stat;
15844
15845 if (stat (l0_filename, &l0_stat) == -1)
15846 {
15847 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15848
15849 return (-1);
15850 }
15851
15852 uint is_dir = S_ISDIR (l0_stat.st_mode);
15853
15854 if (is_dir == 0)
15855 {
15856 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15857
15858 dictcnt++;
15859
15860 dictfiles[dictcnt - 1] = l0_filename;
15861 }
15862 else
15863 {
15864 // do not allow --keyspace w/ a directory
15865
15866 if (keyspace == 1)
15867 {
15868 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15869
15870 return (-1);
15871 }
15872
15873 char **dictionary_files = NULL;
15874
15875 dictionary_files = scan_directory (l0_filename);
15876
15877 if (dictionary_files != NULL)
15878 {
15879 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15880
15881 for (int d = 0; dictionary_files[d] != NULL; d++)
15882 {
15883 char *l1_filename = dictionary_files[d];
15884
15885 struct stat l1_stat;
15886
15887 if (stat (l1_filename, &l1_stat) == -1)
15888 {
15889 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15890
15891 return (-1);
15892 }
15893
15894 if (S_ISREG (l1_stat.st_mode))
15895 {
15896 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15897
15898 dictcnt++;
15899
15900 dictfiles[dictcnt - 1] = strdup (l1_filename);
15901 }
15902 }
15903 }
15904
15905 local_free (dictionary_files);
15906 }
15907 }
15908
15909 if (dictcnt < 1)
15910 {
15911 log_error ("ERROR: No usable dictionary file found.");
15912
15913 return (-1);
15914 }
15915 }
15916 else if (wordlist_mode == WL_MODE_STDIN)
15917 {
15918 dictcnt = 1;
15919 }
15920 }
15921 else if (attack_mode == ATTACK_MODE_COMBI)
15922 {
15923 // display
15924
15925 char *dictfile1 = myargv[optind + 1 + 0];
15926 char *dictfile2 = myargv[optind + 1 + 1];
15927
15928 // find the bigger dictionary and use as base
15929
15930 FILE *fp1 = NULL;
15931 FILE *fp2 = NULL;
15932
15933 struct stat tmp_stat;
15934
15935 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15936 {
15937 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15938
15939 return (-1);
15940 }
15941
15942 if (stat (dictfile1, &tmp_stat) == -1)
15943 {
15944 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15945
15946 fclose (fp1);
15947
15948 return (-1);
15949 }
15950
15951 if (S_ISDIR (tmp_stat.st_mode))
15952 {
15953 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15954
15955 fclose (fp1);
15956
15957 return (-1);
15958 }
15959
15960 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15961 {
15962 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15963
15964 fclose (fp1);
15965
15966 return (-1);
15967 }
15968
15969 if (stat (dictfile2, &tmp_stat) == -1)
15970 {
15971 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15972
15973 fclose (fp1);
15974 fclose (fp2);
15975
15976 return (-1);
15977 }
15978
15979 if (S_ISDIR (tmp_stat.st_mode))
15980 {
15981 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15982
15983 fclose (fp1);
15984 fclose (fp2);
15985
15986 return (-1);
15987 }
15988
15989 data.combs_cnt = 1;
15990
15991 data.quiet = 1;
15992
15993 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15994
15995 data.quiet = quiet;
15996
15997 if (words1_cnt == 0)
15998 {
15999 log_error ("ERROR: %s: empty file", dictfile1);
16000
16001 fclose (fp1);
16002 fclose (fp2);
16003
16004 return (-1);
16005 }
16006
16007 data.combs_cnt = 1;
16008
16009 data.quiet = 1;
16010
16011 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16012
16013 data.quiet = quiet;
16014
16015 if (words2_cnt == 0)
16016 {
16017 log_error ("ERROR: %s: empty file", dictfile2);
16018
16019 fclose (fp1);
16020 fclose (fp2);
16021
16022 return (-1);
16023 }
16024
16025 fclose (fp1);
16026 fclose (fp2);
16027
16028 data.dictfile = dictfile1;
16029 data.dictfile2 = dictfile2;
16030
16031 if (words1_cnt >= words2_cnt)
16032 {
16033 data.combs_cnt = words2_cnt;
16034 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16035
16036 dictfiles = &data.dictfile;
16037
16038 dictcnt = 1;
16039 }
16040 else
16041 {
16042 data.combs_cnt = words1_cnt;
16043 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16044
16045 dictfiles = &data.dictfile2;
16046
16047 dictcnt = 1;
16048
16049 // we also have to switch wordlist related rules!
16050
16051 char *tmpc = data.rule_buf_l;
16052
16053 data.rule_buf_l = data.rule_buf_r;
16054 data.rule_buf_r = tmpc;
16055
16056 int tmpi = data.rule_len_l;
16057
16058 data.rule_len_l = data.rule_len_r;
16059 data.rule_len_r = tmpi;
16060 }
16061 }
16062 else if (attack_mode == ATTACK_MODE_BF)
16063 {
16064 char *mask = NULL;
16065
16066 maskcnt = 0;
16067
16068 if (benchmark == 0)
16069 {
16070 mask = myargv[optind + 1];
16071
16072 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16073
16074 if ((optind + 2) <= myargc)
16075 {
16076 struct stat file_stat;
16077
16078 if (stat (mask, &file_stat) == -1)
16079 {
16080 maskcnt = 1;
16081
16082 masks[maskcnt - 1] = mystrdup (mask);
16083 }
16084 else
16085 {
16086 int wls_left = myargc - (optind + 1);
16087
16088 uint masks_avail = INCR_MASKS;
16089
16090 for (int i = 0; i < wls_left; i++)
16091 {
16092 if (i != 0)
16093 {
16094 mask = myargv[optind + 1 + i];
16095
16096 if (stat (mask, &file_stat) == -1)
16097 {
16098 log_error ("ERROR: %s: %s", mask, strerror (errno));
16099
16100 return (-1);
16101 }
16102 }
16103
16104 uint is_file = S_ISREG (file_stat.st_mode);
16105
16106 if (is_file == 1)
16107 {
16108 FILE *mask_fp;
16109
16110 if ((mask_fp = fopen (mask, "r")) == NULL)
16111 {
16112 log_error ("ERROR: %s: %s", mask, strerror (errno));
16113
16114 return (-1);
16115 }
16116
16117 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16118
16119 while (!feof (mask_fp))
16120 {
16121 memset (line_buf, 0, HCBUFSIZ);
16122
16123 int line_len = fgetl (mask_fp, line_buf);
16124
16125 if (line_len == 0) continue;
16126
16127 if (line_buf[0] == '#') continue;
16128
16129 if (masks_avail == maskcnt)
16130 {
16131 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16132
16133 masks_avail += INCR_MASKS;
16134 }
16135
16136 masks[maskcnt] = mystrdup (line_buf);
16137
16138 maskcnt++;
16139 }
16140
16141 myfree (line_buf);
16142
16143 fclose (mask_fp);
16144 }
16145 else
16146 {
16147 log_error ("ERROR: %s: unsupported file-type", mask);
16148
16149 return (-1);
16150 }
16151 }
16152
16153 mask_from_file = 1;
16154 }
16155 }
16156 else
16157 {
16158 custom_charset_1 = (char *) "?l?d?u";
16159 custom_charset_2 = (char *) "?l?d";
16160 custom_charset_3 = (char *) "?l?d*!$@_";
16161
16162 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16163 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16164 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16165
16166 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16167
16168 wordlist_mode = WL_MODE_MASK;
16169
16170 data.wordlist_mode = wordlist_mode;
16171
16172 increment = 1;
16173
16174 maskcnt = 1;
16175 }
16176 }
16177 else
16178 {
16179 /**
16180 * generate full masks and charsets
16181 */
16182
16183 masks = (char **) mymalloc (sizeof (char *));
16184
16185 switch (hash_mode)
16186 {
16187 case 1731: pw_min = 5;
16188 pw_max = 5;
16189 mask = mystrdup ("?b?b?b?b?b");
16190 break;
16191 case 12500: pw_min = 5;
16192 pw_max = 5;
16193 mask = mystrdup ("?b?b?b?b?b");
16194 break;
16195 default: pw_min = 7;
16196 pw_max = 7;
16197 mask = mystrdup ("?b?b?b?b?b?b?b");
16198 break;
16199 }
16200
16201 maskcnt = 1;
16202
16203 masks[maskcnt - 1] = mystrdup (mask);
16204
16205 wordlist_mode = WL_MODE_MASK;
16206
16207 data.wordlist_mode = wordlist_mode;
16208
16209 increment = 1;
16210 }
16211
16212 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16213
16214 if (increment)
16215 {
16216 if (increment_min > pw_min) pw_min = increment_min;
16217
16218 if (increment_max < pw_max) pw_max = increment_max;
16219 }
16220 }
16221 else if (attack_mode == ATTACK_MODE_HYBRID1)
16222 {
16223 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16224
16225 // display
16226
16227 char *mask = myargv[myargc - 1];
16228
16229 maskcnt = 0;
16230
16231 masks = (char **) mymalloc (1 * sizeof (char *));
16232
16233 // mod
16234
16235 struct stat file_stat;
16236
16237 if (stat (mask, &file_stat) == -1)
16238 {
16239 maskcnt = 1;
16240
16241 masks[maskcnt - 1] = mystrdup (mask);
16242 }
16243 else
16244 {
16245 uint is_file = S_ISREG (file_stat.st_mode);
16246
16247 if (is_file == 1)
16248 {
16249 FILE *mask_fp;
16250
16251 if ((mask_fp = fopen (mask, "r")) == NULL)
16252 {
16253 log_error ("ERROR: %s: %s", mask, strerror (errno));
16254
16255 return (-1);
16256 }
16257
16258 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16259
16260 uint masks_avail = 1;
16261
16262 while (!feof (mask_fp))
16263 {
16264 memset (line_buf, 0, HCBUFSIZ);
16265
16266 int line_len = fgetl (mask_fp, line_buf);
16267
16268 if (line_len == 0) continue;
16269
16270 if (line_buf[0] == '#') continue;
16271
16272 if (masks_avail == maskcnt)
16273 {
16274 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16275
16276 masks_avail += INCR_MASKS;
16277 }
16278
16279 masks[maskcnt] = mystrdup (line_buf);
16280
16281 maskcnt++;
16282 }
16283
16284 myfree (line_buf);
16285
16286 fclose (mask_fp);
16287
16288 mask_from_file = 1;
16289 }
16290 else
16291 {
16292 maskcnt = 1;
16293
16294 masks[maskcnt - 1] = mystrdup (mask);
16295 }
16296 }
16297
16298 // base
16299
16300 int wls_left = myargc - (optind + 2);
16301
16302 for (int i = 0; i < wls_left; i++)
16303 {
16304 char *filename = myargv[optind + 1 + i];
16305
16306 struct stat file_stat;
16307
16308 if (stat (filename, &file_stat) == -1)
16309 {
16310 log_error ("ERROR: %s: %s", filename, strerror (errno));
16311
16312 return (-1);
16313 }
16314
16315 uint is_dir = S_ISDIR (file_stat.st_mode);
16316
16317 if (is_dir == 0)
16318 {
16319 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16320
16321 dictcnt++;
16322
16323 dictfiles[dictcnt - 1] = filename;
16324 }
16325 else
16326 {
16327 // do not allow --keyspace w/ a directory
16328
16329 if (keyspace == 1)
16330 {
16331 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16332
16333 return (-1);
16334 }
16335
16336 char **dictionary_files = NULL;
16337
16338 dictionary_files = scan_directory (filename);
16339
16340 if (dictionary_files != NULL)
16341 {
16342 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16343
16344 for (int d = 0; dictionary_files[d] != NULL; d++)
16345 {
16346 char *l1_filename = dictionary_files[d];
16347
16348 struct stat l1_stat;
16349
16350 if (stat (l1_filename, &l1_stat) == -1)
16351 {
16352 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16353
16354 return (-1);
16355 }
16356
16357 if (S_ISREG (l1_stat.st_mode))
16358 {
16359 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16360
16361 dictcnt++;
16362
16363 dictfiles[dictcnt - 1] = strdup (l1_filename);
16364 }
16365 }
16366 }
16367
16368 local_free (dictionary_files);
16369 }
16370 }
16371
16372 if (dictcnt < 1)
16373 {
16374 log_error ("ERROR: No usable dictionary file found.");
16375
16376 return (-1);
16377 }
16378
16379 if (increment)
16380 {
16381 maskcnt = 0;
16382
16383 uint mask_min = increment_min; // we can't reject smaller masks here
16384 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16385
16386 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16387 {
16388 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16389
16390 if (cur_mask == NULL) break;
16391
16392 masks[maskcnt] = cur_mask;
16393
16394 maskcnt++;
16395
16396 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16397 }
16398 }
16399 }
16400 else if (attack_mode == ATTACK_MODE_HYBRID2)
16401 {
16402 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16403
16404 // display
16405
16406 char *mask = myargv[optind + 1 + 0];
16407
16408 maskcnt = 0;
16409
16410 masks = (char **) mymalloc (1 * sizeof (char *));
16411
16412 // mod
16413
16414 struct stat file_stat;
16415
16416 if (stat (mask, &file_stat) == -1)
16417 {
16418 maskcnt = 1;
16419
16420 masks[maskcnt - 1] = mystrdup (mask);
16421 }
16422 else
16423 {
16424 uint is_file = S_ISREG (file_stat.st_mode);
16425
16426 if (is_file == 1)
16427 {
16428 FILE *mask_fp;
16429
16430 if ((mask_fp = fopen (mask, "r")) == NULL)
16431 {
16432 log_error ("ERROR: %s: %s", mask, strerror (errno));
16433
16434 return (-1);
16435 }
16436
16437 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16438
16439 uint masks_avail = 1;
16440
16441 while (!feof (mask_fp))
16442 {
16443 memset (line_buf, 0, HCBUFSIZ);
16444
16445 int line_len = fgetl (mask_fp, line_buf);
16446
16447 if (line_len == 0) continue;
16448
16449 if (line_buf[0] == '#') continue;
16450
16451 if (masks_avail == maskcnt)
16452 {
16453 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16454
16455 masks_avail += INCR_MASKS;
16456 }
16457
16458 masks[maskcnt] = mystrdup (line_buf);
16459
16460 maskcnt++;
16461 }
16462
16463 myfree (line_buf);
16464
16465 fclose (mask_fp);
16466
16467 mask_from_file = 1;
16468 }
16469 else
16470 {
16471 maskcnt = 1;
16472
16473 masks[maskcnt - 1] = mystrdup (mask);
16474 }
16475 }
16476
16477 // base
16478
16479 int wls_left = myargc - (optind + 2);
16480
16481 for (int i = 0; i < wls_left; i++)
16482 {
16483 char *filename = myargv[optind + 2 + i];
16484
16485 struct stat file_stat;
16486
16487 if (stat (filename, &file_stat) == -1)
16488 {
16489 log_error ("ERROR: %s: %s", filename, strerror (errno));
16490
16491 return (-1);
16492 }
16493
16494 uint is_dir = S_ISDIR (file_stat.st_mode);
16495
16496 if (is_dir == 0)
16497 {
16498 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16499
16500 dictcnt++;
16501
16502 dictfiles[dictcnt - 1] = filename;
16503 }
16504 else
16505 {
16506 // do not allow --keyspace w/ a directory
16507
16508 if (keyspace == 1)
16509 {
16510 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16511
16512 return (-1);
16513 }
16514
16515 char **dictionary_files = NULL;
16516
16517 dictionary_files = scan_directory (filename);
16518
16519 if (dictionary_files != NULL)
16520 {
16521 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16522
16523 for (int d = 0; dictionary_files[d] != NULL; d++)
16524 {
16525 char *l1_filename = dictionary_files[d];
16526
16527 struct stat l1_stat;
16528
16529 if (stat (l1_filename, &l1_stat) == -1)
16530 {
16531 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16532
16533 return (-1);
16534 }
16535
16536 if (S_ISREG (l1_stat.st_mode))
16537 {
16538 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16539
16540 dictcnt++;
16541
16542 dictfiles[dictcnt - 1] = strdup (l1_filename);
16543 }
16544 }
16545 }
16546
16547 local_free (dictionary_files);
16548 }
16549 }
16550
16551 if (dictcnt < 1)
16552 {
16553 log_error ("ERROR: No usable dictionary file found.");
16554
16555 return (-1);
16556 }
16557
16558 if (increment)
16559 {
16560 maskcnt = 0;
16561
16562 uint mask_min = increment_min; // we can't reject smaller masks here
16563 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16564
16565 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16566 {
16567 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16568
16569 if (cur_mask == NULL) break;
16570
16571 masks[maskcnt] = cur_mask;
16572
16573 maskcnt++;
16574
16575 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16576 }
16577 }
16578 }
16579
16580 data.pw_min = pw_min;
16581 data.pw_max = pw_max;
16582
16583 /**
16584 * weak hash check
16585 */
16586
16587 if (weak_hash_threshold >= salts_cnt)
16588 {
16589 hc_device_param_t *device_param = NULL;
16590
16591 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16592 {
16593 device_param = &data.devices_param[device_id];
16594
16595 if (device_param->skipped) continue;
16596
16597 break;
16598 }
16599
16600 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16601
16602 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16603 {
16604 weak_hash_check (device_param, salt_pos);
16605 }
16606
16607 // Display hack, guarantee that there is at least one \r before real start
16608
16609 //if (data.quiet == 0) log_info ("");
16610 }
16611
16612 /**
16613 * status and monitor threads
16614 */
16615
16616 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16617
16618 hc_thread_t i_thread = 0;
16619
16620 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16621 {
16622 hc_thread_create (i_thread, thread_keypress, &benchmark);
16623 }
16624
16625 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16626
16627 uint ni_threads_cnt = 0;
16628
16629 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16630
16631 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16632
16633 ni_threads_cnt++;
16634
16635 /**
16636 * Outfile remove
16637 */
16638
16639 if (keyspace == 0)
16640 {
16641 if (outfile_check_timer != 0)
16642 {
16643 if (data.outfile_check_directory != NULL)
16644 {
16645 if ((hash_mode != 5200) &&
16646 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16647 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16648 (hash_mode != 9000))
16649 {
16650 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16651
16652 ni_threads_cnt++;
16653 }
16654 else
16655 {
16656 outfile_check_timer = 0;
16657 }
16658 }
16659 else
16660 {
16661 outfile_check_timer = 0;
16662 }
16663 }
16664 }
16665
16666 /**
16667 * Inform the user if we got some hashes remove because of the pot file remove feature
16668 */
16669
16670 if (data.quiet == 0)
16671 {
16672 if (potfile_remove_cracks > 0)
16673 {
16674 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16675 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16676 }
16677 }
16678
16679 data.outfile_check_timer = outfile_check_timer;
16680
16681 /**
16682 * main loop
16683 */
16684
16685 char **induction_dictionaries = NULL;
16686
16687 int induction_dictionaries_cnt = 0;
16688
16689 hcstat_table_t *root_table_buf = NULL;
16690 hcstat_table_t *markov_table_buf = NULL;
16691
16692 uint initial_restore_done = 0;
16693
16694 data.maskcnt = maskcnt;
16695
16696 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16697 {
16698 if (data.devices_status == STATUS_CRACKED) break;
16699
16700 data.devices_status = STATUS_INIT;
16701
16702 if (maskpos > rd->maskpos)
16703 {
16704 rd->dictpos = 0;
16705 }
16706
16707 rd->maskpos = maskpos;
16708 data.maskpos = maskpos;
16709
16710 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16711 {
16712 char *mask = masks[maskpos];
16713
16714 if (mask_from_file == 1)
16715 {
16716 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16717
16718 char *str_ptr;
16719 uint str_pos;
16720
16721 uint mask_offset = 0;
16722
16723 uint separator_cnt;
16724
16725 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16726 {
16727 str_ptr = strstr (mask + mask_offset, ",");
16728
16729 if (str_ptr == NULL) break;
16730
16731 str_pos = str_ptr - mask;
16732
16733 // escaped separator, i.e. "\,"
16734
16735 if (str_pos > 0)
16736 {
16737 if (mask[str_pos - 1] == '\\')
16738 {
16739 separator_cnt --;
16740
16741 mask_offset = str_pos + 1;
16742
16743 continue;
16744 }
16745 }
16746
16747 // reset the offset
16748
16749 mask_offset = 0;
16750
16751 mask[str_pos] = '\0';
16752
16753 switch (separator_cnt)
16754 {
16755 case 0:
16756 mp_reset_usr (mp_usr, 0);
16757
16758 custom_charset_1 = mask;
16759 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16760 break;
16761
16762 case 1:
16763 mp_reset_usr (mp_usr, 1);
16764
16765 custom_charset_2 = mask;
16766 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16767 break;
16768
16769 case 2:
16770 mp_reset_usr (mp_usr, 2);
16771
16772 custom_charset_3 = mask;
16773 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16774 break;
16775
16776 case 3:
16777 mp_reset_usr (mp_usr, 3);
16778
16779 custom_charset_4 = mask;
16780 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16781 break;
16782 }
16783
16784 mask = mask + str_pos + 1;
16785 }
16786 }
16787
16788 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16789 {
16790 if (maskpos > 0)
16791 {
16792 local_free (css_buf);
16793 local_free (data.root_css_buf);
16794 local_free (data.markov_css_buf);
16795
16796 local_free (masks[maskpos - 1]);
16797 }
16798
16799 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16800
16801 data.mask = mask;
16802 data.css_cnt = css_cnt;
16803 data.css_buf = css_buf;
16804
16805 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16806
16807 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16808
16809 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16810 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16811
16812 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16813
16814 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16815
16816 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16817 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16818
16819 data.root_css_buf = root_css_buf;
16820 data.markov_css_buf = markov_css_buf;
16821
16822 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16823
16824 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16825
16826 local_free (root_table_buf);
16827 local_free (markov_table_buf);
16828
16829 // args
16830
16831 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16832 {
16833 hc_device_param_t *device_param = &data.devices_param[device_id];
16834
16835 if (device_param->skipped) continue;
16836
16837 device_param->kernel_params_mp[0] = &device_param->d_combs;
16838 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16839 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16840
16841 device_param->kernel_params_mp_buf64[3] = 0;
16842 device_param->kernel_params_mp_buf32[4] = css_cnt;
16843 device_param->kernel_params_mp_buf32[5] = 0;
16844 device_param->kernel_params_mp_buf32[6] = 0;
16845 device_param->kernel_params_mp_buf32[7] = 0;
16846
16847 if (attack_mode == ATTACK_MODE_HYBRID1)
16848 {
16849 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16850 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16851 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16852 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16853 }
16854 else if (attack_mode == ATTACK_MODE_HYBRID2)
16855 {
16856 device_param->kernel_params_mp_buf32[5] = 0;
16857 device_param->kernel_params_mp_buf32[6] = 0;
16858 device_param->kernel_params_mp_buf32[7] = 0;
16859 }
16860
16861 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]);
16862 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]);
16863 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]);
16864
16865 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);
16866 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);
16867 }
16868 }
16869 else if (attack_mode == ATTACK_MODE_BF)
16870 {
16871 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16872
16873 if (increment)
16874 {
16875 for (uint i = 0; i < dictcnt; i++)
16876 {
16877 local_free (dictfiles[i]);
16878 }
16879
16880 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16881 {
16882 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16883
16884 if (l1_filename == NULL) break;
16885
16886 dictcnt++;
16887
16888 dictfiles[dictcnt - 1] = l1_filename;
16889 }
16890 }
16891 else
16892 {
16893 dictcnt++;
16894
16895 dictfiles[dictcnt - 1] = mask;
16896 }
16897
16898 if (dictcnt == 0)
16899 {
16900 log_error ("ERROR: Mask is too small");
16901
16902 return (-1);
16903 }
16904 }
16905 }
16906
16907 free (induction_dictionaries);
16908
16909 // induction_dictionaries_cnt = 0; // implied
16910
16911 if (attack_mode != ATTACK_MODE_BF)
16912 {
16913 if (keyspace == 0)
16914 {
16915 induction_dictionaries = scan_directory (induction_directory);
16916
16917 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16918 }
16919 }
16920
16921 if (induction_dictionaries_cnt)
16922 {
16923 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16924 }
16925
16926 /**
16927 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16928 */
16929 if (keyspace == 1)
16930 {
16931 if ((maskcnt > 1) || (dictcnt > 1))
16932 {
16933 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16934
16935 return (-1);
16936 }
16937 }
16938
16939 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16940 {
16941 char *subid = logfile_generate_subid ();
16942
16943 data.subid = subid;
16944
16945 logfile_sub_msg ("START");
16946
16947 data.devices_status = STATUS_INIT;
16948
16949 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16950 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16951 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16952
16953 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16954
16955 data.cpt_pos = 0;
16956
16957 data.cpt_start = time (NULL);
16958
16959 data.cpt_total = 0;
16960
16961 if (data.restore == 0)
16962 {
16963 rd->words_cur = skip;
16964
16965 skip = 0;
16966
16967 data.skip = 0;
16968 }
16969
16970 data.ms_paused = 0;
16971
16972 data.words_cur = rd->words_cur;
16973
16974 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16975 {
16976 hc_device_param_t *device_param = &data.devices_param[device_id];
16977
16978 if (device_param->skipped) continue;
16979
16980 device_param->speed_pos = 0;
16981
16982 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16983 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16984
16985 device_param->exec_pos = 0;
16986
16987 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16988
16989 device_param->kernel_power = device_param->kernel_power_user;
16990
16991 device_param->outerloop_pos = 0;
16992 device_param->outerloop_left = 0;
16993 device_param->innerloop_pos = 0;
16994 device_param->innerloop_left = 0;
16995
16996 // some more resets:
16997
16998 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16999
17000 device_param->pws_cnt = 0;
17001
17002 device_param->words_off = 0;
17003 device_param->words_done = 0;
17004 }
17005
17006 data.kernel_power_div = 0;
17007
17008 // figure out some workload
17009
17010 if (attack_mode == ATTACK_MODE_STRAIGHT)
17011 {
17012 if (data.wordlist_mode == WL_MODE_FILE)
17013 {
17014 char *dictfile = NULL;
17015
17016 if (induction_dictionaries_cnt)
17017 {
17018 dictfile = induction_dictionaries[0];
17019 }
17020 else
17021 {
17022 dictfile = dictfiles[dictpos];
17023 }
17024
17025 data.dictfile = dictfile;
17026
17027 logfile_sub_string (dictfile);
17028
17029 for (uint i = 0; i < rp_files_cnt; i++)
17030 {
17031 logfile_sub_var_string ("rulefile", rp_files[i]);
17032 }
17033
17034 FILE *fd2 = fopen (dictfile, "rb");
17035
17036 if (fd2 == NULL)
17037 {
17038 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17039
17040 return (-1);
17041 }
17042
17043 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17044
17045 fclose (fd2);
17046
17047 if (data.words_cnt == 0)
17048 {
17049 if (data.devices_status == STATUS_CRACKED) break;
17050 if (data.devices_status == STATUS_ABORTED) break;
17051
17052 dictpos++;
17053
17054 continue;
17055 }
17056 }
17057 }
17058 else if (attack_mode == ATTACK_MODE_COMBI)
17059 {
17060 char *dictfile = data.dictfile;
17061 char *dictfile2 = data.dictfile2;
17062
17063 logfile_sub_string (dictfile);
17064 logfile_sub_string (dictfile2);
17065
17066 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17067 {
17068 FILE *fd2 = fopen (dictfile, "rb");
17069
17070 if (fd2 == NULL)
17071 {
17072 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17073
17074 return (-1);
17075 }
17076
17077 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17078
17079 fclose (fd2);
17080 }
17081 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17082 {
17083 FILE *fd2 = fopen (dictfile2, "rb");
17084
17085 if (fd2 == NULL)
17086 {
17087 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17088
17089 return (-1);
17090 }
17091
17092 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17093
17094 fclose (fd2);
17095 }
17096
17097 if (data.words_cnt == 0)
17098 {
17099 if (data.devices_status == STATUS_CRACKED) break;
17100 if (data.devices_status == STATUS_ABORTED) break;
17101
17102 dictpos++;
17103
17104 continue;
17105 }
17106 }
17107 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17108 {
17109 char *dictfile = NULL;
17110
17111 if (induction_dictionaries_cnt)
17112 {
17113 dictfile = induction_dictionaries[0];
17114 }
17115 else
17116 {
17117 dictfile = dictfiles[dictpos];
17118 }
17119
17120 data.dictfile = dictfile;
17121
17122 char *mask = data.mask;
17123
17124 logfile_sub_string (dictfile);
17125 logfile_sub_string (mask);
17126
17127 FILE *fd2 = fopen (dictfile, "rb");
17128
17129 if (fd2 == NULL)
17130 {
17131 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17132
17133 return (-1);
17134 }
17135
17136 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17137
17138 fclose (fd2);
17139
17140 if (data.words_cnt == 0)
17141 {
17142 if (data.devices_status == STATUS_CRACKED) break;
17143 if (data.devices_status == STATUS_ABORTED) break;
17144
17145 dictpos++;
17146
17147 continue;
17148 }
17149 }
17150 else if (attack_mode == ATTACK_MODE_BF)
17151 {
17152 local_free (css_buf);
17153 local_free (data.root_css_buf);
17154 local_free (data.markov_css_buf);
17155
17156 char *mask = dictfiles[dictpos];
17157
17158 logfile_sub_string (mask);
17159
17160 // base
17161
17162 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17163
17164 if (opts_type & OPTS_TYPE_PT_UNICODE)
17165 {
17166 uint css_cnt_unicode = css_cnt * 2;
17167
17168 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17169
17170 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17171 {
17172 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17173
17174 css_buf_unicode[j + 1].cs_buf[0] = 0;
17175 css_buf_unicode[j + 1].cs_len = 1;
17176 }
17177
17178 free (css_buf);
17179
17180 css_buf = css_buf_unicode;
17181 css_cnt = css_cnt_unicode;
17182 }
17183
17184 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17185
17186 uint mask_min = pw_min;
17187 uint mask_max = pw_max;
17188
17189 if (opts_type & OPTS_TYPE_PT_UNICODE)
17190 {
17191 mask_min *= 2;
17192 mask_max *= 2;
17193 }
17194
17195 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17196 {
17197 if (css_cnt < mask_min)
17198 {
17199 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17200 }
17201
17202 if (css_cnt > mask_max)
17203 {
17204 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17205 }
17206
17207 // skip to next mask
17208
17209 dictpos++;
17210
17211 rd->dictpos = dictpos;
17212
17213 logfile_sub_msg ("STOP");
17214
17215 continue;
17216 }
17217
17218 uint save_css_cnt = css_cnt;
17219
17220 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17221 {
17222 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17223 {
17224 uint salt_len = (uint) data.salts_buf[0].salt_len;
17225 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17226
17227 uint css_cnt_salt = css_cnt + salt_len;
17228
17229 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17230
17231 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17232
17233 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17234 {
17235 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17236 css_buf_salt[j].cs_len = 1;
17237 }
17238
17239 free (css_buf);
17240
17241 css_buf = css_buf_salt;
17242 css_cnt = css_cnt_salt;
17243 }
17244 }
17245
17246 data.mask = mask;
17247 data.css_cnt = css_cnt;
17248 data.css_buf = css_buf;
17249
17250 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17251
17252 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17253
17254 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17255
17256 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17257 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17258
17259 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17260
17261 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17262
17263 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17264 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17265
17266 data.root_css_buf = root_css_buf;
17267 data.markov_css_buf = markov_css_buf;
17268
17269 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17270
17271 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17272
17273 local_free (root_table_buf);
17274 local_free (markov_table_buf);
17275
17276 // copy + args
17277
17278 uint css_cnt_l = css_cnt;
17279 uint css_cnt_r;
17280
17281 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17282 {
17283 if (save_css_cnt < 6)
17284 {
17285 css_cnt_r = 1;
17286 }
17287 else if (save_css_cnt == 6)
17288 {
17289 css_cnt_r = 2;
17290 }
17291 else
17292 {
17293 if (opts_type & OPTS_TYPE_PT_UNICODE)
17294 {
17295 if (save_css_cnt == 8 || save_css_cnt == 10)
17296 {
17297 css_cnt_r = 2;
17298 }
17299 else
17300 {
17301 css_cnt_r = 4;
17302 }
17303 }
17304 else
17305 {
17306 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17307 {
17308 css_cnt_r = 3;
17309 }
17310 else
17311 {
17312 css_cnt_r = 4;
17313 }
17314 }
17315 }
17316 }
17317 else
17318 {
17319 css_cnt_r = 1;
17320
17321 /* unfinished code?
17322 int sum = css_buf[css_cnt_r - 1].cs_len;
17323
17324 for (uint i = 1; i < 4 && i < css_cnt; i++)
17325 {
17326 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17327
17328 css_cnt_r++;
17329
17330 sum *= css_buf[css_cnt_r - 1].cs_len;
17331 }
17332 */
17333 }
17334
17335 css_cnt_l -= css_cnt_r;
17336
17337 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17338
17339 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17340 {
17341 hc_device_param_t *device_param = &data.devices_param[device_id];
17342
17343 if (device_param->skipped) continue;
17344
17345 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17346 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17347 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17348
17349 device_param->kernel_params_mp_l_buf64[3] = 0;
17350 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17351 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17352 device_param->kernel_params_mp_l_buf32[6] = 0;
17353 device_param->kernel_params_mp_l_buf32[7] = 0;
17354 device_param->kernel_params_mp_l_buf32[8] = 0;
17355
17356 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17357 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17358 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17359 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17360
17361 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17362 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17363 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17364
17365 device_param->kernel_params_mp_r_buf64[3] = 0;
17366 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17367 device_param->kernel_params_mp_r_buf32[5] = 0;
17368 device_param->kernel_params_mp_r_buf32[6] = 0;
17369 device_param->kernel_params_mp_r_buf32[7] = 0;
17370
17371 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]);
17372 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]);
17373 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]);
17374
17375 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]);
17376 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]);
17377 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]);
17378
17379 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);
17380 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);
17381 }
17382 }
17383
17384 u64 words_base = data.words_cnt;
17385
17386 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17387 {
17388 if (data.kernel_rules_cnt)
17389 {
17390 words_base /= data.kernel_rules_cnt;
17391 }
17392 }
17393 else if (data.attack_kern == ATTACK_KERN_COMBI)
17394 {
17395 if (data.combs_cnt)
17396 {
17397 words_base /= data.combs_cnt;
17398 }
17399 }
17400 else if (data.attack_kern == ATTACK_KERN_BF)
17401 {
17402 if (data.bfs_cnt)
17403 {
17404 words_base /= data.bfs_cnt;
17405 }
17406 }
17407
17408 data.words_base = words_base;
17409
17410 if (keyspace == 1)
17411 {
17412 log_info ("%llu", (unsigned long long int) words_base);
17413
17414 return (0);
17415 }
17416
17417 if (data.words_cur > data.words_base)
17418 {
17419 log_error ("ERROR: restore value greater keyspace");
17420
17421 return (-1);
17422 }
17423
17424 if (data.words_cur)
17425 {
17426 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17427 {
17428 for (uint i = 0; i < data.salts_cnt; i++)
17429 {
17430 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17431 }
17432 }
17433 else if (data.attack_kern == ATTACK_KERN_COMBI)
17434 {
17435 for (uint i = 0; i < data.salts_cnt; i++)
17436 {
17437 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17438 }
17439 }
17440 else if (data.attack_kern == ATTACK_KERN_BF)
17441 {
17442 for (uint i = 0; i < data.salts_cnt; i++)
17443 {
17444 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17445 }
17446 }
17447 }
17448
17449 /*
17450 * Inform user about possible slow speeds
17451 */
17452
17453 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17454 {
17455 if (data.words_base < kernel_power_all)
17456 {
17457 if (quiet == 0)
17458 {
17459 log_info ("ATTENTION!");
17460 log_info (" The wordlist or mask you are using is too small.");
17461 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17462 log_info (" The cracking speed will drop.");
17463 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17464 log_info ("");
17465 }
17466 }
17467 }
17468
17469 /*
17470 * Update loopback file
17471 */
17472
17473 if (loopback == 1)
17474 {
17475 time_t now;
17476
17477 time (&now);
17478
17479 uint random_num = get_random_num (0, 9999);
17480
17481 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17482
17483 data.loopback_file = loopback_file;
17484 }
17485
17486 /*
17487 * Update dictionary statistic
17488 */
17489
17490 if (keyspace == 0)
17491 {
17492 dictstat_fp = fopen (dictstat, "wb");
17493
17494 if (dictstat_fp)
17495 {
17496 lock_file (dictstat_fp);
17497
17498 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17499
17500 fclose (dictstat_fp);
17501 }
17502 }
17503
17504 data.devices_status = STATUS_RUNNING;
17505
17506 if (initial_restore_done == 0)
17507 {
17508 if (data.restore_disable == 0) cycle_restore ();
17509
17510 initial_restore_done = 1;
17511 }
17512
17513 hc_timer_set (&data.timer_running);
17514
17515 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17516 {
17517 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17518 {
17519 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17520 if (quiet == 0) fflush (stdout);
17521 }
17522 }
17523 else if (wordlist_mode == WL_MODE_STDIN)
17524 {
17525 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17526 if (data.quiet == 0) log_info ("");
17527 }
17528
17529 time_t runtime_start;
17530
17531 time (&runtime_start);
17532
17533 data.runtime_start = runtime_start;
17534
17535 /**
17536 * create cracker threads
17537 */
17538
17539 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17540
17541 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17542 {
17543 hc_device_param_t *device_param = &devices_param[device_id];
17544
17545 if (wordlist_mode == WL_MODE_STDIN)
17546 {
17547 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17548 }
17549 else
17550 {
17551 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17552 }
17553 }
17554
17555 // wait for crack threads to exit
17556
17557 hc_thread_wait (data.devices_cnt, c_threads);
17558
17559 local_free (c_threads);
17560
17561 data.restore = 0;
17562
17563 // finalize task
17564
17565 logfile_sub_var_uint ("status-after-work", data.devices_status);
17566
17567 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17568
17569 if (data.devices_status == STATUS_CRACKED) break;
17570 if (data.devices_status == STATUS_ABORTED) break;
17571
17572 if (data.devices_status == STATUS_BYPASS)
17573 {
17574 data.devices_status = STATUS_RUNNING;
17575 }
17576
17577 if (induction_dictionaries_cnt)
17578 {
17579 unlink (induction_dictionaries[0]);
17580 }
17581
17582 free (induction_dictionaries);
17583
17584 if (attack_mode != ATTACK_MODE_BF)
17585 {
17586 induction_dictionaries = scan_directory (induction_directory);
17587
17588 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17589 }
17590
17591 if (benchmark == 0)
17592 {
17593 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17594 {
17595 if (quiet == 0) clear_prompt ();
17596
17597 if (quiet == 0) log_info ("");
17598
17599 if (status == 1)
17600 {
17601 status_display ();
17602 }
17603 else
17604 {
17605 if (quiet == 0) status_display ();
17606 }
17607
17608 if (quiet == 0) log_info ("");
17609 }
17610 }
17611
17612 if (attack_mode == ATTACK_MODE_BF)
17613 {
17614 dictpos++;
17615
17616 rd->dictpos = dictpos;
17617 }
17618 else
17619 {
17620 if (induction_dictionaries_cnt)
17621 {
17622 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17623 }
17624 else
17625 {
17626 dictpos++;
17627
17628 rd->dictpos = dictpos;
17629 }
17630 }
17631
17632 time_t runtime_stop;
17633
17634 time (&runtime_stop);
17635
17636 data.runtime_stop = runtime_stop;
17637
17638 logfile_sub_uint (runtime_start);
17639 logfile_sub_uint (runtime_stop);
17640
17641 logfile_sub_msg ("STOP");
17642
17643 global_free (subid);
17644 }
17645
17646 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17647
17648 if (data.devices_status == STATUS_CRACKED) break;
17649 if (data.devices_status == STATUS_ABORTED) break;
17650 if (data.devices_status == STATUS_QUIT) break;
17651
17652 if (data.devices_status == STATUS_BYPASS)
17653 {
17654 data.devices_status = STATUS_RUNNING;
17655 }
17656 }
17657
17658 // 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
17659
17660 if (attack_mode == ATTACK_MODE_STRAIGHT)
17661 {
17662 if (data.wordlist_mode == WL_MODE_FILE)
17663 {
17664 if (data.dictfile == NULL)
17665 {
17666 if (dictfiles != NULL)
17667 {
17668 data.dictfile = dictfiles[0];
17669
17670 hc_timer_set (&data.timer_running);
17671 }
17672 }
17673 }
17674 }
17675 // NOTE: combi is okay because it is already set beforehand
17676 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17677 {
17678 if (data.dictfile == NULL)
17679 {
17680 if (dictfiles != NULL)
17681 {
17682 hc_timer_set (&data.timer_running);
17683
17684 data.dictfile = dictfiles[0];
17685 }
17686 }
17687 }
17688 else if (attack_mode == ATTACK_MODE_BF)
17689 {
17690 if (data.mask == NULL)
17691 {
17692 hc_timer_set (&data.timer_running);
17693
17694 data.mask = masks[0];
17695 }
17696 }
17697
17698 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17699 {
17700 data.devices_status = STATUS_EXHAUSTED;
17701 }
17702
17703 // if cracked / aborted remove last induction dictionary
17704
17705 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17706 {
17707 struct stat induct_stat;
17708
17709 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17710 {
17711 unlink (induction_dictionaries[file_pos]);
17712 }
17713 }
17714
17715 // wait for non-interactive threads
17716
17717 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17718 {
17719 hc_thread_wait (1, &ni_threads[thread_idx]);
17720 }
17721
17722 local_free (ni_threads);
17723
17724 // wait for interactive threads
17725
17726 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17727 {
17728 hc_thread_wait (1, &i_thread);
17729 }
17730
17731 // we dont need restore file anymore
17732 if (data.restore_disable == 0)
17733 {
17734 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17735 {
17736 unlink (eff_restore_file);
17737 unlink (new_restore_file);
17738 }
17739 else
17740 {
17741 cycle_restore ();
17742 }
17743 }
17744
17745 // finally save left hashes
17746
17747 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17748 {
17749 save_hash ();
17750 }
17751
17752 /**
17753 * Clean up
17754 */
17755
17756 if (benchmark == 1)
17757 {
17758 status_benchmark ();
17759
17760 if (machine_readable == 0)
17761 {
17762 log_info ("");
17763 }
17764 }
17765 else
17766 {
17767 if (quiet == 0) clear_prompt ();
17768
17769 if (quiet == 0) log_info ("");
17770
17771 if (status == 1)
17772 {
17773 status_display ();
17774 }
17775 else
17776 {
17777 if (quiet == 0) status_display ();
17778 }
17779
17780 if (quiet == 0) log_info ("");
17781 }
17782
17783 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17784 {
17785 hc_device_param_t *device_param = &data.devices_param[device_id];
17786
17787 if (device_param->skipped) continue;
17788
17789 local_free (device_param->combs_buf);
17790
17791 local_free (device_param->hooks_buf);
17792
17793 local_free (device_param->device_name);
17794
17795 local_free (device_param->device_name_chksum);
17796
17797 local_free (device_param->device_version);
17798
17799 local_free (device_param->driver_version);
17800
17801 if (device_param->pws_buf) myfree (device_param->pws_buf);
17802 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17803 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17804 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17805 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17806 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17807 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17808 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17809 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17810 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17811 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17812 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17813 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17814 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17815 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17816 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17817 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17818 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17819 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17820 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17821 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17822 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17823 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17824 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17825 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17826 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17827 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17828 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17829 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17830
17831 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17832 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17833 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17834 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17835 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17836 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17837 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17838 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17839 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17840 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17841 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17842
17843 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17844 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17845 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17846
17847 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17848 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17849 }
17850
17851 // reset default fan speed
17852
17853 #ifdef HAVE_HWMON
17854 if (gpu_temp_disable == 0)
17855 {
17856 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17857 {
17858 hc_thread_mutex_lock (mux_adl);
17859
17860 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17861 {
17862 hc_device_param_t *device_param = &data.devices_param[device_id];
17863
17864 if (device_param->skipped) continue;
17865
17866 if (data.hm_device[device_id].fan_set_supported == 1)
17867 {
17868 int fanspeed = temp_retain_fanspeed_value[device_id];
17869 int fanpolicy = temp_retain_fanpolicy_value[device_id];
17870
17871 if (fanpolicy == 1)
17872 {
17873 int rc = -1;
17874
17875 if (device_param->device_vendor_id == VENDOR_ID_AMD)
17876 {
17877 rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed, 0);
17878 }
17879 else if (device_param->device_vendor_id == VENDOR_ID_NV)
17880 {
17881
17882 }
17883
17884 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
17885 }
17886 }
17887 }
17888
17889 hc_thread_mutex_unlock (mux_adl);
17890 }
17891 }
17892
17893 // reset power tuning
17894
17895 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17896 {
17897 hc_thread_mutex_lock (mux_adl);
17898
17899 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17900 {
17901 hc_device_param_t *device_param = &data.devices_param[device_id];
17902
17903 if (device_param->skipped) continue;
17904
17905 if (data.hm_device[device_id].od_version == 6)
17906 {
17907 // check powertune capabilities first, if not available then skip device
17908
17909 int powertune_supported = 0;
17910
17911 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17912 {
17913 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17914
17915 return (-1);
17916 }
17917
17918 if (powertune_supported != 0)
17919 {
17920 // powercontrol settings
17921
17922 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)
17923 {
17924 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17925
17926 return (-1);
17927 }
17928
17929 // clocks
17930
17931 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17932
17933 performance_state->iNumberOfPerformanceLevels = 2;
17934
17935 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17936 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17937 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17938 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17939
17940 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)
17941 {
17942 log_info ("ERROR: Failed to restore ADL performance state");
17943
17944 return (-1);
17945 }
17946
17947 local_free (performance_state);
17948 }
17949 }
17950 }
17951
17952 hc_thread_mutex_unlock (mux_adl);
17953 }
17954
17955 if (gpu_temp_disable == 0)
17956 {
17957 if (data.hm_nv)
17958 {
17959 hm_NVML_nvmlShutdown (data.hm_nv);
17960
17961 nvml_close (data.hm_nv);
17962
17963 data.hm_nv = NULL;
17964 }
17965
17966 if (data.hm_amd)
17967 {
17968 hm_ADL_Main_Control_Destroy (data.hm_amd);
17969
17970 adl_close (data.hm_amd);
17971
17972 data.hm_amd = NULL;
17973 }
17974 }
17975 #endif // HAVE_HWMON
17976
17977 // free memory
17978
17979 local_free (masks);
17980
17981 local_free (dictstat_base);
17982
17983 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17984 {
17985 pot_t *pot_ptr = &pot[pot_pos];
17986
17987 hash_t *hash = &pot_ptr->hash;
17988
17989 local_free (hash->digest);
17990
17991 if (isSalted)
17992 {
17993 local_free (hash->salt);
17994 }
17995 }
17996
17997 local_free (pot);
17998
17999 local_free (all_kernel_rules_cnt);
18000 local_free (all_kernel_rules_buf);
18001
18002 local_free (wl_data->buf);
18003 local_free (wl_data);
18004
18005 local_free (bitmap_s1_a);
18006 local_free (bitmap_s1_b);
18007 local_free (bitmap_s1_c);
18008 local_free (bitmap_s1_d);
18009 local_free (bitmap_s2_a);
18010 local_free (bitmap_s2_b);
18011 local_free (bitmap_s2_c);
18012 local_free (bitmap_s2_d);
18013
18014 #ifdef HAVE_HWMON
18015 local_free (temp_retain_fanspeed_value);
18016 local_free (od_clock_mem_status);
18017 local_free (od_power_control_status);
18018 #endif
18019
18020 global_free (devices_param);
18021
18022 global_free (kernel_rules_buf);
18023
18024 global_free (root_css_buf);
18025 global_free (markov_css_buf);
18026
18027 global_free (digests_buf);
18028 global_free (digests_shown);
18029 global_free (digests_shown_tmp);
18030
18031 global_free (salts_buf);
18032 global_free (salts_shown);
18033
18034 global_free (esalts_buf);
18035
18036 global_free (words_progress_done);
18037 global_free (words_progress_rejected);
18038 global_free (words_progress_restored);
18039
18040 if (pot_fp) fclose (pot_fp);
18041
18042 if (data.devices_status == STATUS_QUIT) break;
18043 }
18044
18045 // destroy others mutex
18046
18047 hc_thread_mutex_delete (mux_dispatcher);
18048 hc_thread_mutex_delete (mux_counter);
18049 hc_thread_mutex_delete (mux_display);
18050 hc_thread_mutex_delete (mux_adl);
18051
18052 // free memory
18053
18054 local_free (eff_restore_file);
18055 local_free (new_restore_file);
18056
18057 local_free (rd);
18058
18059 // tuning db
18060
18061 tuning_db_destroy (tuning_db);
18062
18063 // loopback
18064
18065 local_free (loopback_file);
18066
18067 if (loopback == 1) unlink (loopback_file);
18068
18069 // induction directory
18070
18071 if (induction_dir == NULL)
18072 {
18073 if (attack_mode != ATTACK_MODE_BF)
18074 {
18075 if (rmdir (induction_directory) == -1)
18076 {
18077 if (errno == ENOENT)
18078 {
18079 // good, we can ignore
18080 }
18081 else if (errno == ENOTEMPTY)
18082 {
18083 // good, we can ignore
18084 }
18085 else
18086 {
18087 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18088
18089 return (-1);
18090 }
18091 }
18092
18093 local_free (induction_directory);
18094 }
18095 }
18096
18097 // outfile-check directory
18098
18099 if (outfile_check_dir == NULL)
18100 {
18101 if (rmdir (outfile_check_directory) == -1)
18102 {
18103 if (errno == ENOENT)
18104 {
18105 // good, we can ignore
18106 }
18107 else if (errno == ENOTEMPTY)
18108 {
18109 // good, we can ignore
18110 }
18111 else
18112 {
18113 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18114
18115 return (-1);
18116 }
18117 }
18118
18119 local_free (outfile_check_directory);
18120 }
18121
18122 time_t proc_stop;
18123
18124 time (&proc_stop);
18125
18126 logfile_top_uint (proc_start);
18127 logfile_top_uint (proc_stop);
18128
18129 logfile_top_msg ("STOP");
18130
18131 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18132 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18133
18134 if (data.ocl) ocl_close (data.ocl);
18135
18136 if (data.devices_status == STATUS_ABORTED) return 2;
18137 if (data.devices_status == STATUS_QUIT) return 2;
18138 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18139 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18140 if (data.devices_status == STATUS_CRACKED) return 0;
18141
18142 return -1;
18143 }
Hashcat additions to support pwdhash