projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Added a ton of new NVML stuff
[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 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1551
1552 char output_buf[256] = { 0 };
1553
1554 int output_len = 0;
1555
1556 if (num_temperature >= 0)
1557 {
1558 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1559
1560 output_len = strlen (output_buf);
1561 }
1562
1563 if (num_fanspeed >= 0)
1564 {
1565 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1566
1567 output_len = strlen (output_buf);
1568 }
1569
1570 if (num_utilization >= 0)
1571 {
1572 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1573
1574 output_len = strlen (output_buf);
1575 }
1576
1577 if (num_corespeed >= 0)
1578 {
1579 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1580
1581 output_len = strlen (output_buf);
1582 }
1583
1584 if (num_memoryspeed >= 0)
1585 {
1586 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1587
1588 output_len = strlen (output_buf);
1589 }
1590
1591 if (num_buslanes >= 0)
1592 {
1593 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1594
1595 output_len = strlen (output_buf);
1596 }
1597
1598 if (num_throttle == 1)
1599 {
1600 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1601
1602 output_len = strlen (output_buf);
1603 }
1604
1605 if (output_len == 0)
1606 {
1607 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1608
1609 output_len = strlen (output_buf);
1610 }
1611
1612 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1613 }
1614
1615 hc_thread_mutex_unlock (mux_adl);
1616 }
1617 #endif // HAVE_HWMON
1618 }
1619
1620 static void status_benchmark_automate ()
1621 {
1622 u64 speed_cnt[DEVICES_MAX] = { 0 };
1623 double speed_ms[DEVICES_MAX] = { 0 };
1624
1625 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1626 {
1627 hc_device_param_t *device_param = &data.devices_param[device_id];
1628
1629 if (device_param->skipped) continue;
1630
1631 speed_cnt[device_id] = device_param->speed_cnt[0];
1632 speed_ms[device_id] = device_param->speed_ms[0];
1633 }
1634
1635 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1636
1637 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1638 {
1639 hc_device_param_t *device_param = &data.devices_param[device_id];
1640
1641 if (device_param->skipped) continue;
1642
1643 hashes_dev_ms[device_id] = 0;
1644
1645 if (speed_ms[device_id])
1646 {
1647 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1648 }
1649 }
1650
1651 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1652 {
1653 hc_device_param_t *device_param = &data.devices_param[device_id];
1654
1655 if (device_param->skipped) continue;
1656
1657 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1658 }
1659 }
1660
1661 static void status_benchmark ()
1662 {
1663 if (data.devices_status == STATUS_INIT) return;
1664 if (data.devices_status == STATUS_STARTING) return;
1665 if (data.devices_status == STATUS_BYPASS) return;
1666
1667 if (data.machine_readable == 1)
1668 {
1669 status_benchmark_automate ();
1670
1671 return;
1672 }
1673
1674 u64 speed_cnt[DEVICES_MAX] = { 0 };
1675 double speed_ms[DEVICES_MAX] = { 0 };
1676
1677 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1678 {
1679 hc_device_param_t *device_param = &data.devices_param[device_id];
1680
1681 if (device_param->skipped) continue;
1682
1683 speed_cnt[device_id] = device_param->speed_cnt[0];
1684 speed_ms[device_id] = device_param->speed_ms[0];
1685 }
1686
1687 double hashes_all_ms = 0;
1688
1689 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1690
1691 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1692 {
1693 hc_device_param_t *device_param = &data.devices_param[device_id];
1694
1695 if (device_param->skipped) continue;
1696
1697 hashes_dev_ms[device_id] = 0;
1698
1699 if (speed_ms[device_id])
1700 {
1701 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1702
1703 hashes_all_ms += hashes_dev_ms[device_id];
1704 }
1705 }
1706
1707 /**
1708 * exec time
1709 */
1710
1711 double exec_all_ms[DEVICES_MAX] = { 0 };
1712
1713 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1714 {
1715 hc_device_param_t *device_param = &data.devices_param[device_id];
1716
1717 if (device_param->skipped) continue;
1718
1719 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1720
1721 exec_all_ms[device_id] = exec_ms_avg;
1722 }
1723
1724 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1725 {
1726 hc_device_param_t *device_param = &data.devices_param[device_id];
1727
1728 if (device_param->skipped) continue;
1729
1730 char display_dev_cur[16] = { 0 };
1731
1732 strncpy (display_dev_cur, "0.00", 4);
1733
1734 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1735
1736 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1737 }
1738
1739 char display_all_cur[16] = { 0 };
1740
1741 strncpy (display_all_cur, "0.00", 4);
1742
1743 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1744
1745 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1746 }
1747
1748 /**
1749 * hashcat -only- functions
1750 */
1751
1752 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1753 {
1754 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1755 {
1756 if (attack_kern == ATTACK_KERN_STRAIGHT)
1757 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1758 else if (attack_kern == ATTACK_KERN_COMBI)
1759 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1760 else if (attack_kern == ATTACK_KERN_BF)
1761 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1762 }
1763 else
1764 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1765 }
1766
1767 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1768 {
1769 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1770 {
1771 if (attack_kern == ATTACK_KERN_STRAIGHT)
1772 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1773 else if (attack_kern == ATTACK_KERN_COMBI)
1774 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1775 else if (attack_kern == ATTACK_KERN_BF)
1776 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1777 }
1778 else
1779 {
1780 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1781 }
1782 }
1783
1784 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1785 {
1786 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1787 {
1788 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1789 }
1790 else
1791 {
1792 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1793 }
1794 }
1795
1796 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1797 {
1798 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1799 {
1800 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1801 }
1802 else
1803 {
1804 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1805 }
1806 }
1807
1808 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1809 {
1810 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1811 }
1812
1813 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1814 {
1815 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1816 }
1817
1818 static uint convert_from_hex (char *line_buf, const uint line_len)
1819 {
1820 if (line_len & 1) return (line_len); // not in hex
1821
1822 if (data.hex_wordlist == 1)
1823 {
1824 uint i;
1825 uint j;
1826
1827 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1828 {
1829 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1830 }
1831
1832 memset (line_buf + i, 0, line_len - i);
1833
1834 return (i);
1835 }
1836 else if (line_len >= 6) // $HEX[] = 6
1837 {
1838 if (line_buf[0] != '$') return (line_len);
1839 if (line_buf[1] != 'H') return (line_len);
1840 if (line_buf[2] != 'E') return (line_len);
1841 if (line_buf[3] != 'X') return (line_len);
1842 if (line_buf[4] != '[') return (line_len);
1843 if (line_buf[line_len - 1] != ']') return (line_len);
1844
1845 uint i;
1846 uint j;
1847
1848 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1849 {
1850 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1851 }
1852
1853 memset (line_buf + i, 0, line_len - i);
1854
1855 return (i);
1856 }
1857
1858 return (line_len);
1859 }
1860
1861 static void clear_prompt ()
1862 {
1863 fputc ('\r', stdout);
1864
1865 for (size_t i = 0; i < strlen (PROMPT); i++)
1866 {
1867 fputc (' ', stdout);
1868 }
1869
1870 fputc ('\r', stdout);
1871
1872 fflush (stdout);
1873 }
1874
1875 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1876 {
1877 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1878 }
1879
1880 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1881 {
1882 char *outfile = data.outfile;
1883 uint quiet = data.quiet;
1884 FILE *pot_fp = data.pot_fp;
1885 uint loopback = data.loopback;
1886 uint debug_mode = data.debug_mode;
1887 char *debug_file = data.debug_file;
1888
1889 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1890 int debug_rule_len = 0; // -1 error
1891 uint debug_plain_len = 0;
1892
1893 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1894
1895 // hash
1896
1897 char out_buf[HCBUFSIZ] = { 0 };
1898
1899 const u32 salt_pos = plain->salt_pos;
1900 const u32 digest_pos = plain->digest_pos; // relative
1901 const u32 gidvid = plain->gidvid;
1902 const u32 il_pos = plain->il_pos;
1903
1904 ascii_digest (out_buf, salt_pos, digest_pos);
1905
1906 // plain
1907
1908 u64 crackpos = device_param->words_off;
1909
1910 uint plain_buf[16] = { 0 };
1911
1912 u8 *plain_ptr = (u8 *) plain_buf;
1913
1914 unsigned int plain_len = 0;
1915
1916 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1917 {
1918 pw_t pw;
1919
1920 gidd_to_pw_t (device_param, gidvid, &pw);
1921
1922 for (int i = 0; i < 16; i++)
1923 {
1924 plain_buf[i] = pw.i[i];
1925 }
1926
1927 plain_len = pw.pw_len;
1928
1929 const uint off = device_param->innerloop_pos + il_pos;
1930
1931 if (debug_mode > 0)
1932 {
1933 debug_rule_len = 0;
1934
1935 // save rule
1936 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1937 {
1938 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1939
1940 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1941 }
1942
1943 // save plain
1944 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1945 {
1946 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1947
1948 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1949
1950 debug_plain_len = plain_len;
1951 }
1952 }
1953
1954 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1955
1956 crackpos += gidvid;
1957 crackpos *= data.kernel_rules_cnt;
1958 crackpos += device_param->innerloop_pos + il_pos;
1959
1960 if (plain_len > data.pw_max) plain_len = data.pw_max;
1961 }
1962 else if (data.attack_mode == ATTACK_MODE_COMBI)
1963 {
1964 pw_t pw;
1965
1966 gidd_to_pw_t (device_param, gidvid, &pw);
1967
1968 for (int i = 0; i < 16; i++)
1969 {
1970 plain_buf[i] = pw.i[i];
1971 }
1972
1973 plain_len = pw.pw_len;
1974
1975 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1976 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1977
1978 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1979 {
1980 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1981 }
1982 else
1983 {
1984 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1985
1986 memcpy (plain_ptr, comb_buf, comb_len);
1987 }
1988
1989 plain_len += comb_len;
1990
1991 crackpos += gidvid;
1992 crackpos *= data.combs_cnt;
1993 crackpos += device_param->innerloop_pos + il_pos;
1994
1995 if (data.pw_max != PW_DICTMAX1)
1996 {
1997 if (plain_len > data.pw_max) plain_len = data.pw_max;
1998 }
1999 }
2000 else if (data.attack_mode == ATTACK_MODE_BF)
2001 {
2002 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2003 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2004
2005 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2006 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2007
2008 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2009 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2010
2011 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2012 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2013
2014 plain_len = data.css_cnt;
2015
2016 crackpos += gidvid;
2017 crackpos *= data.bfs_cnt;
2018 crackpos += device_param->innerloop_pos + il_pos;
2019 }
2020 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2021 {
2022 pw_t pw;
2023
2024 gidd_to_pw_t (device_param, gidvid, &pw);
2025
2026 for (int i = 0; i < 16; i++)
2027 {
2028 plain_buf[i] = pw.i[i];
2029 }
2030
2031 plain_len = pw.pw_len;
2032
2033 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2034
2035 uint start = 0;
2036 uint stop = device_param->kernel_params_mp_buf32[4];
2037
2038 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2039
2040 plain_len += start + stop;
2041
2042 crackpos += gidvid;
2043 crackpos *= data.combs_cnt;
2044 crackpos += device_param->innerloop_pos + il_pos;
2045
2046 if (data.pw_max != PW_DICTMAX1)
2047 {
2048 if (plain_len > data.pw_max) plain_len = data.pw_max;
2049 }
2050 }
2051 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2052 {
2053 pw_t pw;
2054
2055 gidd_to_pw_t (device_param, gidvid, &pw);
2056
2057 for (int i = 0; i < 16; i++)
2058 {
2059 plain_buf[i] = pw.i[i];
2060 }
2061
2062 plain_len = pw.pw_len;
2063
2064 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2065
2066 uint start = 0;
2067 uint stop = device_param->kernel_params_mp_buf32[4];
2068
2069 memmove (plain_ptr + stop, plain_ptr, plain_len);
2070
2071 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2072
2073 plain_len += start + stop;
2074
2075 crackpos += gidvid;
2076 crackpos *= data.combs_cnt;
2077 crackpos += device_param->innerloop_pos + il_pos;
2078
2079 if (data.pw_max != PW_DICTMAX1)
2080 {
2081 if (plain_len > data.pw_max) plain_len = data.pw_max;
2082 }
2083 }
2084
2085 if (data.attack_mode == ATTACK_MODE_BF)
2086 {
2087 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2088 {
2089 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2090 {
2091 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2092 {
2093 plain_len = plain_len - data.salts_buf[0].salt_len;
2094 }
2095 }
2096
2097 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2098 {
2099 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2100 {
2101 plain_ptr[j] = plain_ptr[i];
2102 }
2103
2104 plain_len = plain_len / 2;
2105 }
2106 }
2107 }
2108
2109 // if enabled, update also the potfile
2110
2111 if (pot_fp)
2112 {
2113 lock_file (pot_fp);
2114
2115 fprintf (pot_fp, "%s:", out_buf);
2116
2117 format_plain (pot_fp, plain_ptr, plain_len, 1);
2118
2119 fputc ('\n', pot_fp);
2120
2121 fflush (pot_fp);
2122
2123 unlock_file (pot_fp);
2124 }
2125
2126 // outfile
2127
2128 FILE *out_fp = NULL;
2129
2130 if (outfile != NULL)
2131 {
2132 if ((out_fp = fopen (outfile, "ab")) == NULL)
2133 {
2134 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2135
2136 out_fp = stdout;
2137 }
2138
2139 lock_file (out_fp);
2140 }
2141 else
2142 {
2143 out_fp = stdout;
2144
2145 if (quiet == 0) clear_prompt ();
2146 }
2147
2148 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2149
2150 if (outfile != NULL)
2151 {
2152 if (out_fp != stdout)
2153 {
2154 fclose (out_fp);
2155 }
2156 }
2157 else
2158 {
2159 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2160 {
2161 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2162 {
2163 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2164 if (quiet == 0) fflush (stdout);
2165 }
2166 }
2167 }
2168
2169 // loopback
2170
2171 if (loopback)
2172 {
2173 char *loopback_file = data.loopback_file;
2174
2175 FILE *fb_fp = NULL;
2176
2177 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2178 {
2179 lock_file (fb_fp);
2180
2181 format_plain (fb_fp, plain_ptr, plain_len, 1);
2182
2183 fputc ('\n', fb_fp);
2184
2185 fclose (fb_fp);
2186 }
2187 }
2188
2189 // (rule) debug mode
2190
2191 // the next check implies that:
2192 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2193 // - debug_mode > 0
2194
2195 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2196 {
2197 if (debug_rule_len < 0) debug_rule_len = 0;
2198
2199 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2200
2201 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2202
2203 if ((quiet == 0) && (debug_file == NULL))
2204 {
2205 fprintf (stdout, "%s", PROMPT);
2206
2207 fflush (stdout);
2208 }
2209 }
2210 }
2211
2212 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2213 {
2214 salt_t *salt_buf = &data.salts_buf[salt_pos];
2215
2216 u32 num_cracked;
2217
2218 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2219
2220 if (num_cracked)
2221 {
2222 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2223
2224 log_info_nn ("");
2225
2226 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2227
2228 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, 0, num_cracked * sizeof (plain_t), cracked, 0, NULL, NULL);
2229
2230 uint cpt_cracked = 0;
2231
2232 for (uint i = 0; i < num_cracked; i++)
2233 {
2234 const uint hash_pos = cracked[i].hash_pos;
2235
2236 if (data.digests_shown[hash_pos] == 1) continue;
2237
2238 hc_thread_mutex_lock (mux_display);
2239
2240 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2241 {
2242 data.digests_shown[hash_pos] = 1;
2243
2244 data.digests_done++;
2245
2246 cpt_cracked++;
2247
2248 salt_buf->digests_done++;
2249
2250 if (salt_buf->digests_done == salt_buf->digests_cnt)
2251 {
2252 data.salts_shown[salt_pos] = 1;
2253
2254 data.salts_done++;
2255 }
2256 }
2257
2258 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2259
2260 hc_thread_mutex_unlock (mux_display);
2261
2262 check_hash (device_param, &cracked[i]);
2263 }
2264
2265 myfree (cracked);
2266
2267 if (cpt_cracked > 0)
2268 {
2269 hc_thread_mutex_lock (mux_display);
2270
2271 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2272 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2273
2274 data.cpt_pos++;
2275
2276 data.cpt_total += cpt_cracked;
2277
2278 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2279
2280 hc_thread_mutex_unlock (mux_display);
2281 }
2282
2283 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2284 {
2285 // we need to reset cracked state on the device
2286 // otherwise host thinks again and again the hash was cracked
2287 // and returns invalid password each time
2288
2289 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2290
2291 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2292 }
2293
2294 num_cracked = 0;
2295
2296 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2297 }
2298 }
2299
2300 static void save_hash ()
2301 {
2302 char *hashfile = data.hashfile;
2303
2304 char new_hashfile[256] = { 0 };
2305 char old_hashfile[256] = { 0 };
2306
2307 snprintf (new_hashfile, 255, "%s.new", hashfile);
2308 snprintf (old_hashfile, 255, "%s.old", hashfile);
2309
2310 unlink (new_hashfile);
2311
2312 char separator = data.separator;
2313
2314 FILE *fp = fopen (new_hashfile, "wb");
2315
2316 if (fp == NULL)
2317 {
2318 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2319
2320 exit (-1);
2321 }
2322
2323 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2324 {
2325 if (data.salts_shown[salt_pos] == 1) continue;
2326
2327 salt_t *salt_buf = &data.salts_buf[salt_pos];
2328
2329 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2330 {
2331 uint idx = salt_buf->digests_offset + digest_pos;
2332
2333 if (data.digests_shown[idx] == 1) continue;
2334
2335 if (data.hash_mode != 2500)
2336 {
2337 char out_buf[HCBUFSIZ] = { 0 };
2338
2339 if (data.username == 1)
2340 {
2341 user_t *user = data.hash_info[idx]->user;
2342
2343 uint i;
2344
2345 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2346
2347 fputc (separator, fp);
2348 }
2349
2350 ascii_digest (out_buf, salt_pos, digest_pos);
2351
2352 fputs (out_buf, fp);
2353
2354 log_out (fp, "");
2355 }
2356 else
2357 {
2358 hccap_t hccap;
2359
2360 to_hccap_t (&hccap, salt_pos, digest_pos);
2361
2362 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2363 }
2364 }
2365 }
2366
2367 fflush (fp);
2368
2369 fclose (fp);
2370
2371 unlink (old_hashfile);
2372
2373 if (rename (hashfile, old_hashfile) != 0)
2374 {
2375 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2376
2377 exit (-1);
2378 }
2379
2380 unlink (hashfile);
2381
2382 if (rename (new_hashfile, hashfile) != 0)
2383 {
2384 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2385
2386 exit (-1);
2387 }
2388
2389 unlink (old_hashfile);
2390 }
2391
2392 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2393 {
2394 // function called only in case kernel_power_all > words_left
2395
2396 float kernel_power_div = (float) (total_left) / kernel_power_all;
2397
2398 kernel_power_div += kernel_power_div / 100;
2399
2400 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2401
2402 while (kernel_power_new < total_left)
2403 {
2404 kernel_power_div += kernel_power_div / 100;
2405
2406 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2407 }
2408
2409 if (data.quiet == 0)
2410 {
2411 clear_prompt ();
2412
2413 //log_info ("");
2414
2415 log_info ("INFO: approaching final keyspace, workload adjusted");
2416 log_info ("");
2417
2418 fprintf (stdout, "%s", PROMPT);
2419
2420 fflush (stdout);
2421 }
2422
2423 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2424
2425 return kernel_power_div;
2426 }
2427
2428 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2429 {
2430 uint num_elements = num;
2431
2432 device_param->kernel_params_buf32[30] = data.combs_mode;
2433 device_param->kernel_params_buf32[31] = num;
2434
2435 uint kernel_threads = device_param->kernel_threads;
2436
2437 while (num_elements % kernel_threads) num_elements++;
2438
2439 cl_kernel kernel = NULL;
2440
2441 switch (kern_run)
2442 {
2443 case KERN_RUN_1: kernel = device_param->kernel1; break;
2444 case KERN_RUN_12: kernel = device_param->kernel12; break;
2445 case KERN_RUN_2: kernel = device_param->kernel2; break;
2446 case KERN_RUN_23: kernel = device_param->kernel23; break;
2447 case KERN_RUN_3: kernel = device_param->kernel3; break;
2448 }
2449
2450 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2451 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2452 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2453 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2454 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2455 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2456 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2457 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2458 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2459 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2460 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2461
2462 cl_event event;
2463
2464 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2465 {
2466 const size_t global_work_size[3] = { num_elements, 32, 1 };
2467 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2468
2469 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2470 }
2471 else
2472 {
2473 if (kern_run == KERN_RUN_2)
2474 {
2475 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2476 {
2477 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2478 }
2479 }
2480
2481 while (num_elements % kernel_threads) num_elements++;
2482
2483 const size_t global_work_size[3] = { num_elements, 1, 1 };
2484 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2485
2486 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2487 }
2488
2489 hc_clFlush (data.ocl, device_param->command_queue);
2490
2491 hc_clWaitForEvents (data.ocl, 1, &event);
2492
2493 if (event_update)
2494 {
2495 cl_ulong time_start;
2496 cl_ulong time_end;
2497
2498 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2499 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2500
2501 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2502
2503 uint exec_pos = device_param->exec_pos;
2504
2505 device_param->exec_ms[exec_pos] = exec_time;
2506
2507 exec_pos++;
2508
2509 if (exec_pos == EXEC_CACHE)
2510 {
2511 exec_pos = 0;
2512 }
2513
2514 device_param->exec_pos = exec_pos;
2515 }
2516
2517 hc_clReleaseEvent (data.ocl, event);
2518
2519 hc_clFinish (data.ocl, device_param->command_queue);
2520 }
2521
2522 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2523 {
2524 uint num_elements = num;
2525
2526 switch (kern_run)
2527 {
2528 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2529 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2530 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2531 }
2532
2533 // causes problems with special threads like in bcrypt
2534 // const uint kernel_threads = device_param->kernel_threads;
2535
2536 uint kernel_threads = device_param->kernel_threads;
2537
2538 while (num_elements % kernel_threads) num_elements++;
2539
2540 cl_kernel kernel = NULL;
2541
2542 switch (kern_run)
2543 {
2544 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2545 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2546 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2547 }
2548
2549 switch (kern_run)
2550 {
2551 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2552 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2553 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2554 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2555 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2556 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2557 break;
2558 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2559 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2560 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2561 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2562 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2563 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2564 break;
2565 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2566 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2567 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2568 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2569 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2570 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2571 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2572 break;
2573 }
2574
2575 const size_t global_work_size[3] = { num_elements, 1, 1 };
2576 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2577
2578 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2579
2580 hc_clFlush (data.ocl, device_param->command_queue);
2581
2582 hc_clFinish (data.ocl, device_param->command_queue);
2583 }
2584
2585 static void run_kernel_tm (hc_device_param_t *device_param)
2586 {
2587 const uint num_elements = 1024; // fixed
2588
2589 uint kernel_threads = 32;
2590
2591 cl_kernel kernel = device_param->kernel_tm;
2592
2593 const size_t global_work_size[3] = { num_elements, 1, 1 };
2594 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2595
2596 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2597
2598 hc_clFlush (data.ocl, device_param->command_queue);
2599
2600 hc_clFinish (data.ocl, device_param->command_queue);
2601 }
2602
2603 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2604 {
2605 uint num_elements = num;
2606
2607 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2608 device_param->kernel_params_amp_buf32[6] = num_elements;
2609
2610 // causes problems with special threads like in bcrypt
2611 // const uint kernel_threads = device_param->kernel_threads;
2612
2613 uint kernel_threads = device_param->kernel_threads;
2614
2615 while (num_elements % kernel_threads) num_elements++;
2616
2617 cl_kernel kernel = device_param->kernel_amp;
2618
2619 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2620 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2621
2622 const size_t global_work_size[3] = { num_elements, 1, 1 };
2623 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2624
2625 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2626
2627 hc_clFlush (data.ocl, device_param->command_queue);
2628
2629 hc_clFinish (data.ocl, device_param->command_queue);
2630 }
2631
2632 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2633 {
2634 const u32 num16d = num / 16;
2635 const u32 num16m = num % 16;
2636
2637 if (num16d)
2638 {
2639 device_param->kernel_params_memset_buf32[1] = value;
2640 device_param->kernel_params_memset_buf32[2] = num16d;
2641
2642 uint kernel_threads = device_param->kernel_threads;
2643
2644 uint num_elements = num16d;
2645
2646 while (num_elements % kernel_threads) num_elements++;
2647
2648 cl_kernel kernel = device_param->kernel_memset;
2649
2650 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2651 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2652 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2653
2654 const size_t global_work_size[3] = { num_elements, 1, 1 };
2655 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2656
2657 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2658
2659 hc_clFlush (data.ocl, device_param->command_queue);
2660
2661 hc_clFinish (data.ocl, device_param->command_queue);
2662 }
2663
2664 if (num16m)
2665 {
2666 u32 tmp[4];
2667
2668 tmp[0] = value;
2669 tmp[1] = value;
2670 tmp[2] = value;
2671 tmp[3] = value;
2672
2673 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2674 }
2675 }
2676
2677 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2678 {
2679 run_kernel_memset (device_param, buf, 0, size);
2680
2681 /*
2682 int rc = -1;
2683
2684 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2685 {
2686 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2687
2688 const cl_uchar zero = 0;
2689
2690 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2691 }
2692
2693 if (rc != 0)
2694 {
2695 // NOTE: clEnqueueFillBuffer () always fails with -59
2696 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2697 // How's that possible, OpenCL 1.2 support is advertised??
2698 // We need to workaround...
2699
2700 #define FILLSZ 0x100000
2701
2702 char *tmp = (char *) mymalloc (FILLSZ);
2703
2704 for (size_t i = 0; i < size; i += FILLSZ)
2705 {
2706 const size_t left = size - i;
2707
2708 const size_t fillsz = MIN (FILLSZ, left);
2709
2710 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2711 }
2712
2713 myfree (tmp);
2714 }
2715 */
2716 }
2717
2718 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2719 {
2720 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2721 {
2722 if (attack_mode == ATTACK_MODE_BF)
2723 {
2724 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2725 {
2726 const uint size_tm = 32 * sizeof (bs_word_t);
2727
2728 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2729
2730 run_kernel_tm (device_param);
2731
2732 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2733 }
2734 }
2735
2736 if (highest_pw_len < 16)
2737 {
2738 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2739 }
2740 else if (highest_pw_len < 32)
2741 {
2742 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2743 }
2744 else
2745 {
2746 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2747 }
2748 }
2749 else
2750 {
2751 run_kernel_amp (device_param, pws_cnt);
2752
2753 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2754
2755 if (opts_type & OPTS_TYPE_HOOK12)
2756 {
2757 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2758 }
2759
2760 uint iter = salt_buf->salt_iter;
2761
2762 uint loop_step = device_param->kernel_loops;
2763
2764 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2765 {
2766 uint loop_left = iter - loop_pos;
2767
2768 loop_left = MIN (loop_left, loop_step);
2769
2770 device_param->kernel_params_buf32[25] = loop_pos;
2771 device_param->kernel_params_buf32[26] = loop_left;
2772
2773 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2774
2775 if (data.devices_status == STATUS_CRACKED) break;
2776 if (data.devices_status == STATUS_ABORTED) break;
2777 if (data.devices_status == STATUS_QUIT) break;
2778
2779 /**
2780 * speed
2781 */
2782
2783 const float iter_part = (float) (loop_pos + loop_left) / iter;
2784
2785 const u64 perf_sum_all = pws_cnt * iter_part;
2786
2787 double speed_ms;
2788
2789 hc_timer_get (device_param->timer_speed, speed_ms);
2790
2791 const u32 speed_pos = device_param->speed_pos;
2792
2793 device_param->speed_cnt[speed_pos] = perf_sum_all;
2794
2795 device_param->speed_ms[speed_pos] = speed_ms;
2796
2797 if (data.benchmark == 1)
2798 {
2799 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2800 }
2801 }
2802
2803 if (opts_type & OPTS_TYPE_HOOK23)
2804 {
2805 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2806
2807 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2808
2809 // do something with data
2810
2811 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2812 }
2813
2814 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2815 }
2816 }
2817
2818 static int run_rule_engine (const int rule_len, const char *rule_buf)
2819 {
2820 if (rule_len == 0)
2821 {
2822 return 0;
2823 }
2824 else if (rule_len == 1)
2825 {
2826 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2827 }
2828
2829 return 1;
2830 }
2831
2832 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2833 {
2834 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2835 {
2836 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2837 }
2838 else if (data.attack_kern == ATTACK_KERN_COMBI)
2839 {
2840 if (data.attack_mode == ATTACK_MODE_COMBI)
2841 {
2842 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2843 {
2844 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2845 {
2846 for (u32 i = 0; i < pws_cnt; i++)
2847 {
2848 const u32 pw_len = device_param->pws_buf[i].pw_len;
2849
2850 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2851
2852 ptr[pw_len] = 0x01;
2853 }
2854 }
2855 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2856 {
2857 for (u32 i = 0; i < pws_cnt; i++)
2858 {
2859 const u32 pw_len = device_param->pws_buf[i].pw_len;
2860
2861 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2862
2863 ptr[pw_len] = 0x80;
2864 }
2865 }
2866 }
2867 }
2868 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2869 {
2870 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2871 {
2872 for (u32 i = 0; i < pws_cnt; i++)
2873 {
2874 const u32 pw_len = device_param->pws_buf[i].pw_len;
2875
2876 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2877
2878 ptr[pw_len] = 0x01;
2879 }
2880 }
2881 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2882 {
2883 for (u32 i = 0; i < pws_cnt; i++)
2884 {
2885 const u32 pw_len = device_param->pws_buf[i].pw_len;
2886
2887 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2888
2889 ptr[pw_len] = 0x80;
2890 }
2891 }
2892 }
2893
2894 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2895 }
2896 else if (data.attack_kern == ATTACK_KERN_BF)
2897 {
2898 const u64 off = device_param->words_off;
2899
2900 device_param->kernel_params_mp_l_buf64[3] = off;
2901
2902 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2903 }
2904 }
2905
2906 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2907 {
2908 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2909
2910 device_param->kernel_params_buf32[25] = 0;
2911 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2912 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2913
2914 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2915 {
2916 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2917 }
2918 else
2919 {
2920 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2921 }
2922
2923 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2924
2925 return exec_ms_prev;
2926 }
2927
2928 static void autotune (hc_device_param_t *device_param)
2929 {
2930 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2931
2932 const u32 kernel_accel_min = device_param->kernel_accel_min;
2933 const u32 kernel_accel_max = device_param->kernel_accel_max;
2934
2935 const u32 kernel_loops_min = device_param->kernel_loops_min;
2936 const u32 kernel_loops_max = device_param->kernel_loops_max;
2937
2938 u32 kernel_accel = kernel_accel_min;
2939 u32 kernel_loops = kernel_loops_min;
2940
2941 // in this case the user specified a fixed -u and -n on the commandline
2942 // no way to tune anything
2943 // but we need to run a few caching rounds
2944
2945 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2946 {
2947 try_run (device_param, kernel_accel, kernel_loops);
2948 try_run (device_param, kernel_accel, kernel_loops);
2949 try_run (device_param, kernel_accel, kernel_loops);
2950 try_run (device_param, kernel_accel, kernel_loops);
2951
2952 device_param->kernel_accel = kernel_accel;
2953 device_param->kernel_loops = kernel_loops;
2954
2955 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2956
2957 device_param->kernel_power = kernel_power;
2958
2959 return;
2960 }
2961
2962 // from here it's clear we are allowed to autotune
2963 // so let's init some fake words
2964
2965 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2966
2967 if (data.attack_kern == ATTACK_KERN_BF)
2968 {
2969 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2970 }
2971 else
2972 {
2973 for (u32 i = 0; i < kernel_power_max; i++)
2974 {
2975 device_param->pws_buf[i].i[0] = i;
2976 device_param->pws_buf[i].i[1] = 0x01234567;
2977 device_param->pws_buf[i].pw_len = 7 + (i & 7);
2978 }
2979
2980 if (data.kernel_rules_cnt > 1)
2981 {
2982 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, 0, 0, kernel_loops_max * sizeof (kernel_rule_t), 0, NULL, NULL);
2983 }
2984
2985 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2986 }
2987
2988 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2989 {
2990 run_kernel_amp (device_param, kernel_power_max);
2991 }
2992
2993 #define VERIFIER_CNT 1
2994
2995 // first find out highest kernel-loops that stays below target_ms
2996
2997 if (kernel_loops_min < kernel_loops_max)
2998 {
2999 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3000 {
3001 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3002
3003 for (int i = 0; i < VERIFIER_CNT; i++)
3004 {
3005 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3006
3007 exec_ms = MIN (exec_ms, exec_ms_v);
3008 }
3009
3010 if (exec_ms < target_ms) break;
3011 }
3012 }
3013
3014 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3015
3016 #define STEPS_CNT 10
3017
3018 if (kernel_accel_min < kernel_accel_max)
3019 {
3020 for (int i = 0; i < STEPS_CNT; i++)
3021 {
3022 const u32 kernel_accel_try = 1 << i;
3023
3024 if (kernel_accel_try < kernel_accel_min) continue;
3025 if (kernel_accel_try > kernel_accel_max) break;
3026
3027 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3028
3029 for (int i = 0; i < VERIFIER_CNT; i++)
3030 {
3031 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3032
3033 exec_ms = MIN (exec_ms, exec_ms_v);
3034 }
3035
3036 if (exec_ms > target_ms) break;
3037
3038 kernel_accel = kernel_accel_try;
3039 }
3040 }
3041
3042 // at this point we want to know the actual runtime for the following reason:
3043 // we need a reference for the balancing loop following up, and this
3044 // the balancing loop can have an effect that the creates a new opportunity, for example:
3045 // if the target is 95 ms and the current runtime is 48ms the above loop
3046 // stopped the execution because the previous exec_ms was > 95ms
3047 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3048 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3049
3050 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3051
3052 for (int i = 0; i < VERIFIER_CNT; i++)
3053 {
3054 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3055
3056 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3057 }
3058
3059 u32 diff = kernel_loops - kernel_accel;
3060
3061 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3062 {
3063 u32 kernel_accel_orig = kernel_accel;
3064 u32 kernel_loops_orig = kernel_loops;
3065
3066 for (u32 f = 1; f < 1024; f++)
3067 {
3068 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3069 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3070
3071 if (kernel_accel_try > kernel_accel_max) break;
3072 if (kernel_loops_try < kernel_loops_min) break;
3073
3074 u32 diff_new = kernel_loops_try - kernel_accel_try;
3075
3076 if (diff_new > diff) break;
3077
3078 diff_new = diff;
3079
3080 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3081
3082 for (int i = 0; i < VERIFIER_CNT; i++)
3083 {
3084 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3085
3086 exec_ms = MIN (exec_ms, exec_ms_v);
3087 }
3088
3089 if (exec_ms < exec_ms_pre_final)
3090 {
3091 exec_ms_pre_final = exec_ms;
3092
3093 kernel_accel = kernel_accel_try;
3094 kernel_loops = kernel_loops_try;
3095 }
3096 }
3097 }
3098
3099 const double exec_left = target_ms / exec_ms_pre_final;
3100
3101 const double accel_left = kernel_accel_max / kernel_accel;
3102
3103 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3104
3105 if (exec_accel_min >= 1.0)
3106 {
3107 // this is safe to not overflow kernel_accel_max because of accel_left
3108
3109 kernel_accel = (double) kernel_accel * exec_accel_min;
3110 }
3111
3112 // reset them fake words
3113
3114 /*
3115 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3116
3117 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3118 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3119 */
3120
3121 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3122
3123 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3124 {
3125 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3126 }
3127
3128 // reset timer
3129
3130 device_param->exec_pos = 0;
3131
3132 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3133
3134 // store
3135
3136 device_param->kernel_accel = kernel_accel;
3137 device_param->kernel_loops = kernel_loops;
3138
3139 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3140
3141 device_param->kernel_power = kernel_power;
3142
3143 #ifdef DEBUG
3144
3145 if (data.quiet == 0)
3146 {
3147 clear_prompt ();
3148
3149 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3150 "Device #%u: autotuned kernel-loops to %u\n",
3151 device_param->device_id + 1, kernel_accel,
3152 device_param->device_id + 1, kernel_loops);
3153
3154 fprintf (stdout, "%s", PROMPT);
3155
3156 fflush (stdout);
3157 }
3158
3159 #endif
3160 }
3161
3162 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3163 {
3164 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3165
3166 // init speed timer
3167
3168 uint speed_pos = device_param->speed_pos;
3169
3170 #ifdef _POSIX
3171 if (device_param->timer_speed.tv_sec == 0)
3172 {
3173 hc_timer_set (&device_param->timer_speed);
3174 }
3175 #endif
3176
3177 #ifdef _WIN
3178 if (device_param->timer_speed.QuadPart == 0)
3179 {
3180 hc_timer_set (&device_param->timer_speed);
3181 }
3182 #endif
3183
3184 // find higest password length, this is for optimization stuff
3185
3186 uint highest_pw_len = 0;
3187
3188 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3189 {
3190 }
3191 else if (data.attack_kern == ATTACK_KERN_COMBI)
3192 {
3193 }
3194 else if (data.attack_kern == ATTACK_KERN_BF)
3195 {
3196 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3197 + device_param->kernel_params_mp_l_buf32[5];
3198 }
3199
3200 // iteration type
3201
3202 uint innerloop_step = 0;
3203 uint innerloop_cnt = 0;
3204
3205 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3206 else innerloop_step = 1;
3207
3208 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3209 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3210 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3211
3212 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3213
3214 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3215 {
3216 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3217
3218 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3219
3220 if (data.devices_status == STATUS_CRACKED) break;
3221 if (data.devices_status == STATUS_ABORTED) break;
3222 if (data.devices_status == STATUS_QUIT) break;
3223 if (data.devices_status == STATUS_BYPASS) break;
3224
3225 salt_t *salt_buf = &data.salts_buf[salt_pos];
3226
3227 device_param->kernel_params_buf32[24] = salt_pos;
3228 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3229 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3230
3231 FILE *combs_fp = device_param->combs_fp;
3232
3233 if (data.attack_mode == ATTACK_MODE_COMBI)
3234 {
3235 rewind (combs_fp);
3236 }
3237
3238 // innerloops
3239
3240 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3241 {
3242 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3243
3244 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3245
3246 if (data.devices_status == STATUS_CRACKED) break;
3247 if (data.devices_status == STATUS_ABORTED) break;
3248 if (data.devices_status == STATUS_QUIT) break;
3249 if (data.devices_status == STATUS_BYPASS) break;
3250
3251 uint innerloop_left = innerloop_cnt - innerloop_pos;
3252
3253 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3254
3255 device_param->innerloop_pos = innerloop_pos;
3256 device_param->innerloop_left = innerloop_left;
3257
3258 device_param->kernel_params_buf32[27] = innerloop_left;
3259
3260 // i think we can get rid of this
3261 if (innerloop_left == 0)
3262 {
3263 puts ("bug, how should this happen????\n");
3264
3265 continue;
3266 }
3267
3268 if (data.salts_shown[salt_pos] == 1)
3269 {
3270 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3271
3272 continue;
3273 }
3274
3275 // initialize amplifiers
3276
3277 if (data.attack_mode == ATTACK_MODE_COMBI)
3278 {
3279 uint i = 0;
3280
3281 while (i < innerloop_left)
3282 {
3283 if (feof (combs_fp)) break;
3284
3285 int line_len = fgetl (combs_fp, line_buf);
3286
3287 if (line_len >= PW_MAX1) continue;
3288
3289 line_len = convert_from_hex (line_buf, line_len);
3290
3291 char *line_buf_new = line_buf;
3292
3293 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3294 {
3295 char rule_buf_out[BLOCK_SIZE] = { 0 };
3296
3297 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3298
3299 if (rule_len_out < 0)
3300 {
3301 data.words_progress_rejected[salt_pos] += pws_cnt;
3302
3303 continue;
3304 }
3305
3306 line_len = rule_len_out;
3307
3308 line_buf_new = rule_buf_out;
3309 }
3310
3311 line_len = MIN (line_len, PW_DICTMAX);
3312
3313 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3314
3315 memcpy (ptr, line_buf_new, line_len);
3316
3317 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3318
3319 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3320 {
3321 uppercase (ptr, line_len);
3322 }
3323
3324 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3325 {
3326 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3327 {
3328 ptr[line_len] = 0x80;
3329 }
3330
3331 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3332 {
3333 ptr[line_len] = 0x01;
3334 }
3335 }
3336
3337 device_param->combs_buf[i].pw_len = line_len;
3338
3339 i++;
3340 }
3341
3342 for (uint j = i; j < innerloop_left; j++)
3343 {
3344 device_param->combs_buf[j].i[0] = 0;
3345 device_param->combs_buf[j].i[1] = 0;
3346 device_param->combs_buf[j].i[2] = 0;
3347 device_param->combs_buf[j].i[3] = 0;
3348 device_param->combs_buf[j].i[4] = 0;
3349 device_param->combs_buf[j].i[5] = 0;
3350 device_param->combs_buf[j].i[6] = 0;
3351 device_param->combs_buf[j].i[7] = 0;
3352
3353 device_param->combs_buf[j].pw_len = 0;
3354 }
3355
3356 innerloop_left = i;
3357 }
3358 else if (data.attack_mode == ATTACK_MODE_BF)
3359 {
3360 u64 off = innerloop_pos;
3361
3362 device_param->kernel_params_mp_r_buf64[3] = off;
3363
3364 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3365 }
3366 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3367 {
3368 u64 off = innerloop_pos;
3369
3370 device_param->kernel_params_mp_buf64[3] = off;
3371
3372 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3373 }
3374 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3375 {
3376 u64 off = innerloop_pos;
3377
3378 device_param->kernel_params_mp_buf64[3] = off;
3379
3380 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3381 }
3382
3383 // copy amplifiers
3384
3385 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3386 {
3387 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
3388 }
3389 else if (data.attack_mode == ATTACK_MODE_COMBI)
3390 {
3391 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
3392 }
3393 else if (data.attack_mode == ATTACK_MODE_BF)
3394 {
3395 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
3396 }
3397 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3398 {
3399 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3400 }
3401 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3402 {
3403 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3404 }
3405
3406 if (data.benchmark == 1)
3407 {
3408 hc_timer_set (&device_param->timer_speed);
3409 }
3410
3411 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3412
3413 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3414
3415 if (data.devices_status == STATUS_CRACKED) break;
3416 if (data.devices_status == STATUS_ABORTED) break;
3417 if (data.devices_status == STATUS_QUIT) break;
3418
3419 /**
3420 * result
3421 */
3422
3423 check_cracked (device_param, salt_pos);
3424
3425 /**
3426 * progress
3427 */
3428
3429 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3430
3431 hc_thread_mutex_lock (mux_counter);
3432
3433 data.words_progress_done[salt_pos] += perf_sum_all;
3434
3435 hc_thread_mutex_unlock (mux_counter);
3436
3437 /**
3438 * speed
3439 */
3440
3441 double speed_ms;
3442
3443 hc_timer_get (device_param->timer_speed, speed_ms);
3444
3445 hc_timer_set (&device_param->timer_speed);
3446
3447 // current speed
3448
3449 //hc_thread_mutex_lock (mux_display);
3450
3451 device_param->speed_cnt[speed_pos] = perf_sum_all;
3452
3453 device_param->speed_ms[speed_pos] = speed_ms;
3454
3455 //hc_thread_mutex_unlock (mux_display);
3456
3457 speed_pos++;
3458
3459 if (speed_pos == SPEED_CACHE)
3460 {
3461 speed_pos = 0;
3462 }
3463
3464 /**
3465 * benchmark
3466 */
3467
3468 if (data.benchmark == 1) break;
3469 }
3470 }
3471
3472 device_param->speed_pos = speed_pos;
3473
3474 myfree (line_buf);
3475 }
3476
3477 static void load_segment (wl_data_t *wl_data, FILE *fd)
3478 {
3479 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3480
3481 wl_data->pos = 0;
3482
3483 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3484
3485 wl_data->buf[wl_data->cnt] = 0;
3486
3487 if (wl_data->cnt == 0) return;
3488
3489 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3490
3491 while (!feof (fd))
3492 {
3493 if (wl_data->cnt == wl_data->avail)
3494 {
3495 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3496
3497 wl_data->avail += wl_data->incr;
3498 }
3499
3500 const int c = fgetc (fd);
3501
3502 if (c == EOF) break;
3503
3504 wl_data->buf[wl_data->cnt] = (char) c;
3505
3506 wl_data->cnt++;
3507
3508 if (c == '\n') break;
3509 }
3510
3511 // ensure stream ends with a newline
3512
3513 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3514 {
3515 wl_data->cnt++;
3516
3517 wl_data->buf[wl_data->cnt - 1] = '\n';
3518 }
3519
3520 return;
3521 }
3522
3523 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3524 {
3525 char *ptr = buf;
3526
3527 for (u32 i = 0; i < sz; i++, ptr++)
3528 {
3529 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3530
3531 if (i == 7)
3532 {
3533 *off = i;
3534 *len = i;
3535
3536 return;
3537 }
3538
3539 if (*ptr != '\n') continue;
3540
3541 *off = i + 1;
3542
3543 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3544
3545 *len = i;
3546
3547 return;
3548 }
3549
3550 *off = sz;
3551 *len = sz;
3552 }
3553
3554 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3555 {
3556 char *ptr = buf;
3557
3558 for (u32 i = 0; i < sz; i++, ptr++)
3559 {
3560 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3561
3562 if (*ptr != '\n') continue;
3563
3564 *off = i + 1;
3565
3566 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3567
3568 *len = i;
3569
3570 return;
3571 }
3572
3573 *off = sz;
3574 *len = sz;
3575 }
3576
3577 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3578 {
3579 char *ptr = buf;
3580
3581 for (u32 i = 0; i < sz; i++, ptr++)
3582 {
3583 if (*ptr != '\n') continue;
3584
3585 *off = i + 1;
3586
3587 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3588
3589 *len = i;
3590
3591 return;
3592 }
3593
3594 *off = sz;
3595 *len = sz;
3596 }
3597
3598 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3599 {
3600 while (wl_data->pos < wl_data->cnt)
3601 {
3602 uint off;
3603 uint len;
3604
3605 char *ptr = wl_data->buf + wl_data->pos;
3606
3607 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3608
3609 wl_data->pos += off;
3610
3611 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3612 {
3613 char rule_buf_out[BLOCK_SIZE] = { 0 };
3614
3615 int rule_len_out = -1;
3616
3617 if (len < BLOCK_SIZE)
3618 {
3619 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3620 }
3621
3622 if (rule_len_out < 0)
3623 {
3624 continue;
3625 }
3626
3627 if (rule_len_out > PW_MAX)
3628 {
3629 continue;
3630 }
3631 }
3632 else
3633 {
3634 if (len > PW_MAX)
3635 {
3636 continue;
3637 }
3638 }
3639
3640 *out_buf = ptr;
3641 *out_len = len;
3642
3643 return;
3644 }
3645
3646 if (feof (fd))
3647 {
3648 fprintf (stderr, "BUG feof()!!\n");
3649
3650 return;
3651 }
3652
3653 load_segment (wl_data, fd);
3654
3655 get_next_word (wl_data, fd, out_buf, out_len);
3656 }
3657
3658 #ifdef _POSIX
3659 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3660 #endif
3661
3662 #ifdef _WIN
3663 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3664 #endif
3665 {
3666 hc_signal (NULL);
3667
3668 dictstat_t d;
3669
3670 d.cnt = 0;
3671
3672 #ifdef _POSIX
3673 fstat (fileno (fd), &d.stat);
3674 #endif
3675
3676 #ifdef _WIN
3677 _fstat64 (fileno (fd), &d.stat);
3678 #endif
3679
3680 d.stat.st_mode = 0;
3681 d.stat.st_nlink = 0;
3682 d.stat.st_uid = 0;
3683 d.stat.st_gid = 0;
3684 d.stat.st_rdev = 0;
3685 d.stat.st_atime = 0;
3686
3687 #ifdef _POSIX
3688 d.stat.st_blksize = 0;
3689 d.stat.st_blocks = 0;
3690 #endif
3691
3692 if (d.stat.st_size == 0) return 0;
3693
3694 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3695
3696 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3697 {
3698 if (d_cache)
3699 {
3700 u64 cnt = d_cache->cnt;
3701
3702 u64 keyspace = cnt;
3703
3704 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3705 {
3706 keyspace *= data.kernel_rules_cnt;
3707 }
3708 else if (data.attack_kern == ATTACK_KERN_COMBI)
3709 {
3710 keyspace *= data.combs_cnt;
3711 }
3712
3713 if (data.quiet == 0) log_info ("Cache-hit dictionary stats %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) d.stat.st_size, (unsigned long long int) cnt, (unsigned long long int) keyspace);
3714 if (data.quiet == 0) log_info ("");
3715
3716 hc_signal (sigHandler_default);
3717
3718 return (keyspace);
3719 }
3720 }
3721
3722 time_t now = 0;
3723 time_t prev = 0;
3724
3725 u64 comp = 0;
3726 u64 cnt = 0;
3727 u64 cnt2 = 0;
3728
3729 while (!feof (fd))
3730 {
3731 load_segment (wl_data, fd);
3732
3733 comp += wl_data->cnt;
3734
3735 u32 i = 0;
3736
3737 while (i < wl_data->cnt)
3738 {
3739 u32 len;
3740 u32 off;
3741
3742 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3743
3744 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3745 {
3746 char rule_buf_out[BLOCK_SIZE] = { 0 };
3747
3748 int rule_len_out = -1;
3749
3750 if (len < BLOCK_SIZE)
3751 {
3752 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3753 }
3754
3755 if (rule_len_out < 0)
3756 {
3757 len = PW_MAX1;
3758 }
3759 else
3760 {
3761 len = rule_len_out;
3762 }
3763 }
3764
3765 if (len < PW_MAX1)
3766 {
3767 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3768 {
3769 cnt += data.kernel_rules_cnt;
3770 }
3771 else if (data.attack_kern == ATTACK_KERN_COMBI)
3772 {
3773 cnt += data.combs_cnt;
3774 }
3775
3776 d.cnt++;
3777 }
3778
3779 i += off;
3780
3781 cnt2++;
3782 }
3783
3784 time (&now);
3785
3786 if ((now - prev) == 0) continue;
3787
3788 float percent = (float) comp / (float) d.stat.st_size;
3789
3790 if (data.quiet == 0) log_info_nn ("Generating dictionary stats for %s: %llu bytes (%.2f%%), %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, percent * 100, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3791
3792 time (&prev);
3793 }
3794
3795 if (data.quiet == 0) log_info ("Generated dictionary stats for %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3796 if (data.quiet == 0) log_info ("");
3797
3798 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3799
3800 hc_signal (sigHandler_default);
3801
3802 return (cnt);
3803 }
3804
3805 static void *thread_monitor (void *p)
3806 {
3807 uint runtime_check = 0;
3808 uint remove_check = 0;
3809 uint status_check = 0;
3810 uint restore_check = 0;
3811
3812 uint restore_left = data.restore_timer;
3813 uint remove_left = data.remove_timer;
3814 uint status_left = data.status_timer;
3815
3816 #ifdef HAVE_HWMON
3817 uint hwmon_check = 0;
3818
3819 int slowdown_warnings = 0;
3820
3821 // these variables are mainly used for fan control
3822
3823 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3824
3825 // temperature controller "loopback" values
3826
3827 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3828 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3829
3830 int temp_threshold = 1; // degrees celcius
3831
3832 int fan_speed_min = 15; // in percentage
3833 int fan_speed_max = 100;
3834
3835 time_t last_temp_check_time;
3836 #endif // HAVE_HWMON
3837
3838 uint sleep_time = 1;
3839
3840 if (data.runtime)
3841 {
3842 runtime_check = 1;
3843 }
3844
3845 if (data.restore_timer)
3846 {
3847 restore_check = 1;
3848 }
3849
3850 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3851 {
3852 remove_check = 1;
3853 }
3854
3855 if (data.status == 1)
3856 {
3857 status_check = 1;
3858 }
3859
3860 #ifdef HAVE_HWMON
3861 if (data.gpu_temp_disable == 0)
3862 {
3863 time (&last_temp_check_time);
3864
3865 hwmon_check = 1;
3866 }
3867 #endif
3868
3869 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3870 {
3871 #ifdef HAVE_HWMON
3872 if (hwmon_check == 0)
3873 #endif
3874 return (p);
3875 }
3876
3877 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3878 {
3879 hc_sleep (sleep_time);
3880
3881 if (data.devices_status != STATUS_RUNNING) continue;
3882
3883 #ifdef HAVE_HWMON
3884
3885 if (1)
3886 {
3887 hc_thread_mutex_lock (mux_adl);
3888
3889 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3890 {
3891 hc_device_param_t *device_param = &data.devices_param[device_id];
3892
3893 if (device_param->skipped) continue;
3894
3895 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3896
3897 const int temperature = hm_get_temperature_with_device_id (device_id);
3898
3899 const int threshold = data.hm_device[device_id].gpu_temp_threshold_slowdown;
3900
3901 if (temperature >= threshold)
3902 {
3903 if (slowdown_warnings < 3)
3904 {
3905 if (data.quiet == 0) clear_prompt ();
3906
3907 log_info ("WARNING: Drivers temperature threshold (%dc) hit on GPU #%d, expect performance to drop...", threshold, device_id + 1);
3908
3909 if (slowdown_warnings == 2)
3910 {
3911 log_info ("");
3912 }
3913
3914 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
3915 if (data.quiet == 0) fflush (stdout);
3916
3917 slowdown_warnings++;
3918 }
3919 }
3920 else
3921 {
3922 slowdown_warnings = 0;
3923 }
3924 }
3925
3926 hc_thread_mutex_unlock (mux_adl);
3927 }
3928
3929 if (hwmon_check == 1)
3930 {
3931 hc_thread_mutex_lock (mux_adl);
3932
3933 time_t temp_check_time;
3934
3935 time (&temp_check_time);
3936
3937 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3938
3939 if (Ta == 0) Ta = 1;
3940
3941 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3942 {
3943 hc_device_param_t *device_param = &data.devices_param[device_id];
3944
3945 if (device_param->skipped) continue;
3946
3947 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3948
3949 const int temperature = hm_get_temperature_with_device_id (device_id);
3950
3951 if (temperature > (int) data.gpu_temp_abort)
3952 {
3953 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3954
3955 if (data.devices_status != STATUS_QUIT) myabort ();
3956
3957 break;
3958 }
3959
3960 const int gpu_temp_retain = data.gpu_temp_retain;
3961
3962 if (gpu_temp_retain)
3963 {
3964 if (data.hm_device[device_id].fan_set_supported == 1)
3965 {
3966 int temp_cur = temperature;
3967
3968 int temp_diff_new = gpu_temp_retain - temp_cur;
3969
3970 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3971
3972 // calculate Ta value (time difference in seconds between the last check and this check)
3973
3974 last_temp_check_time = temp_check_time;
3975
3976 float Kp = 1.8;
3977 float Ki = 0.005;
3978 float Kd = 6;
3979
3980 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3981
3982 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
3983
3984 if (abs (fan_diff_required) >= temp_threshold)
3985 {
3986 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3987
3988 int fan_speed_level = fan_speed_cur;
3989
3990 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3991
3992 int fan_speed_new = fan_speed_level - fan_diff_required;
3993
3994 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3995 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3996
3997 if (fan_speed_new != fan_speed_cur)
3998 {
3999 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4000 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4001
4002 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4003 {
4004 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4005 {
4006 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new, 1);
4007 }
4008 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4009 {
4010
4011 }
4012
4013 fan_speed_chgd[device_id] = 1;
4014 }
4015
4016 temp_diff_old[device_id] = temp_diff_new;
4017 }
4018 }
4019 }
4020 }
4021 }
4022
4023 hc_thread_mutex_unlock (mux_adl);
4024 }
4025 #endif // HAVE_HWMON
4026
4027 if (restore_check == 1)
4028 {
4029 restore_left--;
4030
4031 if (restore_left == 0)
4032 {
4033 if (data.restore_disable == 0) cycle_restore ();
4034
4035 restore_left = data.restore_timer;
4036 }
4037 }
4038
4039 if ((runtime_check == 1) && (data.runtime_start > 0))
4040 {
4041 time_t runtime_cur;
4042
4043 time (&runtime_cur);
4044
4045 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4046
4047 if (runtime_left <= 0)
4048 {
4049 if (data.benchmark == 0)
4050 {
4051 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4052 }
4053
4054 if (data.devices_status != STATUS_QUIT) myabort ();
4055 }
4056 }
4057
4058 if (remove_check == 1)
4059 {
4060 remove_left--;
4061
4062 if (remove_left == 0)
4063 {
4064 if (data.digests_saved != data.digests_done)
4065 {
4066 data.digests_saved = data.digests_done;
4067
4068 save_hash ();
4069 }
4070
4071 remove_left = data.remove_timer;
4072 }
4073 }
4074
4075 if (status_check == 1)
4076 {
4077 status_left--;
4078
4079 if (status_left == 0)
4080 {
4081 //hc_thread_mutex_lock (mux_display);
4082
4083 if (data.quiet == 0) clear_prompt ();
4084
4085 if (data.quiet == 0) log_info ("");
4086
4087 status_display ();
4088
4089 if (data.quiet == 0) log_info ("");
4090
4091 //hc_thread_mutex_unlock (mux_display);
4092
4093 status_left = data.status_timer;
4094 }
4095 }
4096 }
4097
4098 #ifdef HAVE_HWMON
4099 myfree (fan_speed_chgd);
4100
4101 myfree (temp_diff_old);
4102 myfree (temp_diff_sum);
4103 #endif
4104
4105 p = NULL;
4106
4107 return (p);
4108 }
4109
4110 static void *thread_outfile_remove (void *p)
4111 {
4112 // some hash-dependent constants
4113 char *outfile_dir = data.outfile_check_directory;
4114 uint dgst_size = data.dgst_size;
4115 uint isSalted = data.isSalted;
4116 uint esalt_size = data.esalt_size;
4117 uint hash_mode = data.hash_mode;
4118
4119 uint outfile_check_timer = data.outfile_check_timer;
4120
4121 char separator = data.separator;
4122
4123 // some hash-dependent functions
4124 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4125 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4126
4127 // buffers
4128 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4129
4130 hash_buf.digest = mymalloc (dgst_size);
4131
4132 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4133
4134 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4135
4136 uint digest_buf[64] = { 0 };
4137
4138 outfile_data_t *out_info = NULL;
4139
4140 char **out_files = NULL;
4141
4142 time_t folder_mtime = 0;
4143
4144 int out_cnt = 0;
4145
4146 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4147
4148 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4149 {
4150 hc_sleep (1);
4151
4152 if (data.devices_status != STATUS_RUNNING) continue;
4153
4154 check_left--;
4155
4156 if (check_left == 0)
4157 {
4158 struct stat outfile_check_stat;
4159
4160 if (stat (outfile_dir, &outfile_check_stat) == 0)
4161 {
4162 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4163
4164 if (is_dir == 1)
4165 {
4166 if (outfile_check_stat.st_mtime > folder_mtime)
4167 {
4168 char **out_files_new = scan_directory (outfile_dir);
4169
4170 int out_cnt_new = count_dictionaries (out_files_new);
4171
4172 outfile_data_t *out_info_new = NULL;
4173
4174 if (out_cnt_new > 0)
4175 {
4176 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4177
4178 for (int i = 0; i < out_cnt_new; i++)
4179 {
4180 out_info_new[i].file_name = out_files_new[i];
4181
4182 // check if there are files that we have seen/checked before (and not changed)
4183
4184 for (int j = 0; j < out_cnt; j++)
4185 {
4186 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4187 {
4188 struct stat outfile_stat;
4189
4190 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4191 {
4192 if (outfile_stat.st_ctime == out_info[j].ctime)
4193 {
4194 out_info_new[i].ctime = out_info[j].ctime;
4195 out_info_new[i].seek = out_info[j].seek;
4196 }
4197 }
4198 }
4199 }
4200 }
4201 }
4202
4203 local_free (out_info);
4204 local_free (out_files);
4205
4206 out_files = out_files_new;
4207 out_cnt = out_cnt_new;
4208 out_info = out_info_new;
4209
4210 folder_mtime = outfile_check_stat.st_mtime;
4211 }
4212
4213 for (int j = 0; j < out_cnt; j++)
4214 {
4215 FILE *fp = fopen (out_info[j].file_name, "rb");
4216
4217 if (fp != NULL)
4218 {
4219 //hc_thread_mutex_lock (mux_display);
4220
4221 #ifdef _POSIX
4222 struct stat outfile_stat;
4223
4224 fstat (fileno (fp), &outfile_stat);
4225 #endif
4226
4227 #ifdef _WIN
4228 struct stat64 outfile_stat;
4229
4230 _fstat64 (fileno (fp), &outfile_stat);
4231 #endif
4232
4233 if (outfile_stat.st_ctime > out_info[j].ctime)
4234 {
4235 out_info[j].ctime = outfile_stat.st_ctime;
4236 out_info[j].seek = 0;
4237 }
4238
4239 fseek (fp, out_info[j].seek, SEEK_SET);
4240
4241 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4242
4243 while (!feof (fp))
4244 {
4245 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4246
4247 if (ptr == NULL) break;
4248
4249 int line_len = strlen (line_buf);
4250
4251 if (line_len <= 0) continue;
4252
4253 int iter = MAX_CUT_TRIES;
4254
4255 for (uint i = line_len - 1; i && iter; i--, line_len--)
4256 {
4257 if (line_buf[i] != separator) continue;
4258
4259 int parser_status = PARSER_OK;
4260
4261 if ((hash_mode != 2500) && (hash_mode != 6800))
4262 {
4263 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4264 }
4265
4266 uint found = 0;
4267
4268 if (parser_status == PARSER_OK)
4269 {
4270 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4271 {
4272 if (data.salts_shown[salt_pos] == 1) continue;
4273
4274 salt_t *salt_buf = &data.salts_buf[salt_pos];
4275
4276 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4277 {
4278 uint idx = salt_buf->digests_offset + digest_pos;
4279
4280 if (data.digests_shown[idx] == 1) continue;
4281
4282 uint cracked = 0;
4283
4284 if (hash_mode == 6800)
4285 {
4286 if (i == salt_buf->salt_len)
4287 {
4288 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4289 }
4290 }
4291 else if (hash_mode == 2500)
4292 {
4293 // BSSID : MAC1 : MAC2 (:plain)
4294 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4295 {
4296 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4297
4298 if (!cracked) continue;
4299
4300 // now compare MAC1 and MAC2 too, since we have this additional info
4301 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4302 char *mac2_pos = mac1_pos + 12 + 1;
4303
4304 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4305 wpa_t *wpa = &wpas[salt_pos];
4306
4307 // compare hex string(s) vs binary MAC address(es)
4308
4309 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4310 {
4311 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4312 {
4313 cracked = 0;
4314
4315 break;
4316 }
4317 }
4318
4319 // early skip ;)
4320 if (!cracked) continue;
4321
4322 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4323 {
4324 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4325 {
4326 cracked = 0;
4327
4328 break;
4329 }
4330 }
4331 }
4332 }
4333 else
4334 {
4335 char *digests_buf_ptr = (char *) data.digests_buf;
4336
4337 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4338
4339 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4340 }
4341
4342 if (cracked == 1)
4343 {
4344 found = 1;
4345
4346 data.digests_shown[idx] = 1;
4347
4348 data.digests_done++;
4349
4350 salt_buf->digests_done++;
4351
4352 if (salt_buf->digests_done == salt_buf->digests_cnt)
4353 {
4354 data.salts_shown[salt_pos] = 1;
4355
4356 data.salts_done++;
4357
4358 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4359 }
4360 }
4361 }
4362
4363 if (data.devices_status == STATUS_CRACKED) break;
4364 }
4365 }
4366
4367 if (found) break;
4368
4369 if (data.devices_status == STATUS_CRACKED) break;
4370
4371 iter--;
4372 }
4373
4374 if (data.devices_status == STATUS_CRACKED) break;
4375 }
4376
4377 myfree (line_buf);
4378
4379 out_info[j].seek = ftell (fp);
4380
4381 //hc_thread_mutex_unlock (mux_display);
4382
4383 fclose (fp);
4384 }
4385 }
4386 }
4387 }
4388
4389 check_left = outfile_check_timer;
4390 }
4391 }
4392
4393 if (esalt_size) local_free (hash_buf.esalt);
4394
4395 if (isSalted) local_free (hash_buf.salt);
4396
4397 local_free (hash_buf.digest);
4398
4399 local_free (out_info);
4400
4401 local_free (out_files);
4402
4403 p = NULL;
4404
4405 return (p);
4406 }
4407
4408 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4409 {
4410 if (device_param->pws_cnt < device_param->kernel_power)
4411 {
4412 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4413
4414 u8 *ptr = (u8 *) pw->i;
4415
4416 memcpy (ptr, pw_buf, pw_len);
4417
4418 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4419
4420 pw->pw_len = pw_len;
4421
4422 device_param->pws_cnt++;
4423 }
4424 else
4425 {
4426 fprintf (stderr, "BUG pw_add()!!\n");
4427
4428 return;
4429 }
4430 }
4431
4432 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4433 {
4434 hc_thread_mutex_lock (mux_dispatcher);
4435
4436 const u64 words_cur = data.words_cur;
4437 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4438
4439 device_param->words_off = words_cur;
4440
4441 const u64 words_left = words_base - words_cur;
4442
4443 if (allow_div)
4444 {
4445 if (data.kernel_power_all > words_left)
4446 {
4447 if (data.kernel_power_div == 0)
4448 {
4449 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4450 }
4451 }
4452
4453 if (data.kernel_power_div)
4454 {
4455 if (device_param->kernel_power == device_param->kernel_power_user)
4456 {
4457 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4458
4459 if (kernel_power_new < device_param->kernel_power)
4460 {
4461 device_param->kernel_power = kernel_power_new;
4462 }
4463 }
4464 }
4465 }
4466
4467 const uint kernel_power = device_param->kernel_power;
4468
4469 uint work = MIN (words_left, kernel_power);
4470
4471 work = MIN (work, max);
4472
4473 data.words_cur += work;
4474
4475 hc_thread_mutex_unlock (mux_dispatcher);
4476
4477 return work;
4478 }
4479
4480 static void *thread_calc_stdin (void *p)
4481 {
4482 hc_device_param_t *device_param = (hc_device_param_t *) p;
4483
4484 if (device_param->skipped) return NULL;
4485
4486 autotune (device_param);
4487
4488 char *buf = (char *) mymalloc (HCBUFSIZ);
4489
4490 const uint attack_kern = data.attack_kern;
4491
4492 const uint kernel_power = device_param->kernel_power;
4493
4494 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4495 {
4496 hc_thread_mutex_lock (mux_dispatcher);
4497
4498 if (feof (stdin) != 0)
4499 {
4500 hc_thread_mutex_unlock (mux_dispatcher);
4501
4502 break;
4503 }
4504
4505 uint words_cur = 0;
4506
4507 while (words_cur < kernel_power)
4508 {
4509 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4510
4511 if (line_buf == NULL) break;
4512
4513 uint line_len = in_superchop (line_buf);
4514
4515 line_len = convert_from_hex (line_buf, line_len);
4516
4517 // post-process rule engine
4518
4519 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4520 {
4521 char rule_buf_out[BLOCK_SIZE] = { 0 };
4522
4523 int rule_len_out = -1;
4524
4525 if (line_len < BLOCK_SIZE)
4526 {
4527 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4528 }
4529
4530 if (rule_len_out < 0) continue;
4531
4532 line_buf = rule_buf_out;
4533 line_len = rule_len_out;
4534 }
4535
4536 if (line_len > PW_MAX)
4537 {
4538 continue;
4539 }
4540
4541 if (attack_kern == ATTACK_KERN_STRAIGHT)
4542 {
4543 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4544 {
4545 hc_thread_mutex_lock (mux_counter);
4546
4547 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4548 {
4549 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4550 }
4551
4552 hc_thread_mutex_unlock (mux_counter);
4553
4554 continue;
4555 }
4556 }
4557 else if (attack_kern == ATTACK_KERN_COMBI)
4558 {
4559 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4560 // since we still need to combine the plains
4561
4562 if (line_len > data.pw_max)
4563 {
4564 hc_thread_mutex_lock (mux_counter);
4565
4566 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4567 {
4568 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4569 }
4570
4571 hc_thread_mutex_unlock (mux_counter);
4572
4573 continue;
4574 }
4575 }
4576
4577 pw_add (device_param, (u8 *) line_buf, line_len);
4578
4579 words_cur++;
4580
4581 if (data.devices_status == STATUS_CRACKED) break;
4582 if (data.devices_status == STATUS_ABORTED) break;
4583 if (data.devices_status == STATUS_QUIT) break;
4584 if (data.devices_status == STATUS_BYPASS) break;
4585 }
4586
4587 hc_thread_mutex_unlock (mux_dispatcher);
4588
4589 if (data.devices_status == STATUS_CRACKED) break;
4590 if (data.devices_status == STATUS_ABORTED) break;
4591 if (data.devices_status == STATUS_QUIT) break;
4592 if (data.devices_status == STATUS_BYPASS) break;
4593
4594 // flush
4595
4596 const uint pws_cnt = device_param->pws_cnt;
4597
4598 if (pws_cnt)
4599 {
4600 run_copy (device_param, pws_cnt);
4601
4602 run_cracker (device_param, pws_cnt);
4603
4604 device_param->pws_cnt = 0;
4605
4606 /*
4607 still required?
4608 if (attack_kern == ATTACK_KERN_STRAIGHT)
4609 {
4610 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4611 }
4612 else if (attack_kern == ATTACK_KERN_COMBI)
4613 {
4614 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4615 }
4616 */
4617 }
4618 }
4619
4620 device_param->kernel_accel = 0;
4621 device_param->kernel_loops = 0;
4622
4623 myfree (buf);
4624
4625 return NULL;
4626 }
4627
4628 static void *thread_calc (void *p)
4629 {
4630 hc_device_param_t *device_param = (hc_device_param_t *) p;
4631
4632 if (device_param->skipped) return NULL;
4633
4634 autotune (device_param);
4635
4636 const uint attack_mode = data.attack_mode;
4637 const uint attack_kern = data.attack_kern;
4638
4639 if (attack_mode == ATTACK_MODE_BF)
4640 {
4641 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4642 {
4643 const uint work = get_work (device_param, -1, true);
4644
4645 if (work == 0) break;
4646
4647 const u64 words_off = device_param->words_off;
4648 const u64 words_fin = words_off + work;
4649
4650 const uint pws_cnt = work;
4651
4652 device_param->pws_cnt = pws_cnt;
4653
4654 if (pws_cnt)
4655 {
4656 run_copy (device_param, pws_cnt);
4657
4658 run_cracker (device_param, pws_cnt);
4659
4660 device_param->pws_cnt = 0;
4661
4662 /*
4663 still required?
4664 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4665 */
4666 }
4667
4668 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4669
4670 if (data.devices_status == STATUS_CRACKED) break;
4671 if (data.devices_status == STATUS_ABORTED) break;
4672 if (data.devices_status == STATUS_QUIT) break;
4673 if (data.devices_status == STATUS_BYPASS) break;
4674
4675 if (data.benchmark == 1) break;
4676
4677 device_param->words_done = words_fin;
4678 }
4679 }
4680 else
4681 {
4682 const uint segment_size = data.segment_size;
4683
4684 char *dictfile = data.dictfile;
4685
4686 if (attack_mode == ATTACK_MODE_COMBI)
4687 {
4688 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4689 {
4690 dictfile = data.dictfile2;
4691 }
4692 }
4693
4694 FILE *fd = fopen (dictfile, "rb");
4695
4696 if (fd == NULL)
4697 {
4698 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4699
4700 return NULL;
4701 }
4702
4703 if (attack_mode == ATTACK_MODE_COMBI)
4704 {
4705 const uint combs_mode = data.combs_mode;
4706
4707 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4708 {
4709 const char *dictfilec = data.dictfile2;
4710
4711 FILE *combs_fp = fopen (dictfilec, "rb");
4712
4713 if (combs_fp == NULL)
4714 {
4715 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4716
4717 fclose (fd);
4718
4719 return NULL;
4720 }
4721
4722 device_param->combs_fp = combs_fp;
4723 }
4724 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4725 {
4726 const char *dictfilec = data.dictfile;
4727
4728 FILE *combs_fp = fopen (dictfilec, "rb");
4729
4730 if (combs_fp == NULL)
4731 {
4732 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4733
4734 fclose (fd);
4735
4736 return NULL;
4737 }
4738
4739 device_param->combs_fp = combs_fp;
4740 }
4741 }
4742
4743 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4744
4745 wl_data->buf = (char *) mymalloc (segment_size);
4746 wl_data->avail = segment_size;
4747 wl_data->incr = segment_size;
4748 wl_data->cnt = 0;
4749 wl_data->pos = 0;
4750
4751 u64 words_cur = 0;
4752
4753 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4754 {
4755 u64 words_off = 0;
4756 u64 words_fin = 0;
4757
4758 bool allow_div = true;
4759
4760 u64 max = -1;
4761
4762 while (max)
4763 {
4764 const uint work = get_work (device_param, max, allow_div);
4765
4766 allow_div = false;
4767
4768 if (work == 0) break;
4769
4770 words_off = device_param->words_off;
4771 words_fin = words_off + work;
4772
4773 char *line_buf;
4774 uint line_len;
4775
4776 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4777
4778 max = 0;
4779
4780 for ( ; words_cur < words_fin; words_cur++)
4781 {
4782 get_next_word (wl_data, fd, &line_buf, &line_len);
4783
4784 line_len = convert_from_hex (line_buf, line_len);
4785
4786 // post-process rule engine
4787
4788 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4789 {
4790 char rule_buf_out[BLOCK_SIZE] = { 0 };
4791
4792 int rule_len_out = -1;
4793
4794 if (line_len < BLOCK_SIZE)
4795 {
4796 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4797 }
4798
4799 if (rule_len_out < 0) continue;
4800
4801 line_buf = rule_buf_out;
4802 line_len = rule_len_out;
4803 }
4804
4805 if (attack_kern == ATTACK_KERN_STRAIGHT)
4806 {
4807 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4808 {
4809 max++;
4810
4811 hc_thread_mutex_lock (mux_counter);
4812
4813 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4814 {
4815 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4816 }
4817
4818 hc_thread_mutex_unlock (mux_counter);
4819
4820 continue;
4821 }
4822 }
4823 else if (attack_kern == ATTACK_KERN_COMBI)
4824 {
4825 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4826 // since we still need to combine the plains
4827
4828 if (line_len > data.pw_max)
4829 {
4830 max++;
4831
4832 hc_thread_mutex_lock (mux_counter);
4833
4834 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4835 {
4836 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4837 }
4838
4839 hc_thread_mutex_unlock (mux_counter);
4840
4841 continue;
4842 }
4843 }
4844
4845 pw_add (device_param, (u8 *) line_buf, line_len);
4846
4847 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4848
4849 if (data.devices_status == STATUS_CRACKED) break;
4850 if (data.devices_status == STATUS_ABORTED) break;
4851 if (data.devices_status == STATUS_QUIT) break;
4852 if (data.devices_status == STATUS_BYPASS) break;
4853 }
4854
4855 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4856
4857 if (data.devices_status == STATUS_CRACKED) break;
4858 if (data.devices_status == STATUS_ABORTED) break;
4859 if (data.devices_status == STATUS_QUIT) break;
4860 if (data.devices_status == STATUS_BYPASS) break;
4861 }
4862
4863 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4864
4865 if (data.devices_status == STATUS_CRACKED) break;
4866 if (data.devices_status == STATUS_ABORTED) break;
4867 if (data.devices_status == STATUS_QUIT) break;
4868 if (data.devices_status == STATUS_BYPASS) break;
4869
4870 //
4871 // flush
4872 //
4873
4874 const uint pws_cnt = device_param->pws_cnt;
4875
4876 if (pws_cnt)
4877 {
4878 run_copy (device_param, pws_cnt);
4879
4880 run_cracker (device_param, pws_cnt);
4881
4882 device_param->pws_cnt = 0;
4883
4884 /*
4885 still required?
4886 if (attack_kern == ATTACK_KERN_STRAIGHT)
4887 {
4888 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4889 }
4890 else if (attack_kern == ATTACK_KERN_COMBI)
4891 {
4892 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4893 }
4894 */
4895 }
4896
4897 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4898
4899 if (data.devices_status == STATUS_CRACKED) break;
4900 if (data.devices_status == STATUS_ABORTED) break;
4901 if (data.devices_status == STATUS_QUIT) break;
4902 if (data.devices_status == STATUS_BYPASS) break;
4903
4904 if (words_fin == 0) break;
4905
4906 device_param->words_done = words_fin;
4907 }
4908
4909 if (attack_mode == ATTACK_MODE_COMBI)
4910 {
4911 fclose (device_param->combs_fp);
4912 }
4913
4914 free (wl_data->buf);
4915 free (wl_data);
4916
4917 fclose (fd);
4918 }
4919
4920 device_param->kernel_accel = 0;
4921 device_param->kernel_loops = 0;
4922
4923 return NULL;
4924 }
4925
4926 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4927 {
4928 if (!device_param)
4929 {
4930 log_error ("ERROR: %s : Invalid argument", __func__);
4931
4932 exit (-1);
4933 }
4934
4935 salt_t *salt_buf = &data.salts_buf[salt_pos];
4936
4937 device_param->kernel_params_buf32[24] = salt_pos;
4938 device_param->kernel_params_buf32[27] = 1;
4939 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4940 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4941 device_param->kernel_params_buf32[30] = 0;
4942 device_param->kernel_params_buf32[31] = 1;
4943
4944 char *dictfile_old = data.dictfile;
4945
4946 const char *weak_hash_check = "weak-hash-check";
4947
4948 data.dictfile = (char *) weak_hash_check;
4949
4950 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4951
4952 data.kernel_rules_buf[0].cmds[0] = 0;
4953
4954 /**
4955 * run the kernel
4956 */
4957
4958 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4959 {
4960 run_kernel (KERN_RUN_1, device_param, 1, false);
4961 }
4962 else
4963 {
4964 run_kernel (KERN_RUN_1, device_param, 1, false);
4965
4966 uint loop_step = 16;
4967
4968 const uint iter = salt_buf->salt_iter;
4969
4970 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4971 {
4972 uint loop_left = iter - loop_pos;
4973
4974 loop_left = MIN (loop_left, loop_step);
4975
4976 device_param->kernel_params_buf32[25] = loop_pos;
4977 device_param->kernel_params_buf32[26] = loop_left;
4978
4979 run_kernel (KERN_RUN_2, device_param, 1, false);
4980 }
4981
4982 run_kernel (KERN_RUN_3, device_param, 1, false);
4983 }
4984
4985 /**
4986 * result
4987 */
4988
4989 check_cracked (device_param, salt_pos);
4990
4991 /**
4992 * cleanup
4993 */
4994
4995 device_param->kernel_params_buf32[24] = 0;
4996 device_param->kernel_params_buf32[25] = 0;
4997 device_param->kernel_params_buf32[26] = 0;
4998 device_param->kernel_params_buf32[27] = 0;
4999 device_param->kernel_params_buf32[28] = 0;
5000 device_param->kernel_params_buf32[29] = 0;
5001 device_param->kernel_params_buf32[30] = 0;
5002 device_param->kernel_params_buf32[31] = 0;
5003
5004 data.dictfile = dictfile_old;
5005
5006 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5007 }
5008
5009 // hlfmt hashcat
5010
5011 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5012 {
5013 if (data.username == 0)
5014 {
5015 *hashbuf_pos = line_buf;
5016 *hashbuf_len = line_len;
5017 }
5018 else
5019 {
5020 char *pos = line_buf;
5021 int len = line_len;
5022
5023 for (int i = 0; i < line_len; i++, pos++, len--)
5024 {
5025 if (line_buf[i] == data.separator)
5026 {
5027 pos++;
5028
5029 len--;
5030
5031 break;
5032 }
5033 }
5034
5035 *hashbuf_pos = pos;
5036 *hashbuf_len = len;
5037 }
5038 }
5039
5040 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5041 {
5042 char *pos = NULL;
5043 int len = 0;
5044
5045 int sep_cnt = 0;
5046
5047 for (int i = 0; i < line_len; i++)
5048 {
5049 if (line_buf[i] == data.separator)
5050 {
5051 sep_cnt++;
5052
5053 continue;
5054 }
5055
5056 if (sep_cnt == 0)
5057 {
5058 if (pos == NULL) pos = line_buf + i;
5059
5060 len++;
5061 }
5062 }
5063
5064 *userbuf_pos = pos;
5065 *userbuf_len = len;
5066 }
5067
5068 // hlfmt pwdump
5069
5070 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5071 {
5072 int sep_cnt = 0;
5073
5074 int sep2_len = 0;
5075 int sep3_len = 0;
5076
5077 for (int i = 0; i < line_len; i++)
5078 {
5079 if (line_buf[i] == ':')
5080 {
5081 sep_cnt++;
5082
5083 continue;
5084 }
5085
5086 if (sep_cnt == 2) sep2_len++;
5087 if (sep_cnt == 3) sep3_len++;
5088 }
5089
5090 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5091
5092 return 0;
5093 }
5094
5095 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5096 {
5097 char *pos = NULL;
5098 int len = 0;
5099
5100 int sep_cnt = 0;
5101
5102 for (int i = 0; i < line_len; i++)
5103 {
5104 if (line_buf[i] == ':')
5105 {
5106 sep_cnt++;
5107
5108 continue;
5109 }
5110
5111 if (data.hash_mode == 1000)
5112 {
5113 if (sep_cnt == 3)
5114 {
5115 if (pos == NULL) pos = line_buf + i;
5116
5117 len++;
5118 }
5119 }
5120 else if (data.hash_mode == 3000)
5121 {
5122 if (sep_cnt == 2)
5123 {
5124 if (pos == NULL) pos = line_buf + i;
5125
5126 len++;
5127 }
5128 }
5129 }
5130
5131 *hashbuf_pos = pos;
5132 *hashbuf_len = len;
5133 }
5134
5135 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5136 {
5137 char *pos = NULL;
5138 int len = 0;
5139
5140 int sep_cnt = 0;
5141
5142 for (int i = 0; i < line_len; i++)
5143 {
5144 if (line_buf[i] == ':')
5145 {
5146 sep_cnt++;
5147
5148 continue;
5149 }
5150
5151 if (sep_cnt == 0)
5152 {
5153 if (pos == NULL) pos = line_buf + i;
5154
5155 len++;
5156 }
5157 }
5158
5159 *userbuf_pos = pos;
5160 *userbuf_len = len;
5161 }
5162
5163 // hlfmt passwd
5164
5165 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5166 {
5167 int sep_cnt = 0;
5168
5169 char sep5_first = 0;
5170 char sep6_first = 0;
5171
5172 for (int i = 0; i < line_len; i++)
5173 {
5174 if (line_buf[i] == ':')
5175 {
5176 sep_cnt++;
5177
5178 continue;
5179 }
5180
5181 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5182 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5183 }
5184
5185 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5186
5187 return 0;
5188 }
5189
5190 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5191 {
5192 char *pos = NULL;
5193 int len = 0;
5194
5195 int sep_cnt = 0;
5196
5197 for (int i = 0; i < line_len; i++)
5198 {
5199 if (line_buf[i] == ':')
5200 {
5201 sep_cnt++;
5202
5203 continue;
5204 }
5205
5206 if (sep_cnt == 1)
5207 {
5208 if (pos == NULL) pos = line_buf + i;
5209
5210 len++;
5211 }
5212 }
5213
5214 *hashbuf_pos = pos;
5215 *hashbuf_len = len;
5216 }
5217
5218 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5219 {
5220 char *pos = NULL;
5221 int len = 0;
5222
5223 int sep_cnt = 0;
5224
5225 for (int i = 0; i < line_len; i++)
5226 {
5227 if (line_buf[i] == ':')
5228 {
5229 sep_cnt++;
5230
5231 continue;
5232 }
5233
5234 if (sep_cnt == 0)
5235 {
5236 if (pos == NULL) pos = line_buf + i;
5237
5238 len++;
5239 }
5240 }
5241
5242 *userbuf_pos = pos;
5243 *userbuf_len = len;
5244 }
5245
5246 // hlfmt shadow
5247
5248 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5249 {
5250 int sep_cnt = 0;
5251
5252 for (int i = 0; i < line_len; i++)
5253 {
5254 if (line_buf[i] == ':') sep_cnt++;
5255 }
5256
5257 if (sep_cnt == 8) return 1;
5258
5259 return 0;
5260 }
5261
5262 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5263 {
5264 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5265 }
5266
5267 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5268 {
5269 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5270 }
5271
5272 // hlfmt main
5273
5274 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5275 {
5276 switch (hashfile_format)
5277 {
5278 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5279 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5280 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5281 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5282 }
5283 }
5284
5285 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5286 {
5287 switch (hashfile_format)
5288 {
5289 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5290 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5291 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5292 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5293 }
5294 }
5295
5296 char *strhlfmt (const uint hashfile_format)
5297 {
5298 switch (hashfile_format)
5299 {
5300 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5301 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5302 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5303 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5304 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5305 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5306 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5307 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5308 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5309 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5310 }
5311
5312 return ((char *) "Unknown");
5313 }
5314
5315 static uint hlfmt_detect (FILE *fp, uint max_check)
5316 {
5317 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5318
5319 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5320 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5321
5322 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5323
5324 uint num_check = 0;
5325
5326 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5327
5328 while (!feof (fp))
5329 {
5330 int line_len = fgetl (fp, line_buf);
5331
5332 if (line_len == 0) continue;
5333
5334 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5335 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5336 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5337
5338 if (num_check == max_check) break;
5339
5340 num_check++;
5341 }
5342
5343 myfree (line_buf);
5344
5345 uint hashlist_format = HLFMT_HASHCAT;
5346
5347 for (int i = 1; i < HLFMTS_CNT; i++)
5348 {
5349 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5350
5351 hashlist_format = i;
5352 }
5353
5354 free (formats_cnt);
5355
5356 return hashlist_format;
5357 }
5358
5359 /**
5360 * some further helper function
5361 */
5362
5363 // wrapper around mymalloc for ADL
5364
5365 #if defined(HAVE_HWMON)
5366 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5367 {
5368 return mymalloc (iSize);
5369 }
5370 #endif
5371
5372 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const u64 collisions_max)
5373 {
5374 u64 collisions = 0;
5375
5376 const uint dgst_pos0 = data.dgst_pos0;
5377 const uint dgst_pos1 = data.dgst_pos1;
5378 const uint dgst_pos2 = data.dgst_pos2;
5379 const uint dgst_pos3 = data.dgst_pos3;
5380
5381 memset (bitmap_a, 0, bitmap_size);
5382 memset (bitmap_b, 0, bitmap_size);
5383 memset (bitmap_c, 0, bitmap_size);
5384 memset (bitmap_d, 0, bitmap_size);
5385
5386 for (uint i = 0; i < digests_cnt; i++)
5387 {
5388 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5389
5390 uint *digest_ptr = (uint *) digests_buf_ptr;
5391
5392 digests_buf_ptr += dgst_size;
5393
5394 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5395 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5396 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5397 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5398
5399 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5400 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5401 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5402 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5403
5404 if (bitmap_a[idx0] & val0) collisions++;
5405 if (bitmap_b[idx1] & val1) collisions++;
5406 if (bitmap_c[idx2] & val2) collisions++;
5407 if (bitmap_d[idx3] & val3) collisions++;
5408
5409 bitmap_a[idx0] |= val0;
5410 bitmap_b[idx1] |= val1;
5411 bitmap_c[idx2] |= val2;
5412 bitmap_d[idx3] |= val3;
5413
5414 if (collisions >= collisions_max) return 0x7fffffff;
5415 }
5416
5417 return collisions;
5418 }
5419
5420 /**
5421 * main
5422 */
5423
5424 #ifdef _WIN
5425 void SetConsoleWindowSize (const int x)
5426 {
5427 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5428
5429 if (h == INVALID_HANDLE_VALUE) return;
5430
5431 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5432
5433 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5434
5435 SMALL_RECT *sr = &bufferInfo.srWindow;
5436
5437 sr->Right = MAX (sr->Right, x - 1);
5438
5439 COORD co;
5440
5441 co.X = sr->Right + 1;
5442 co.Y = sr->Bottom + 1;
5443
5444 if (!SetConsoleScreenBufferSize (h, co)) return;
5445
5446 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5447 }
5448 #endif
5449
5450 int main (int argc, char **argv)
5451 {
5452 #ifdef _WIN
5453 SetConsoleWindowSize (132);
5454 #endif
5455
5456 /**
5457 * To help users a bit
5458 */
5459
5460 char *compute = getenv ("COMPUTE");
5461
5462 if (compute)
5463 {
5464 static char display[100];
5465
5466 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5467
5468 putenv (display);
5469 }
5470 else
5471 {
5472 if (getenv ("DISPLAY") == NULL)
5473 putenv ((char *) "DISPLAY=:0");
5474 }
5475
5476 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5477 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5478
5479 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5480 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5481
5482 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5483 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5484
5485 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5486 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5487
5488 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5489 putenv ((char *) "POCL_KERNEL_CACHE=0");
5490
5491 umask (077);
5492
5493 /**
5494 * Real init
5495 */
5496
5497 memset (&data, 0, sizeof (hc_global_data_t));
5498
5499 time_t proc_start;
5500
5501 time (&proc_start);
5502
5503 data.proc_start = proc_start;
5504
5505 int myargc = argc;
5506 char **myargv = argv;
5507
5508 hc_thread_mutex_init (mux_dispatcher);
5509 hc_thread_mutex_init (mux_counter);
5510 hc_thread_mutex_init (mux_display);
5511 hc_thread_mutex_init (mux_adl);
5512
5513 /**
5514 * commandline parameters
5515 */
5516
5517 uint usage = USAGE;
5518 uint version = VERSION;
5519 uint quiet = QUIET;
5520 uint benchmark = BENCHMARK;
5521 uint show = SHOW;
5522 uint left = LEFT;
5523 uint username = USERNAME;
5524 uint remove = REMOVE;
5525 uint remove_timer = REMOVE_TIMER;
5526 u64 skip = SKIP;
5527 u64 limit = LIMIT;
5528 uint keyspace = KEYSPACE;
5529 uint potfile_disable = POTFILE_DISABLE;
5530 char *potfile_path = NULL;
5531 uint debug_mode = DEBUG_MODE;
5532 char *debug_file = NULL;
5533 char *induction_dir = NULL;
5534 char *outfile_check_dir = NULL;
5535 uint force = FORCE;
5536 uint runtime = RUNTIME;
5537 uint hash_mode = HASH_MODE;
5538 uint attack_mode = ATTACK_MODE;
5539 uint markov_disable = MARKOV_DISABLE;
5540 uint markov_classic = MARKOV_CLASSIC;
5541 uint markov_threshold = MARKOV_THRESHOLD;
5542 char *markov_hcstat = NULL;
5543 char *outfile = NULL;
5544 uint outfile_format = OUTFILE_FORMAT;
5545 uint outfile_autohex = OUTFILE_AUTOHEX;
5546 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5547 uint restore = RESTORE;
5548 uint restore_timer = RESTORE_TIMER;
5549 uint restore_disable = RESTORE_DISABLE;
5550 uint status = STATUS;
5551 uint status_timer = STATUS_TIMER;
5552 uint machine_readable = MACHINE_READABLE;
5553 uint loopback = LOOPBACK;
5554 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5555 char *session = NULL;
5556 uint hex_charset = HEX_CHARSET;
5557 uint hex_salt = HEX_SALT;
5558 uint hex_wordlist = HEX_WORDLIST;
5559 uint rp_gen = RP_GEN;
5560 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5561 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5562 uint rp_gen_seed = RP_GEN_SEED;
5563 char *rule_buf_l = (char *) RULE_BUF_L;
5564 char *rule_buf_r = (char *) RULE_BUF_R;
5565 uint increment = INCREMENT;
5566 uint increment_min = INCREMENT_MIN;
5567 uint increment_max = INCREMENT_MAX;
5568 char *cpu_affinity = NULL;
5569 OCL_PTR *ocl = NULL;
5570 char *opencl_devices = NULL;
5571 char *opencl_platforms = NULL;
5572 char *opencl_device_types = NULL;
5573 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5574 char *truecrypt_keyfiles = NULL;
5575 char *veracrypt_keyfiles = NULL;
5576 uint veracrypt_pim = 0;
5577 uint workload_profile = WORKLOAD_PROFILE;
5578 uint kernel_accel = KERNEL_ACCEL;
5579 uint kernel_loops = KERNEL_LOOPS;
5580 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5581 #ifdef HAVE_HWMON
5582 uint gpu_temp_abort = GPU_TEMP_ABORT;
5583 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5584 uint powertune_enable = POWERTUNE_ENABLE;
5585 #endif
5586 uint logfile_disable = LOGFILE_DISABLE;
5587 uint segment_size = SEGMENT_SIZE;
5588 uint scrypt_tmto = SCRYPT_TMTO;
5589 char separator = SEPARATOR;
5590 uint bitmap_min = BITMAP_MIN;
5591 uint bitmap_max = BITMAP_MAX;
5592 char *custom_charset_1 = NULL;
5593 char *custom_charset_2 = NULL;
5594 char *custom_charset_3 = NULL;
5595 char *custom_charset_4 = NULL;
5596
5597 #define IDX_HELP 'h'
5598 #define IDX_VERSION 'V'
5599 #define IDX_VERSION_LOWER 'v'
5600 #define IDX_QUIET 0xff02
5601 #define IDX_SHOW 0xff03
5602 #define IDX_LEFT 0xff04
5603 #define IDX_REMOVE 0xff05
5604 #define IDX_REMOVE_TIMER 0xff37
5605 #define IDX_SKIP 's'
5606 #define IDX_LIMIT 'l'
5607 #define IDX_KEYSPACE 0xff35
5608 #define IDX_POTFILE_DISABLE 0xff06
5609 #define IDX_POTFILE_PATH 0xffe0
5610 #define IDX_DEBUG_MODE 0xff43
5611 #define IDX_DEBUG_FILE 0xff44
5612 #define IDX_INDUCTION_DIR 0xff46
5613 #define IDX_OUTFILE_CHECK_DIR 0xff47
5614 #define IDX_USERNAME 0xff07
5615 #define IDX_FORCE 0xff08
5616 #define IDX_RUNTIME 0xff09
5617 #define IDX_BENCHMARK 'b'
5618 #define IDX_HASH_MODE 'm'
5619 #define IDX_ATTACK_MODE 'a'
5620 #define IDX_RP_FILE 'r'
5621 #define IDX_RP_GEN 'g'
5622 #define IDX_RP_GEN_FUNC_MIN 0xff10
5623 #define IDX_RP_GEN_FUNC_MAX 0xff11
5624 #define IDX_RP_GEN_SEED 0xff34
5625 #define IDX_RULE_BUF_L 'j'
5626 #define IDX_RULE_BUF_R 'k'
5627 #define IDX_INCREMENT 'i'
5628 #define IDX_INCREMENT_MIN 0xff12
5629 #define IDX_INCREMENT_MAX 0xff13
5630 #define IDX_OUTFILE 'o'
5631 #define IDX_OUTFILE_FORMAT 0xff14
5632 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5633 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5634 #define IDX_RESTORE 0xff15
5635 #define IDX_RESTORE_DISABLE 0xff27
5636 #define IDX_STATUS 0xff17
5637 #define IDX_STATUS_TIMER 0xff18
5638 #define IDX_MACHINE_READABLE 0xff50
5639 #define IDX_LOOPBACK 0xff38
5640 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5641 #define IDX_SESSION 0xff19
5642 #define IDX_HEX_CHARSET 0xff20
5643 #define IDX_HEX_SALT 0xff21
5644 #define IDX_HEX_WORDLIST 0xff40
5645 #define IDX_MARKOV_DISABLE 0xff22
5646 #define IDX_MARKOV_CLASSIC 0xff23
5647 #define IDX_MARKOV_THRESHOLD 't'
5648 #define IDX_MARKOV_HCSTAT 0xff24
5649 #define IDX_CPU_AFFINITY 0xff25
5650 #define IDX_OPENCL_DEVICES 'd'
5651 #define IDX_OPENCL_PLATFORMS 0xff72
5652 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5653 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5654 #define IDX_WORKLOAD_PROFILE 'w'
5655 #define IDX_KERNEL_ACCEL 'n'
5656 #define IDX_KERNEL_LOOPS 'u'
5657 #define IDX_GPU_TEMP_DISABLE 0xff29
5658 #define IDX_GPU_TEMP_ABORT 0xff30
5659 #define IDX_GPU_TEMP_RETAIN 0xff31
5660 #define IDX_POWERTUNE_ENABLE 0xff41
5661 #define IDX_LOGFILE_DISABLE 0xff51
5662 #define IDX_TRUECRYPT_KEYFILES 0xff52
5663 #define IDX_VERACRYPT_KEYFILES 0xff53
5664 #define IDX_VERACRYPT_PIM 0xff54
5665 #define IDX_SCRYPT_TMTO 0xff61
5666 #define IDX_SEGMENT_SIZE 'c'
5667 #define IDX_SEPARATOR 'p'
5668 #define IDX_BITMAP_MIN 0xff70
5669 #define IDX_BITMAP_MAX 0xff71
5670 #define IDX_CUSTOM_CHARSET_1 '1'
5671 #define IDX_CUSTOM_CHARSET_2 '2'
5672 #define IDX_CUSTOM_CHARSET_3 '3'
5673 #define IDX_CUSTOM_CHARSET_4 '4'
5674
5675 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5676
5677 struct option long_options[] =
5678 {
5679 {"help", no_argument, 0, IDX_HELP},
5680 {"version", no_argument, 0, IDX_VERSION},
5681 {"quiet", no_argument, 0, IDX_QUIET},
5682 {"show", no_argument, 0, IDX_SHOW},
5683 {"left", no_argument, 0, IDX_LEFT},
5684 {"username", no_argument, 0, IDX_USERNAME},
5685 {"remove", no_argument, 0, IDX_REMOVE},
5686 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5687 {"skip", required_argument, 0, IDX_SKIP},
5688 {"limit", required_argument, 0, IDX_LIMIT},
5689 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5690 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5691 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5692 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5693 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5694 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5695 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5696 {"force", no_argument, 0, IDX_FORCE},
5697 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5698 {"restore", no_argument, 0, IDX_RESTORE},
5699 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5700 {"status", no_argument, 0, IDX_STATUS},
5701 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5702 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5703 {"loopback", no_argument, 0, IDX_LOOPBACK},
5704 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5705 {"session", required_argument, 0, IDX_SESSION},
5706 {"runtime", required_argument, 0, IDX_RUNTIME},
5707 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5708 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5709 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5710 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5711 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5712 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5713 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5714 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5715 {"rules-file", required_argument, 0, IDX_RP_FILE},
5716 {"outfile", required_argument, 0, IDX_OUTFILE},
5717 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5718 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5719 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5720 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5721 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5722 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5723 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5724 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5725 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5726 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5727 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5728 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5729 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5730 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5731 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5732 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5733 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5734 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5735 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5736 #ifdef HAVE_HWMON
5737 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5738 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5739 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5740 #endif // HAVE_HWMON
5741 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5742 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5743 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5744 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5745 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5746 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5747 {"seperator", required_argument, 0, IDX_SEPARATOR},
5748 {"separator", required_argument, 0, IDX_SEPARATOR},
5749 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5750 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5751 {"increment", no_argument, 0, IDX_INCREMENT},
5752 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5753 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5754 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5755 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5756 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5757 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5758 {0, 0, 0, 0}
5759 };
5760
5761 uint rp_files_cnt = 0;
5762
5763 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5764
5765 int option_index = 0;
5766 int c = -1;
5767
5768 optind = 1;
5769 optopt = 0;
5770
5771 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5772 {
5773 switch (c)
5774 {
5775 case IDX_HELP: usage = 1; break;
5776 case IDX_VERSION:
5777 case IDX_VERSION_LOWER: version = 1; break;
5778 case IDX_RESTORE: restore = 1; break;
5779 case IDX_SESSION: session = optarg; break;
5780 case IDX_SHOW: show = 1; break;
5781 case IDX_LEFT: left = 1; break;
5782 case '?': return (-1);
5783 }
5784 }
5785
5786 if (optopt != 0)
5787 {
5788 log_error ("ERROR: Invalid argument specified");
5789
5790 return (-1);
5791 }
5792
5793 /**
5794 * exit functions
5795 */
5796
5797 if (version)
5798 {
5799 log_info ("%s", VERSION_TAG);
5800
5801 return (0);
5802 }
5803
5804 if (usage)
5805 {
5806 usage_big_print (PROGNAME);
5807
5808 return (0);
5809 }
5810
5811 /**
5812 * session needs to be set, always!
5813 */
5814
5815 if (session == NULL) session = (char *) PROGNAME;
5816
5817 /**
5818 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5819 */
5820
5821 char *exec_path = get_exec_path ();
5822
5823 #ifdef LINUX
5824
5825 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5826 char *resolved_exec_path = realpath (exec_path, NULL);
5827
5828 char *install_dir = get_install_dir (resolved_exec_path);
5829 char *profile_dir = NULL;
5830 char *session_dir = NULL;
5831 char *shared_dir = NULL;
5832
5833 if (strcmp (install_dir, resolved_install_folder) == 0)
5834 {
5835 struct passwd *pw = getpwuid (getuid ());
5836
5837 const char *homedir = pw->pw_dir;
5838
5839 profile_dir = get_profile_dir (homedir);
5840 session_dir = get_session_dir (profile_dir);
5841 shared_dir = strdup (SHARED_FOLDER);
5842
5843 mkdir (profile_dir, 0700);
5844 mkdir (session_dir, 0700);
5845 }
5846 else
5847 {
5848 profile_dir = install_dir;
5849 session_dir = install_dir;
5850 shared_dir = install_dir;
5851 }
5852
5853 myfree (resolved_install_folder);
5854 myfree (resolved_exec_path);
5855
5856 #else
5857
5858 char *install_dir = get_install_dir (exec_path);
5859 char *profile_dir = install_dir;
5860 char *session_dir = install_dir;
5861 char *shared_dir = install_dir;
5862
5863 #endif
5864
5865 data.install_dir = install_dir;
5866 data.profile_dir = profile_dir;
5867 data.session_dir = session_dir;
5868 data.shared_dir = shared_dir;
5869
5870 myfree (exec_path);
5871
5872 /**
5873 * kernel cache, we need to make sure folder exist
5874 */
5875
5876 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5877
5878 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5879
5880 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5881
5882 mkdir (kernels_folder, 0700);
5883
5884 myfree (kernels_folder);
5885
5886 /**
5887 * session
5888 */
5889
5890 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5891
5892 data.session = session;
5893
5894 char *eff_restore_file = (char *) mymalloc (session_size);
5895 char *new_restore_file = (char *) mymalloc (session_size);
5896
5897 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5898 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5899
5900 data.eff_restore_file = eff_restore_file;
5901 data.new_restore_file = new_restore_file;
5902
5903 if (((show == 1) || (left == 1)) && (restore == 1))
5904 {
5905 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5906 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5907
5908 return (-1);
5909 }
5910
5911 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5912 if ((show == 1) || (left == 1))
5913 {
5914 restore_disable = 1;
5915
5916 restore = 0;
5917 }
5918
5919 data.restore_disable = restore_disable;
5920
5921 restore_data_t *rd = init_restore (argc, argv);
5922
5923 data.rd = rd;
5924
5925 /**
5926 * restore file
5927 */
5928
5929 if (restore == 1)
5930 {
5931 read_restore (eff_restore_file, rd);
5932
5933 if (rd->version_bin < RESTORE_MIN)
5934 {
5935 log_error ("ERROR: Incompatible restore-file version");
5936
5937 return (-1);
5938 }
5939
5940 myargc = rd->argc;
5941 myargv = rd->argv;
5942
5943 #ifdef _POSIX
5944 rd->pid = getpid ();
5945 #elif _WIN
5946 rd->pid = GetCurrentProcessId ();
5947 #endif
5948 }
5949
5950 uint hash_mode_chgd = 0;
5951 uint runtime_chgd = 0;
5952 uint kernel_loops_chgd = 0;
5953 uint kernel_accel_chgd = 0;
5954 uint attack_mode_chgd = 0;
5955 uint outfile_format_chgd = 0;
5956 uint rp_gen_seed_chgd = 0;
5957 uint remove_timer_chgd = 0;
5958 uint increment_min_chgd = 0;
5959 uint increment_max_chgd = 0;
5960 uint workload_profile_chgd = 0;
5961 uint opencl_vector_width_chgd = 0;
5962
5963 optind = 1;
5964 optopt = 0;
5965 option_index = 0;
5966
5967 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5968 {
5969 switch (c)
5970 {
5971 //case IDX_HELP: usage = 1; break;
5972 //case IDX_VERSION: version = 1; break;
5973 //case IDX_RESTORE: restore = 1; break;
5974 case IDX_QUIET: quiet = 1; break;
5975 //case IDX_SHOW: show = 1; break;
5976 case IDX_SHOW: break;
5977 //case IDX_LEFT: left = 1; break;
5978 case IDX_LEFT: break;
5979 case IDX_USERNAME: username = 1; break;
5980 case IDX_REMOVE: remove = 1; break;
5981 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5982 remove_timer_chgd = 1; break;
5983 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5984 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5985 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5986 case IDX_DEBUG_FILE: debug_file = optarg; break;
5987 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5988 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5989 case IDX_FORCE: force = 1; break;
5990 case IDX_SKIP: skip = atoll (optarg); break;
5991 case IDX_LIMIT: limit = atoll (optarg); break;
5992 case IDX_KEYSPACE: keyspace = 1; break;
5993 case IDX_BENCHMARK: benchmark = 1; break;
5994 case IDX_RESTORE: break;
5995 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5996 case IDX_STATUS: status = 1; break;
5997 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5998 case IDX_MACHINE_READABLE: machine_readable = 1; break;
5999 case IDX_LOOPBACK: loopback = 1; break;
6000 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6001 //case IDX_SESSION: session = optarg; break;
6002 case IDX_SESSION: break;
6003 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6004 hash_mode_chgd = 1; break;
6005 case IDX_RUNTIME: runtime = atoi (optarg);
6006 runtime_chgd = 1; break;
6007 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6008 attack_mode_chgd = 1; break;
6009 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6010 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6011 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6012 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6013 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6014 rp_gen_seed_chgd = 1; break;
6015 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6016 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6017 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6018 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6019 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6020 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6021 case IDX_OUTFILE: outfile = optarg; break;
6022 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6023 outfile_format_chgd = 1; break;
6024 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6025 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6026 case IDX_HEX_CHARSET: hex_charset = 1; break;
6027 case IDX_HEX_SALT: hex_salt = 1; break;
6028 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6029 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6030 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6031 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6032 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6033 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6034 opencl_vector_width_chgd = 1; break;
6035 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6036 workload_profile_chgd = 1; break;
6037 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6038 kernel_accel_chgd = 1; break;
6039 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6040 kernel_loops_chgd = 1; break;
6041 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6042 #ifdef HAVE_HWMON
6043 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6044 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6045 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6046 #endif // HAVE_HWMON
6047 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6048 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6049 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6050 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6051 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6052 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6053 case IDX_SEPARATOR: separator = optarg[0]; break;
6054 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6055 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6056 case IDX_INCREMENT: increment = 1; break;
6057 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6058 increment_min_chgd = 1; break;
6059 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6060 increment_max_chgd = 1; break;
6061 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6062 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6063 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6064 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6065
6066 default:
6067 log_error ("ERROR: Invalid argument specified");
6068 return (-1);
6069 }
6070 }
6071
6072 if (optopt != 0)
6073 {
6074 log_error ("ERROR: Invalid argument specified");
6075
6076 return (-1);
6077 }
6078
6079 /**
6080 * Inform user things getting started,
6081 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6082 * - we do not need to check algorithm_pos
6083 */
6084
6085 if (quiet == 0)
6086 {
6087 if (benchmark == 1)
6088 {
6089 if (machine_readable == 0)
6090 {
6091 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6092 log_info ("");
6093 }
6094 else
6095 {
6096 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6097 }
6098 }
6099 else if (restore == 1)
6100 {
6101 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6102 log_info ("");
6103 }
6104 else
6105 {
6106 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6107 log_info ("");
6108 }
6109 }
6110
6111 /**
6112 * sanity check
6113 */
6114
6115 if (attack_mode > 7)
6116 {
6117 log_error ("ERROR: Invalid attack-mode specified");
6118
6119 return (-1);
6120 }
6121
6122 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6123 {
6124 log_error ("ERROR: Invalid runtime specified");
6125
6126 return (-1);
6127 }
6128
6129 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
6130 {
6131 log_error ("ERROR: Invalid hash-type specified");
6132
6133 return (-1);
6134 }
6135
6136 // renamed hash modes
6137
6138 if (hash_mode_chgd)
6139 {
6140 int n = -1;
6141
6142 switch (hash_mode)
6143 {
6144 case 123: n = 124;
6145 break;
6146 }
6147
6148 if (n >= 0)
6149 {
6150 log_error ("Old -m specified, use -m %d instead", n);
6151
6152 return (-1);
6153 }
6154 }
6155
6156 if (username == 1)
6157 {
6158 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6159 {
6160 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6161
6162 return (-1);
6163 }
6164 }
6165
6166 if (outfile_format > 16)
6167 {
6168 log_error ("ERROR: Invalid outfile-format specified");
6169
6170 return (-1);
6171 }
6172
6173 if (left == 1)
6174 {
6175 if (outfile_format_chgd == 1)
6176 {
6177 if (outfile_format > 1)
6178 {
6179 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6180
6181 return (-1);
6182 }
6183 }
6184 else
6185 {
6186 outfile_format = OUTFILE_FMT_HASH;
6187 }
6188 }
6189
6190 if (show == 1)
6191 {
6192 if (outfile_format_chgd == 1)
6193 {
6194 if ((outfile_format > 7) && (outfile_format < 16))
6195 {
6196 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6197
6198 return (-1);
6199 }
6200 }
6201 }
6202
6203 if (increment_min < INCREMENT_MIN)
6204 {
6205 log_error ("ERROR: Invalid increment-min specified");
6206
6207 return (-1);
6208 }
6209
6210 if (increment_max > INCREMENT_MAX)
6211 {
6212 log_error ("ERROR: Invalid increment-max specified");
6213
6214 return (-1);
6215 }
6216
6217 if (increment_min > increment_max)
6218 {
6219 log_error ("ERROR: Invalid increment-min specified");
6220
6221 return (-1);
6222 }
6223
6224 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6225 {
6226 log_error ("ERROR: increment is not allowed in attack-mode 0");
6227
6228 return (-1);
6229 }
6230
6231 if ((increment == 0) && (increment_min_chgd == 1))
6232 {
6233 log_error ("ERROR: increment-min is only supported together with increment switch");
6234
6235 return (-1);
6236 }
6237
6238 if ((increment == 0) && (increment_max_chgd == 1))
6239 {
6240 log_error ("ERROR: increment-max is only supported together with increment switch");
6241
6242 return (-1);
6243 }
6244
6245 if (rp_files_cnt && rp_gen)
6246 {
6247 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6248
6249 return (-1);
6250 }
6251
6252 if (rp_files_cnt || rp_gen)
6253 {
6254 if (attack_mode != ATTACK_MODE_STRAIGHT)
6255 {
6256 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6257
6258 return (-1);
6259 }
6260 }
6261
6262 if (rp_gen_func_min > rp_gen_func_max)
6263 {
6264 log_error ("ERROR: Invalid rp-gen-func-min specified");
6265
6266 return (-1);
6267 }
6268
6269 if (kernel_accel_chgd == 1)
6270 {
6271 if (force == 0)
6272 {
6273 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6274 log_info ("Please consider using the option -w instead");
6275 log_info ("You can use --force to override this but do not post error reports if you do so");
6276 log_info ("");
6277
6278 return (-1);
6279 }
6280
6281 if (kernel_accel < 1)
6282 {
6283 log_error ("ERROR: Invalid kernel-accel specified");
6284
6285 return (-1);
6286 }
6287
6288 if (kernel_accel > 1024)
6289 {
6290 log_error ("ERROR: Invalid kernel-accel specified");
6291
6292 return (-1);
6293 }
6294 }
6295
6296 if (kernel_loops_chgd == 1)
6297 {
6298 if (force == 0)
6299 {
6300 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6301 log_info ("Please consider using the option -w instead");
6302 log_info ("You can use --force to override this but do not post error reports if you do so");
6303 log_info ("");
6304
6305 return (-1);
6306 }
6307
6308 if (kernel_loops < 1)
6309 {
6310 log_error ("ERROR: Invalid kernel-loops specified");
6311
6312 return (-1);
6313 }
6314
6315 if (kernel_loops > 1024)
6316 {
6317 log_error ("ERROR: Invalid kernel-loops specified");
6318
6319 return (-1);
6320 }
6321 }
6322
6323 if ((workload_profile < 1) || (workload_profile > 4))
6324 {
6325 log_error ("ERROR: workload-profile %i not available", workload_profile);
6326
6327 return (-1);
6328 }
6329
6330 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6331 {
6332 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6333
6334 return (-1);
6335 }
6336
6337 if (show == 1 || left == 1)
6338 {
6339 attack_mode = ATTACK_MODE_NONE;
6340
6341 if (remove == 1)
6342 {
6343 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6344
6345 return (-1);
6346 }
6347
6348 if (potfile_disable == 1)
6349 {
6350 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6351
6352 return (-1);
6353 }
6354 }
6355
6356 uint attack_kern = ATTACK_KERN_NONE;
6357
6358 switch (attack_mode)
6359 {
6360 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6361 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6362 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6363 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6364 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6365 }
6366
6367 if (benchmark == 0)
6368 {
6369 if (keyspace == 1)
6370 {
6371 int num_additional_params = 1;
6372
6373 if (attack_kern == ATTACK_KERN_COMBI)
6374 {
6375 num_additional_params = 2;
6376 }
6377
6378 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6379
6380 if (keyspace_wordlist_specified == 0) optind--;
6381 }
6382
6383 if (attack_kern == ATTACK_KERN_NONE)
6384 {
6385 if ((optind + 1) != myargc)
6386 {
6387 usage_mini_print (myargv[0]);
6388
6389 return (-1);
6390 }
6391 }
6392 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6393 {
6394 if ((optind + 1) > myargc)
6395 {
6396 usage_mini_print (myargv[0]);
6397
6398 return (-1);
6399 }
6400 }
6401 else if (attack_kern == ATTACK_KERN_COMBI)
6402 {
6403 if ((optind + 3) != myargc)
6404 {
6405 usage_mini_print (myargv[0]);
6406
6407 return (-1);
6408 }
6409 }
6410 else if (attack_kern == ATTACK_KERN_BF)
6411 {
6412 if ((optind + 1) > myargc)
6413 {
6414 usage_mini_print (myargv[0]);
6415
6416 return (-1);
6417 }
6418 }
6419 else
6420 {
6421 usage_mini_print (myargv[0]);
6422
6423 return (-1);
6424 }
6425 }
6426 else
6427 {
6428 if (myargv[optind] != 0)
6429 {
6430 log_error ("ERROR: Invalid argument for benchmark mode specified");
6431
6432 return (-1);
6433 }
6434
6435 if (attack_mode_chgd == 1)
6436 {
6437 if (attack_mode != ATTACK_MODE_BF)
6438 {
6439 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6440
6441 return (-1);
6442 }
6443 }
6444 }
6445
6446 if (skip != 0 && limit != 0)
6447 {
6448 limit += skip;
6449 }
6450
6451 if (keyspace == 1)
6452 {
6453 if (show == 1)
6454 {
6455 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6456
6457 return (-1);
6458 }
6459 else if (left == 1)
6460 {
6461 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6462
6463 return (-1);
6464 }
6465
6466 potfile_disable = 1;
6467
6468 restore_disable = 1;
6469
6470 restore = 0;
6471
6472 weak_hash_threshold = 0;
6473
6474 quiet = 1;
6475 }
6476
6477 if (remove_timer_chgd == 1)
6478 {
6479 if (remove == 0)
6480 {
6481 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6482
6483 return (-1);
6484 }
6485
6486 if (remove_timer < 1)
6487 {
6488 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6489
6490 return (-1);
6491 }
6492 }
6493
6494 if (loopback == 1)
6495 {
6496 if (attack_mode == ATTACK_MODE_STRAIGHT)
6497 {
6498 if ((rp_files_cnt == 0) && (rp_gen == 0))
6499 {
6500 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6501
6502 return (-1);
6503 }
6504 }
6505 else
6506 {
6507 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6508
6509 return (-1);
6510 }
6511 }
6512
6513 if (debug_mode > 0)
6514 {
6515 if (attack_mode != ATTACK_MODE_STRAIGHT)
6516 {
6517 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6518
6519 return (-1);
6520 }
6521
6522 if ((rp_files_cnt == 0) && (rp_gen == 0))
6523 {
6524 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6525
6526 return (-1);
6527 }
6528 }
6529
6530 if (debug_mode > 4)
6531 {
6532 log_error ("ERROR: Invalid debug-mode specified");
6533
6534 return (-1);
6535 }
6536
6537 if (debug_file != NULL)
6538 {
6539 if (debug_mode < 1)
6540 {
6541 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6542
6543 return (-1);
6544 }
6545 }
6546
6547 if (induction_dir != NULL)
6548 {
6549 if (attack_mode == ATTACK_MODE_BF)
6550 {
6551 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6552
6553 return (-1);
6554 }
6555 }
6556
6557 if (attack_mode != ATTACK_MODE_STRAIGHT)
6558 {
6559 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6560 {
6561 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6562
6563 return (-1);
6564 }
6565
6566 weak_hash_threshold = 0;
6567 }
6568
6569 /**
6570 * induction directory
6571 */
6572
6573 char *induction_directory = NULL;
6574
6575 if (attack_mode != ATTACK_MODE_BF)
6576 {
6577 if (induction_dir == NULL)
6578 {
6579 induction_directory = (char *) mymalloc (session_size);
6580
6581 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6582
6583 // create induction folder if it does not already exist
6584
6585 if (keyspace == 0)
6586 {
6587 if (rmdir (induction_directory) == -1)
6588 {
6589 if (errno == ENOENT)
6590 {
6591 // good, we can ignore
6592 }
6593 else if (errno == ENOTEMPTY)
6594 {
6595 char *induction_directory_mv = (char *) mymalloc (session_size);
6596
6597 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6598
6599 if (rename (induction_directory, induction_directory_mv) != 0)
6600 {
6601 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6602
6603 return (-1);
6604 }
6605 }
6606 else
6607 {
6608 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6609
6610 return (-1);
6611 }
6612 }
6613
6614 if (mkdir (induction_directory, 0700) == -1)
6615 {
6616 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6617
6618 return (-1);
6619 }
6620 }
6621 }
6622 else
6623 {
6624 induction_directory = induction_dir;
6625 }
6626 }
6627
6628 data.induction_directory = induction_directory;
6629
6630 /**
6631 * loopback
6632 */
6633
6634 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6635
6636 char *loopback_file = (char *) mymalloc (loopback_size);
6637
6638 /**
6639 * tuning db
6640 */
6641
6642 char tuning_db_file[256] = { 0 };
6643
6644 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6645
6646 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6647
6648 /**
6649 * outfile-check directory
6650 */
6651
6652 char *outfile_check_directory = NULL;
6653
6654 if (outfile_check_dir == NULL)
6655 {
6656 outfile_check_directory = (char *) mymalloc (session_size);
6657
6658 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6659 }
6660 else
6661 {
6662 outfile_check_directory = outfile_check_dir;
6663 }
6664
6665 data.outfile_check_directory = outfile_check_directory;
6666
6667 if (keyspace == 0)
6668 {
6669 struct stat outfile_check_stat;
6670
6671 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6672 {
6673 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6674
6675 if (is_dir == 0)
6676 {
6677 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6678
6679 return (-1);
6680 }
6681 }
6682 else if (outfile_check_dir == NULL)
6683 {
6684 if (mkdir (outfile_check_directory, 0700) == -1)
6685 {
6686 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6687
6688 return (-1);
6689 }
6690 }
6691 }
6692
6693 /**
6694 * special other stuff
6695 */
6696
6697 if (hash_mode == 9710)
6698 {
6699 outfile_format = 5;
6700 outfile_format_chgd = 1;
6701 }
6702
6703 if (hash_mode == 9810)
6704 {
6705 outfile_format = 5;
6706 outfile_format_chgd = 1;
6707 }
6708
6709 if (hash_mode == 10410)
6710 {
6711 outfile_format = 5;
6712 outfile_format_chgd = 1;
6713 }
6714
6715 /**
6716 * store stuff
6717 */
6718
6719 data.hash_mode = hash_mode;
6720 data.restore = restore;
6721 data.restore_timer = restore_timer;
6722 data.restore_disable = restore_disable;
6723 data.status = status;
6724 data.status_timer = status_timer;
6725 data.machine_readable = machine_readable;
6726 data.loopback = loopback;
6727 data.runtime = runtime;
6728 data.remove = remove;
6729 data.remove_timer = remove_timer;
6730 data.debug_mode = debug_mode;
6731 data.debug_file = debug_file;
6732 data.username = username;
6733 data.quiet = quiet;
6734 data.outfile = outfile;
6735 data.outfile_format = outfile_format;
6736 data.outfile_autohex = outfile_autohex;
6737 data.hex_charset = hex_charset;
6738 data.hex_salt = hex_salt;
6739 data.hex_wordlist = hex_wordlist;
6740 data.separator = separator;
6741 data.rp_files = rp_files;
6742 data.rp_files_cnt = rp_files_cnt;
6743 data.rp_gen = rp_gen;
6744 data.rp_gen_seed = rp_gen_seed;
6745 data.force = force;
6746 data.benchmark = benchmark;
6747 data.skip = skip;
6748 data.limit = limit;
6749 #ifdef HAVE_HWMON
6750 data.powertune_enable = powertune_enable;
6751 #endif
6752 data.logfile_disable = logfile_disable;
6753 data.truecrypt_keyfiles = truecrypt_keyfiles;
6754 data.veracrypt_keyfiles = veracrypt_keyfiles;
6755 data.veracrypt_pim = veracrypt_pim;
6756 data.scrypt_tmto = scrypt_tmto;
6757 data.workload_profile = workload_profile;
6758
6759 /**
6760 * cpu affinity
6761 */
6762
6763 if (cpu_affinity)
6764 {
6765 set_cpu_affinity (cpu_affinity);
6766 }
6767
6768 if (rp_gen_seed_chgd == 0)
6769 {
6770 srand (proc_start);
6771 }
6772 else
6773 {
6774 srand (rp_gen_seed);
6775 }
6776
6777 /**
6778 * logfile init
6779 */
6780
6781 if (logfile_disable == 0)
6782 {
6783 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6784
6785 char *logfile = (char *) mymalloc (logfile_size);
6786
6787 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6788
6789 data.logfile = logfile;
6790
6791 char *topid = logfile_generate_topid ();
6792
6793 data.topid = topid;
6794 }
6795
6796 // logfile_append() checks for logfile_disable internally to make it easier from here
6797
6798 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6799 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6800 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6801 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6802 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6803 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6804 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6805 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6806 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6807 #define logfile_sub_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s\t%s", data.topid, data.subid, (var), (val));
6808
6809 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6810 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6811 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6812 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6813 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6814 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6815 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6816 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6817
6818 logfile_top_msg ("START");
6819
6820 logfile_top_uint (attack_mode);
6821 logfile_top_uint (attack_kern);
6822 logfile_top_uint (benchmark);
6823 logfile_top_uint (bitmap_min);
6824 logfile_top_uint (bitmap_max);
6825 logfile_top_uint (debug_mode);
6826 logfile_top_uint (force);
6827 logfile_top_uint (kernel_accel);
6828 logfile_top_uint (kernel_loops);
6829 logfile_top_uint (gpu_temp_disable);
6830 #ifdef HAVE_HWMON
6831 logfile_top_uint (gpu_temp_abort);
6832 logfile_top_uint (gpu_temp_retain);
6833 #endif
6834 logfile_top_uint (hash_mode);
6835 logfile_top_uint (hex_charset);
6836 logfile_top_uint (hex_salt);
6837 logfile_top_uint (hex_wordlist);
6838 logfile_top_uint (increment);
6839 logfile_top_uint (increment_max);
6840 logfile_top_uint (increment_min);
6841 logfile_top_uint (keyspace);
6842 logfile_top_uint (left);
6843 logfile_top_uint (logfile_disable);
6844 logfile_top_uint (loopback);
6845 logfile_top_uint (markov_classic);
6846 logfile_top_uint (markov_disable);
6847 logfile_top_uint (markov_threshold);
6848 logfile_top_uint (outfile_autohex);
6849 logfile_top_uint (outfile_check_timer);
6850 logfile_top_uint (outfile_format);
6851 logfile_top_uint (potfile_disable);
6852 logfile_top_string (potfile_path);
6853 #if defined(HAVE_HWMON)
6854 logfile_top_uint (powertune_enable);
6855 #endif
6856 logfile_top_uint (scrypt_tmto);
6857 logfile_top_uint (quiet);
6858 logfile_top_uint (remove);
6859 logfile_top_uint (remove_timer);
6860 logfile_top_uint (restore);
6861 logfile_top_uint (restore_disable);
6862 logfile_top_uint (restore_timer);
6863 logfile_top_uint (rp_gen);
6864 logfile_top_uint (rp_gen_func_max);
6865 logfile_top_uint (rp_gen_func_min);
6866 logfile_top_uint (rp_gen_seed);
6867 logfile_top_uint (runtime);
6868 logfile_top_uint (segment_size);
6869 logfile_top_uint (show);
6870 logfile_top_uint (status);
6871 logfile_top_uint (machine_readable);
6872 logfile_top_uint (status_timer);
6873 logfile_top_uint (usage);
6874 logfile_top_uint (username);
6875 logfile_top_uint (version);
6876 logfile_top_uint (weak_hash_threshold);
6877 logfile_top_uint (workload_profile);
6878 logfile_top_uint64 (limit);
6879 logfile_top_uint64 (skip);
6880 logfile_top_char (separator);
6881 logfile_top_string (cpu_affinity);
6882 logfile_top_string (custom_charset_1);
6883 logfile_top_string (custom_charset_2);
6884 logfile_top_string (custom_charset_3);
6885 logfile_top_string (custom_charset_4);
6886 logfile_top_string (debug_file);
6887 logfile_top_string (opencl_devices);
6888 logfile_top_string (opencl_platforms);
6889 logfile_top_string (opencl_device_types);
6890 logfile_top_uint (opencl_vector_width);
6891 logfile_top_string (induction_dir);
6892 logfile_top_string (markov_hcstat);
6893 logfile_top_string (outfile);
6894 logfile_top_string (outfile_check_dir);
6895 logfile_top_string (rule_buf_l);
6896 logfile_top_string (rule_buf_r);
6897 logfile_top_string (session);
6898 logfile_top_string (truecrypt_keyfiles);
6899 logfile_top_string (veracrypt_keyfiles);
6900 logfile_top_uint (veracrypt_pim);
6901
6902 /**
6903 * Init OpenCL library loader
6904 */
6905
6906 if (keyspace == 0)
6907 {
6908 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6909
6910 ocl_init (ocl);
6911
6912 data.ocl = ocl;
6913 }
6914
6915 /**
6916 * OpenCL platform selection
6917 */
6918
6919 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6920
6921 /**
6922 * OpenCL device selection
6923 */
6924
6925 u32 devices_filter = setup_devices_filter (opencl_devices);
6926
6927 /**
6928 * OpenCL device type selection
6929 */
6930
6931 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6932
6933 /**
6934 * benchmark
6935 */
6936
6937 if (benchmark == 1)
6938 {
6939 /**
6940 * disable useless stuff for benchmark
6941 */
6942
6943 status_timer = 0;
6944 restore_timer = 0;
6945 restore_disable = 1;
6946 potfile_disable = 1;
6947 weak_hash_threshold = 0;
6948 gpu_temp_disable = 1;
6949
6950 #ifdef HAVE_HWMON
6951 powertune_enable = 1;
6952 #endif
6953
6954 data.status_timer = status_timer;
6955 data.restore_timer = restore_timer;
6956 data.restore_disable = restore_disable;
6957
6958 /**
6959 * force attack mode to be bruteforce
6960 */
6961
6962 attack_mode = ATTACK_MODE_BF;
6963 attack_kern = ATTACK_KERN_BF;
6964
6965 if (workload_profile_chgd == 0)
6966 {
6967 workload_profile = 3;
6968
6969 data.workload_profile = workload_profile;
6970 }
6971 }
6972
6973 /**
6974 * config
6975 */
6976
6977 uint hash_type = 0;
6978 uint salt_type = 0;
6979 uint attack_exec = 0;
6980 uint opts_type = 0;
6981 uint kern_type = 0;
6982 uint dgst_size = 0;
6983 uint esalt_size = 0;
6984 uint opti_type = 0;
6985 uint dgst_pos0 = -1;
6986 uint dgst_pos1 = -1;
6987 uint dgst_pos2 = -1;
6988 uint dgst_pos3 = -1;
6989
6990 int (*parse_func) (char *, uint, hash_t *);
6991 int (*sort_by_digest) (const void *, const void *);
6992
6993 uint algorithm_pos = 0;
6994 uint algorithm_max = 1;
6995
6996 uint *algorithms = default_benchmark_algorithms;
6997
6998 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6999
7000 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7001 {
7002 /*
7003 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7004 * the following algos are skipped entirely
7005 */
7006
7007 if (algorithm_pos > 0)
7008 {
7009 local_free (rd);
7010
7011 rd = init_restore (argc, argv);
7012
7013 data.rd = rd;
7014 }
7015
7016 /**
7017 * update hash_mode in case of multihash benchmark
7018 */
7019
7020 if (benchmark == 1)
7021 {
7022 if (hash_mode_chgd == 0)
7023 {
7024 hash_mode = algorithms[algorithm_pos];
7025
7026 data.hash_mode = hash_mode;
7027 }
7028
7029 quiet = 1;
7030
7031 data.quiet = quiet;
7032 }
7033
7034 switch (hash_mode)
7035 {
7036 case 0: hash_type = HASH_TYPE_MD5;
7037 salt_type = SALT_TYPE_NONE;
7038 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7039 opts_type = OPTS_TYPE_PT_GENERATE_LE
7040 | OPTS_TYPE_PT_ADD80
7041 | OPTS_TYPE_PT_ADDBITS14;
7042 kern_type = KERN_TYPE_MD5;
7043 dgst_size = DGST_SIZE_4_4;
7044 parse_func = md5_parse_hash;
7045 sort_by_digest = sort_by_digest_4_4;
7046 opti_type = OPTI_TYPE_ZERO_BYTE
7047 | OPTI_TYPE_PRECOMPUTE_INIT
7048 | OPTI_TYPE_PRECOMPUTE_MERKLE
7049 | OPTI_TYPE_MEET_IN_MIDDLE
7050 | OPTI_TYPE_EARLY_SKIP
7051 | OPTI_TYPE_NOT_ITERATED
7052 | OPTI_TYPE_NOT_SALTED
7053 | OPTI_TYPE_RAW_HASH;
7054 dgst_pos0 = 0;
7055 dgst_pos1 = 3;
7056 dgst_pos2 = 2;
7057 dgst_pos3 = 1;
7058 break;
7059
7060 case 10: hash_type = HASH_TYPE_MD5;
7061 salt_type = SALT_TYPE_INTERN;
7062 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7063 opts_type = OPTS_TYPE_PT_GENERATE_LE
7064 | OPTS_TYPE_ST_ADD80
7065 | OPTS_TYPE_ST_ADDBITS14;
7066 kern_type = KERN_TYPE_MD5_PWSLT;
7067 dgst_size = DGST_SIZE_4_4;
7068 parse_func = md5s_parse_hash;
7069 sort_by_digest = sort_by_digest_4_4;
7070 opti_type = OPTI_TYPE_ZERO_BYTE
7071 | OPTI_TYPE_PRECOMPUTE_INIT
7072 | OPTI_TYPE_PRECOMPUTE_MERKLE
7073 | OPTI_TYPE_MEET_IN_MIDDLE
7074 | OPTI_TYPE_EARLY_SKIP
7075 | OPTI_TYPE_NOT_ITERATED
7076 | OPTI_TYPE_APPENDED_SALT
7077 | OPTI_TYPE_RAW_HASH;
7078 dgst_pos0 = 0;
7079 dgst_pos1 = 3;
7080 dgst_pos2 = 2;
7081 dgst_pos3 = 1;
7082 break;
7083
7084 case 11: hash_type = HASH_TYPE_MD5;
7085 salt_type = SALT_TYPE_INTERN;
7086 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7087 opts_type = OPTS_TYPE_PT_GENERATE_LE
7088 | OPTS_TYPE_ST_ADD80
7089 | OPTS_TYPE_ST_ADDBITS14;
7090 kern_type = KERN_TYPE_MD5_PWSLT;
7091 dgst_size = DGST_SIZE_4_4;
7092 parse_func = joomla_parse_hash;
7093 sort_by_digest = sort_by_digest_4_4;
7094 opti_type = OPTI_TYPE_ZERO_BYTE
7095 | OPTI_TYPE_PRECOMPUTE_INIT
7096 | OPTI_TYPE_PRECOMPUTE_MERKLE
7097 | OPTI_TYPE_MEET_IN_MIDDLE
7098 | OPTI_TYPE_EARLY_SKIP
7099 | OPTI_TYPE_NOT_ITERATED
7100 | OPTI_TYPE_APPENDED_SALT
7101 | OPTI_TYPE_RAW_HASH;
7102 dgst_pos0 = 0;
7103 dgst_pos1 = 3;
7104 dgst_pos2 = 2;
7105 dgst_pos3 = 1;
7106 break;
7107
7108 case 12: hash_type = HASH_TYPE_MD5;
7109 salt_type = SALT_TYPE_INTERN;
7110 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7111 opts_type = OPTS_TYPE_PT_GENERATE_LE
7112 | OPTS_TYPE_ST_ADD80
7113 | OPTS_TYPE_ST_ADDBITS14;
7114 kern_type = KERN_TYPE_MD5_PWSLT;
7115 dgst_size = DGST_SIZE_4_4;
7116 parse_func = postgresql_parse_hash;
7117 sort_by_digest = sort_by_digest_4_4;
7118 opti_type = OPTI_TYPE_ZERO_BYTE
7119 | OPTI_TYPE_PRECOMPUTE_INIT
7120 | OPTI_TYPE_PRECOMPUTE_MERKLE
7121 | OPTI_TYPE_MEET_IN_MIDDLE
7122 | OPTI_TYPE_EARLY_SKIP
7123 | OPTI_TYPE_NOT_ITERATED
7124 | OPTI_TYPE_APPENDED_SALT
7125 | OPTI_TYPE_RAW_HASH;
7126 dgst_pos0 = 0;
7127 dgst_pos1 = 3;
7128 dgst_pos2 = 2;
7129 dgst_pos3 = 1;
7130 break;
7131
7132 case 20: hash_type = HASH_TYPE_MD5;
7133 salt_type = SALT_TYPE_INTERN;
7134 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7135 opts_type = OPTS_TYPE_PT_GENERATE_LE
7136 | OPTS_TYPE_PT_ADD80
7137 | OPTS_TYPE_PT_ADDBITS14;
7138 kern_type = KERN_TYPE_MD5_SLTPW;
7139 dgst_size = DGST_SIZE_4_4;
7140 parse_func = md5s_parse_hash;
7141 sort_by_digest = sort_by_digest_4_4;
7142 opti_type = OPTI_TYPE_ZERO_BYTE
7143 | OPTI_TYPE_PRECOMPUTE_INIT
7144 | OPTI_TYPE_PRECOMPUTE_MERKLE
7145 | OPTI_TYPE_EARLY_SKIP
7146 | OPTI_TYPE_NOT_ITERATED
7147 | OPTI_TYPE_PREPENDED_SALT
7148 | OPTI_TYPE_RAW_HASH;
7149 dgst_pos0 = 0;
7150 dgst_pos1 = 3;
7151 dgst_pos2 = 2;
7152 dgst_pos3 = 1;
7153 break;
7154
7155 case 21: hash_type = HASH_TYPE_MD5;
7156 salt_type = SALT_TYPE_INTERN;
7157 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7158 opts_type = OPTS_TYPE_PT_GENERATE_LE
7159 | OPTS_TYPE_PT_ADD80
7160 | OPTS_TYPE_PT_ADDBITS14;
7161 kern_type = KERN_TYPE_MD5_SLTPW;
7162 dgst_size = DGST_SIZE_4_4;
7163 parse_func = osc_parse_hash;
7164 sort_by_digest = sort_by_digest_4_4;
7165 opti_type = OPTI_TYPE_ZERO_BYTE
7166 | OPTI_TYPE_PRECOMPUTE_INIT
7167 | OPTI_TYPE_PRECOMPUTE_MERKLE
7168 | OPTI_TYPE_EARLY_SKIP
7169 | OPTI_TYPE_NOT_ITERATED
7170 | OPTI_TYPE_PREPENDED_SALT
7171 | OPTI_TYPE_RAW_HASH;
7172 dgst_pos0 = 0;
7173 dgst_pos1 = 3;
7174 dgst_pos2 = 2;
7175 dgst_pos3 = 1;
7176 break;
7177
7178 case 22: hash_type = HASH_TYPE_MD5;
7179 salt_type = SALT_TYPE_EMBEDDED;
7180 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7181 opts_type = OPTS_TYPE_PT_GENERATE_LE
7182 | OPTS_TYPE_PT_ADD80
7183 | OPTS_TYPE_PT_ADDBITS14;
7184 kern_type = KERN_TYPE_MD5_SLTPW;
7185 dgst_size = DGST_SIZE_4_4;
7186 parse_func = netscreen_parse_hash;
7187 sort_by_digest = sort_by_digest_4_4;
7188 opti_type = OPTI_TYPE_ZERO_BYTE
7189 | OPTI_TYPE_PRECOMPUTE_INIT
7190 | OPTI_TYPE_PRECOMPUTE_MERKLE
7191 | OPTI_TYPE_EARLY_SKIP
7192 | OPTI_TYPE_NOT_ITERATED
7193 | OPTI_TYPE_PREPENDED_SALT
7194 | OPTI_TYPE_RAW_HASH;
7195 dgst_pos0 = 0;
7196 dgst_pos1 = 3;
7197 dgst_pos2 = 2;
7198 dgst_pos3 = 1;
7199 break;
7200
7201 case 23: hash_type = HASH_TYPE_MD5;
7202 salt_type = SALT_TYPE_EMBEDDED;
7203 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7204 opts_type = OPTS_TYPE_PT_GENERATE_LE
7205 | OPTS_TYPE_PT_ADD80
7206 | OPTS_TYPE_PT_ADDBITS14;
7207 kern_type = KERN_TYPE_MD5_SLTPW;
7208 dgst_size = DGST_SIZE_4_4;
7209 parse_func = skype_parse_hash;
7210 sort_by_digest = sort_by_digest_4_4;
7211 opti_type = OPTI_TYPE_ZERO_BYTE
7212 | OPTI_TYPE_PRECOMPUTE_INIT
7213 | OPTI_TYPE_PRECOMPUTE_MERKLE
7214 | OPTI_TYPE_EARLY_SKIP
7215 | OPTI_TYPE_NOT_ITERATED
7216 | OPTI_TYPE_PREPENDED_SALT
7217 | OPTI_TYPE_RAW_HASH;
7218 dgst_pos0 = 0;
7219 dgst_pos1 = 3;
7220 dgst_pos2 = 2;
7221 dgst_pos3 = 1;
7222 break;
7223
7224 case 30: hash_type = HASH_TYPE_MD5;
7225 salt_type = SALT_TYPE_INTERN;
7226 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7227 opts_type = OPTS_TYPE_PT_GENERATE_LE
7228 | OPTS_TYPE_PT_UNICODE
7229 | OPTS_TYPE_ST_ADD80
7230 | OPTS_TYPE_ST_ADDBITS14;
7231 kern_type = KERN_TYPE_MD5_PWUSLT;
7232 dgst_size = DGST_SIZE_4_4;
7233 parse_func = md5s_parse_hash;
7234 sort_by_digest = sort_by_digest_4_4;
7235 opti_type = OPTI_TYPE_ZERO_BYTE
7236 | OPTI_TYPE_PRECOMPUTE_INIT
7237 | OPTI_TYPE_PRECOMPUTE_MERKLE
7238 | OPTI_TYPE_MEET_IN_MIDDLE
7239 | OPTI_TYPE_EARLY_SKIP
7240 | OPTI_TYPE_NOT_ITERATED
7241 | OPTI_TYPE_APPENDED_SALT
7242 | OPTI_TYPE_RAW_HASH;
7243 dgst_pos0 = 0;
7244 dgst_pos1 = 3;
7245 dgst_pos2 = 2;
7246 dgst_pos3 = 1;
7247 break;
7248
7249 case 40: hash_type = HASH_TYPE_MD5;
7250 salt_type = SALT_TYPE_INTERN;
7251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7252 opts_type = OPTS_TYPE_PT_GENERATE_LE
7253 | OPTS_TYPE_PT_ADD80
7254 | OPTS_TYPE_PT_ADDBITS14
7255 | OPTS_TYPE_PT_UNICODE;
7256 kern_type = KERN_TYPE_MD5_SLTPWU;
7257 dgst_size = DGST_SIZE_4_4;
7258 parse_func = md5s_parse_hash;
7259 sort_by_digest = sort_by_digest_4_4;
7260 opti_type = OPTI_TYPE_ZERO_BYTE
7261 | OPTI_TYPE_PRECOMPUTE_INIT
7262 | OPTI_TYPE_PRECOMPUTE_MERKLE
7263 | OPTI_TYPE_EARLY_SKIP
7264 | OPTI_TYPE_NOT_ITERATED
7265 | OPTI_TYPE_PREPENDED_SALT
7266 | OPTI_TYPE_RAW_HASH;
7267 dgst_pos0 = 0;
7268 dgst_pos1 = 3;
7269 dgst_pos2 = 2;
7270 dgst_pos3 = 1;
7271 break;
7272
7273 case 50: hash_type = HASH_TYPE_MD5;
7274 salt_type = SALT_TYPE_INTERN;
7275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7276 opts_type = OPTS_TYPE_PT_GENERATE_LE
7277 | OPTS_TYPE_ST_ADD80
7278 | OPTS_TYPE_ST_ADDBITS14;
7279 kern_type = KERN_TYPE_HMACMD5_PW;
7280 dgst_size = DGST_SIZE_4_4;
7281 parse_func = hmacmd5_parse_hash;
7282 sort_by_digest = sort_by_digest_4_4;
7283 opti_type = OPTI_TYPE_ZERO_BYTE
7284 | OPTI_TYPE_NOT_ITERATED;
7285 dgst_pos0 = 0;
7286 dgst_pos1 = 3;
7287 dgst_pos2 = 2;
7288 dgst_pos3 = 1;
7289 break;
7290
7291 case 60: hash_type = HASH_TYPE_MD5;
7292 salt_type = SALT_TYPE_INTERN;
7293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7294 opts_type = OPTS_TYPE_PT_GENERATE_LE
7295 | OPTS_TYPE_PT_ADD80
7296 | OPTS_TYPE_PT_ADDBITS14;
7297 kern_type = KERN_TYPE_HMACMD5_SLT;
7298 dgst_size = DGST_SIZE_4_4;
7299 parse_func = hmacmd5_parse_hash;
7300 sort_by_digest = sort_by_digest_4_4;
7301 opti_type = OPTI_TYPE_ZERO_BYTE
7302 | OPTI_TYPE_NOT_ITERATED;
7303 dgst_pos0 = 0;
7304 dgst_pos1 = 3;
7305 dgst_pos2 = 2;
7306 dgst_pos3 = 1;
7307 break;
7308
7309 case 100: hash_type = HASH_TYPE_SHA1;
7310 salt_type = SALT_TYPE_NONE;
7311 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7312 opts_type = OPTS_TYPE_PT_GENERATE_BE
7313 | OPTS_TYPE_PT_ADD80
7314 | OPTS_TYPE_PT_ADDBITS15;
7315 kern_type = KERN_TYPE_SHA1;
7316 dgst_size = DGST_SIZE_4_5;
7317 parse_func = sha1_parse_hash;
7318 sort_by_digest = sort_by_digest_4_5;
7319 opti_type = OPTI_TYPE_ZERO_BYTE
7320 | OPTI_TYPE_PRECOMPUTE_INIT
7321 | OPTI_TYPE_PRECOMPUTE_MERKLE
7322 | OPTI_TYPE_EARLY_SKIP
7323 | OPTI_TYPE_NOT_ITERATED
7324 | OPTI_TYPE_NOT_SALTED
7325 | OPTI_TYPE_RAW_HASH;
7326 dgst_pos0 = 3;
7327 dgst_pos1 = 4;
7328 dgst_pos2 = 2;
7329 dgst_pos3 = 1;
7330 break;
7331
7332 case 101: hash_type = HASH_TYPE_SHA1;
7333 salt_type = SALT_TYPE_NONE;
7334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7335 opts_type = OPTS_TYPE_PT_GENERATE_BE
7336 | OPTS_TYPE_PT_ADD80
7337 | OPTS_TYPE_PT_ADDBITS15;
7338 kern_type = KERN_TYPE_SHA1;
7339 dgst_size = DGST_SIZE_4_5;
7340 parse_func = sha1b64_parse_hash;
7341 sort_by_digest = sort_by_digest_4_5;
7342 opti_type = OPTI_TYPE_ZERO_BYTE
7343 | OPTI_TYPE_PRECOMPUTE_INIT
7344 | OPTI_TYPE_PRECOMPUTE_MERKLE
7345 | OPTI_TYPE_EARLY_SKIP
7346 | OPTI_TYPE_NOT_ITERATED
7347 | OPTI_TYPE_NOT_SALTED
7348 | OPTI_TYPE_RAW_HASH;
7349 dgst_pos0 = 3;
7350 dgst_pos1 = 4;
7351 dgst_pos2 = 2;
7352 dgst_pos3 = 1;
7353 break;
7354
7355 case 110: hash_type = HASH_TYPE_SHA1;
7356 salt_type = SALT_TYPE_INTERN;
7357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7358 opts_type = OPTS_TYPE_PT_GENERATE_BE
7359 | OPTS_TYPE_ST_ADD80
7360 | OPTS_TYPE_ST_ADDBITS15;
7361 kern_type = KERN_TYPE_SHA1_PWSLT;
7362 dgst_size = DGST_SIZE_4_5;
7363 parse_func = sha1s_parse_hash;
7364 sort_by_digest = sort_by_digest_4_5;
7365 opti_type = OPTI_TYPE_ZERO_BYTE
7366 | OPTI_TYPE_PRECOMPUTE_INIT
7367 | OPTI_TYPE_PRECOMPUTE_MERKLE
7368 | OPTI_TYPE_EARLY_SKIP
7369 | OPTI_TYPE_NOT_ITERATED
7370 | OPTI_TYPE_APPENDED_SALT
7371 | OPTI_TYPE_RAW_HASH;
7372 dgst_pos0 = 3;
7373 dgst_pos1 = 4;
7374 dgst_pos2 = 2;
7375 dgst_pos3 = 1;
7376 break;
7377
7378 case 111: hash_type = HASH_TYPE_SHA1;
7379 salt_type = SALT_TYPE_EMBEDDED;
7380 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7381 opts_type = OPTS_TYPE_PT_GENERATE_BE
7382 | OPTS_TYPE_ST_ADD80
7383 | OPTS_TYPE_ST_ADDBITS15;
7384 kern_type = KERN_TYPE_SHA1_PWSLT;
7385 dgst_size = DGST_SIZE_4_5;
7386 parse_func = sha1b64s_parse_hash;
7387 sort_by_digest = sort_by_digest_4_5;
7388 opti_type = OPTI_TYPE_ZERO_BYTE
7389 | OPTI_TYPE_PRECOMPUTE_INIT
7390 | OPTI_TYPE_PRECOMPUTE_MERKLE
7391 | OPTI_TYPE_EARLY_SKIP
7392 | OPTI_TYPE_NOT_ITERATED
7393 | OPTI_TYPE_APPENDED_SALT
7394 | OPTI_TYPE_RAW_HASH;
7395 dgst_pos0 = 3;
7396 dgst_pos1 = 4;
7397 dgst_pos2 = 2;
7398 dgst_pos3 = 1;
7399 break;
7400
7401 case 112: hash_type = HASH_TYPE_SHA1;
7402 salt_type = SALT_TYPE_INTERN;
7403 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7404 opts_type = OPTS_TYPE_PT_GENERATE_BE
7405 | OPTS_TYPE_ST_ADD80
7406 | OPTS_TYPE_ST_ADDBITS15
7407 | OPTS_TYPE_ST_HEX;
7408 kern_type = KERN_TYPE_SHA1_PWSLT;
7409 dgst_size = DGST_SIZE_4_5;
7410 parse_func = oracles_parse_hash;
7411 sort_by_digest = sort_by_digest_4_5;
7412 opti_type = OPTI_TYPE_ZERO_BYTE
7413 | OPTI_TYPE_PRECOMPUTE_INIT
7414 | OPTI_TYPE_PRECOMPUTE_MERKLE
7415 | OPTI_TYPE_EARLY_SKIP
7416 | OPTI_TYPE_NOT_ITERATED
7417 | OPTI_TYPE_APPENDED_SALT
7418 | OPTI_TYPE_RAW_HASH;
7419 dgst_pos0 = 3;
7420 dgst_pos1 = 4;
7421 dgst_pos2 = 2;
7422 dgst_pos3 = 1;
7423 break;
7424
7425 case 120: hash_type = HASH_TYPE_SHA1;
7426 salt_type = SALT_TYPE_INTERN;
7427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7428 opts_type = OPTS_TYPE_PT_GENERATE_BE
7429 | OPTS_TYPE_PT_ADD80
7430 | OPTS_TYPE_PT_ADDBITS15;
7431 kern_type = KERN_TYPE_SHA1_SLTPW;
7432 dgst_size = DGST_SIZE_4_5;
7433 parse_func = sha1s_parse_hash;
7434 sort_by_digest = sort_by_digest_4_5;
7435 opti_type = OPTI_TYPE_ZERO_BYTE
7436 | OPTI_TYPE_PRECOMPUTE_INIT
7437 | OPTI_TYPE_PRECOMPUTE_MERKLE
7438 | OPTI_TYPE_EARLY_SKIP
7439 | OPTI_TYPE_NOT_ITERATED
7440 | OPTI_TYPE_PREPENDED_SALT
7441 | OPTI_TYPE_RAW_HASH;
7442 dgst_pos0 = 3;
7443 dgst_pos1 = 4;
7444 dgst_pos2 = 2;
7445 dgst_pos3 = 1;
7446 break;
7447
7448 case 121: hash_type = HASH_TYPE_SHA1;
7449 salt_type = SALT_TYPE_INTERN;
7450 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7451 opts_type = OPTS_TYPE_PT_GENERATE_BE
7452 | OPTS_TYPE_PT_ADD80
7453 | OPTS_TYPE_PT_ADDBITS15
7454 | OPTS_TYPE_ST_LOWER;
7455 kern_type = KERN_TYPE_SHA1_SLTPW;
7456 dgst_size = DGST_SIZE_4_5;
7457 parse_func = smf_parse_hash;
7458 sort_by_digest = sort_by_digest_4_5;
7459 opti_type = OPTI_TYPE_ZERO_BYTE
7460 | OPTI_TYPE_PRECOMPUTE_INIT
7461 | OPTI_TYPE_PRECOMPUTE_MERKLE
7462 | OPTI_TYPE_EARLY_SKIP
7463 | OPTI_TYPE_NOT_ITERATED
7464 | OPTI_TYPE_PREPENDED_SALT
7465 | OPTI_TYPE_RAW_HASH;
7466 dgst_pos0 = 3;
7467 dgst_pos1 = 4;
7468 dgst_pos2 = 2;
7469 dgst_pos3 = 1;
7470 break;
7471
7472 case 122: hash_type = HASH_TYPE_SHA1;
7473 salt_type = SALT_TYPE_EMBEDDED;
7474 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7475 opts_type = OPTS_TYPE_PT_GENERATE_BE
7476 | OPTS_TYPE_PT_ADD80
7477 | OPTS_TYPE_PT_ADDBITS15
7478 | OPTS_TYPE_ST_HEX;
7479 kern_type = KERN_TYPE_SHA1_SLTPW;
7480 dgst_size = DGST_SIZE_4_5;
7481 parse_func = osx1_parse_hash;
7482 sort_by_digest = sort_by_digest_4_5;
7483 opti_type = OPTI_TYPE_ZERO_BYTE
7484 | OPTI_TYPE_PRECOMPUTE_INIT
7485 | OPTI_TYPE_PRECOMPUTE_MERKLE
7486 | OPTI_TYPE_EARLY_SKIP
7487 | OPTI_TYPE_NOT_ITERATED
7488 | OPTI_TYPE_PREPENDED_SALT
7489 | OPTI_TYPE_RAW_HASH;
7490 dgst_pos0 = 3;
7491 dgst_pos1 = 4;
7492 dgst_pos2 = 2;
7493 dgst_pos3 = 1;
7494 break;
7495
7496 case 124: hash_type = HASH_TYPE_SHA1;
7497 salt_type = SALT_TYPE_EMBEDDED;
7498 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7499 opts_type = OPTS_TYPE_PT_GENERATE_BE
7500 | OPTS_TYPE_PT_ADD80
7501 | OPTS_TYPE_PT_ADDBITS15;
7502 kern_type = KERN_TYPE_SHA1_SLTPW;
7503 dgst_size = DGST_SIZE_4_5;
7504 parse_func = djangosha1_parse_hash;
7505 sort_by_digest = sort_by_digest_4_5;
7506 opti_type = OPTI_TYPE_ZERO_BYTE
7507 | OPTI_TYPE_PRECOMPUTE_INIT
7508 | OPTI_TYPE_PRECOMPUTE_MERKLE
7509 | OPTI_TYPE_EARLY_SKIP
7510 | OPTI_TYPE_NOT_ITERATED
7511 | OPTI_TYPE_PREPENDED_SALT
7512 | OPTI_TYPE_RAW_HASH;
7513 dgst_pos0 = 3;
7514 dgst_pos1 = 4;
7515 dgst_pos2 = 2;
7516 dgst_pos3 = 1;
7517 break;
7518
7519 case 125: hash_type = HASH_TYPE_SHA1;
7520 salt_type = SALT_TYPE_EMBEDDED;
7521 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7522 opts_type = OPTS_TYPE_PT_GENERATE_BE
7523 | OPTS_TYPE_PT_ADD80
7524 | OPTS_TYPE_PT_ADDBITS15
7525 | OPTS_TYPE_ST_HEX;
7526 kern_type = KERN_TYPE_SHA1_SLTPW;
7527 dgst_size = DGST_SIZE_4_5;
7528 parse_func = arubaos_parse_hash;
7529 sort_by_digest = sort_by_digest_4_5;
7530 opti_type = OPTI_TYPE_ZERO_BYTE
7531 | OPTI_TYPE_PRECOMPUTE_INIT
7532 | OPTI_TYPE_PRECOMPUTE_MERKLE
7533 | OPTI_TYPE_EARLY_SKIP
7534 | OPTI_TYPE_NOT_ITERATED
7535 | OPTI_TYPE_PREPENDED_SALT
7536 | OPTI_TYPE_RAW_HASH;
7537 dgst_pos0 = 3;
7538 dgst_pos1 = 4;
7539 dgst_pos2 = 2;
7540 dgst_pos3 = 1;
7541 break;
7542
7543 case 130: hash_type = HASH_TYPE_SHA1;
7544 salt_type = SALT_TYPE_INTERN;
7545 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7546 opts_type = OPTS_TYPE_PT_GENERATE_BE
7547 | OPTS_TYPE_PT_UNICODE
7548 | OPTS_TYPE_ST_ADD80
7549 | OPTS_TYPE_ST_ADDBITS15;
7550 kern_type = KERN_TYPE_SHA1_PWUSLT;
7551 dgst_size = DGST_SIZE_4_5;
7552 parse_func = sha1s_parse_hash;
7553 sort_by_digest = sort_by_digest_4_5;
7554 opti_type = OPTI_TYPE_ZERO_BYTE
7555 | OPTI_TYPE_PRECOMPUTE_INIT
7556 | OPTI_TYPE_PRECOMPUTE_MERKLE
7557 | OPTI_TYPE_EARLY_SKIP
7558 | OPTI_TYPE_NOT_ITERATED
7559 | OPTI_TYPE_APPENDED_SALT
7560 | OPTI_TYPE_RAW_HASH;
7561 dgst_pos0 = 3;
7562 dgst_pos1 = 4;
7563 dgst_pos2 = 2;
7564 dgst_pos3 = 1;
7565 break;
7566
7567 case 131: hash_type = HASH_TYPE_SHA1;
7568 salt_type = SALT_TYPE_EMBEDDED;
7569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7570 opts_type = OPTS_TYPE_PT_GENERATE_BE
7571 | OPTS_TYPE_PT_UNICODE
7572 | OPTS_TYPE_PT_UPPER
7573 | OPTS_TYPE_ST_ADD80
7574 | OPTS_TYPE_ST_ADDBITS15
7575 | OPTS_TYPE_ST_HEX;
7576 kern_type = KERN_TYPE_SHA1_PWUSLT;
7577 dgst_size = DGST_SIZE_4_5;
7578 parse_func = mssql2000_parse_hash;
7579 sort_by_digest = sort_by_digest_4_5;
7580 opti_type = OPTI_TYPE_ZERO_BYTE
7581 | OPTI_TYPE_PRECOMPUTE_INIT
7582 | OPTI_TYPE_PRECOMPUTE_MERKLE
7583 | OPTI_TYPE_EARLY_SKIP
7584 | OPTI_TYPE_NOT_ITERATED
7585 | OPTI_TYPE_APPENDED_SALT
7586 | OPTI_TYPE_RAW_HASH;
7587 dgst_pos0 = 3;
7588 dgst_pos1 = 4;
7589 dgst_pos2 = 2;
7590 dgst_pos3 = 1;
7591 break;
7592
7593 case 132: hash_type = HASH_TYPE_SHA1;
7594 salt_type = SALT_TYPE_EMBEDDED;
7595 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7596 opts_type = OPTS_TYPE_PT_GENERATE_BE
7597 | OPTS_TYPE_PT_UNICODE
7598 | OPTS_TYPE_ST_ADD80
7599 | OPTS_TYPE_ST_ADDBITS15
7600 | OPTS_TYPE_ST_HEX;
7601 kern_type = KERN_TYPE_SHA1_PWUSLT;
7602 dgst_size = DGST_SIZE_4_5;
7603 parse_func = mssql2005_parse_hash;
7604 sort_by_digest = sort_by_digest_4_5;
7605 opti_type = OPTI_TYPE_ZERO_BYTE
7606 | OPTI_TYPE_PRECOMPUTE_INIT
7607 | OPTI_TYPE_PRECOMPUTE_MERKLE
7608 | OPTI_TYPE_EARLY_SKIP
7609 | OPTI_TYPE_NOT_ITERATED
7610 | OPTI_TYPE_APPENDED_SALT
7611 | OPTI_TYPE_RAW_HASH;
7612 dgst_pos0 = 3;
7613 dgst_pos1 = 4;
7614 dgst_pos2 = 2;
7615 dgst_pos3 = 1;
7616 break;
7617
7618 case 133: hash_type = HASH_TYPE_SHA1;
7619 salt_type = SALT_TYPE_EMBEDDED;
7620 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7621 opts_type = OPTS_TYPE_PT_GENERATE_BE
7622 | OPTS_TYPE_PT_UNICODE
7623 | OPTS_TYPE_ST_ADD80
7624 | OPTS_TYPE_ST_ADDBITS15;
7625 kern_type = KERN_TYPE_SHA1_PWUSLT;
7626 dgst_size = DGST_SIZE_4_5;
7627 parse_func = peoplesoft_parse_hash;
7628 sort_by_digest = sort_by_digest_4_5;
7629 opti_type = OPTI_TYPE_ZERO_BYTE
7630 | OPTI_TYPE_PRECOMPUTE_INIT
7631 | OPTI_TYPE_PRECOMPUTE_MERKLE
7632 | OPTI_TYPE_EARLY_SKIP
7633 | OPTI_TYPE_NOT_ITERATED
7634 | OPTI_TYPE_APPENDED_SALT
7635 | OPTI_TYPE_RAW_HASH;
7636 dgst_pos0 = 3;
7637 dgst_pos1 = 4;
7638 dgst_pos2 = 2;
7639 dgst_pos3 = 1;
7640 break;
7641
7642 case 140: hash_type = HASH_TYPE_SHA1;
7643 salt_type = SALT_TYPE_INTERN;
7644 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7645 opts_type = OPTS_TYPE_PT_GENERATE_BE
7646 | OPTS_TYPE_PT_ADD80
7647 | OPTS_TYPE_PT_ADDBITS15
7648 | OPTS_TYPE_PT_UNICODE;
7649 kern_type = KERN_TYPE_SHA1_SLTPWU;
7650 dgst_size = DGST_SIZE_4_5;
7651 parse_func = sha1s_parse_hash;
7652 sort_by_digest = sort_by_digest_4_5;
7653 opti_type = OPTI_TYPE_ZERO_BYTE
7654 | OPTI_TYPE_PRECOMPUTE_INIT
7655 | OPTI_TYPE_PRECOMPUTE_MERKLE
7656 | OPTI_TYPE_EARLY_SKIP
7657 | OPTI_TYPE_NOT_ITERATED
7658 | OPTI_TYPE_PREPENDED_SALT
7659 | OPTI_TYPE_RAW_HASH;
7660 dgst_pos0 = 3;
7661 dgst_pos1 = 4;
7662 dgst_pos2 = 2;
7663 dgst_pos3 = 1;
7664 break;
7665
7666 case 141: hash_type = HASH_TYPE_SHA1;
7667 salt_type = SALT_TYPE_EMBEDDED;
7668 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7669 opts_type = OPTS_TYPE_PT_GENERATE_BE
7670 | OPTS_TYPE_PT_ADD80
7671 | OPTS_TYPE_PT_ADDBITS15
7672 | OPTS_TYPE_PT_UNICODE
7673 | OPTS_TYPE_ST_BASE64;
7674 kern_type = KERN_TYPE_SHA1_SLTPWU;
7675 dgst_size = DGST_SIZE_4_5;
7676 parse_func = episerver_parse_hash;
7677 sort_by_digest = sort_by_digest_4_5;
7678 opti_type = OPTI_TYPE_ZERO_BYTE
7679 | OPTI_TYPE_PRECOMPUTE_INIT
7680 | OPTI_TYPE_PRECOMPUTE_MERKLE
7681 | OPTI_TYPE_EARLY_SKIP
7682 | OPTI_TYPE_NOT_ITERATED
7683 | OPTI_TYPE_PREPENDED_SALT
7684 | OPTI_TYPE_RAW_HASH;
7685 dgst_pos0 = 3;
7686 dgst_pos1 = 4;
7687 dgst_pos2 = 2;
7688 dgst_pos3 = 1;
7689 break;
7690
7691 case 150: hash_type = HASH_TYPE_SHA1;
7692 salt_type = SALT_TYPE_INTERN;
7693 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7694 opts_type = OPTS_TYPE_PT_GENERATE_BE
7695 | OPTS_TYPE_ST_ADD80
7696 | OPTS_TYPE_ST_ADDBITS15;
7697 kern_type = KERN_TYPE_HMACSHA1_PW;
7698 dgst_size = DGST_SIZE_4_5;
7699 parse_func = hmacsha1_parse_hash;
7700 sort_by_digest = sort_by_digest_4_5;
7701 opti_type = OPTI_TYPE_ZERO_BYTE
7702 | OPTI_TYPE_NOT_ITERATED;
7703 dgst_pos0 = 3;
7704 dgst_pos1 = 4;
7705 dgst_pos2 = 2;
7706 dgst_pos3 = 1;
7707 break;
7708
7709 case 160: hash_type = HASH_TYPE_SHA1;
7710 salt_type = SALT_TYPE_INTERN;
7711 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7712 opts_type = OPTS_TYPE_PT_GENERATE_BE
7713 | OPTS_TYPE_PT_ADD80
7714 | OPTS_TYPE_PT_ADDBITS15;
7715 kern_type = KERN_TYPE_HMACSHA1_SLT;
7716 dgst_size = DGST_SIZE_4_5;
7717 parse_func = hmacsha1_parse_hash;
7718 sort_by_digest = sort_by_digest_4_5;
7719 opti_type = OPTI_TYPE_ZERO_BYTE
7720 | OPTI_TYPE_NOT_ITERATED;
7721 dgst_pos0 = 3;
7722 dgst_pos1 = 4;
7723 dgst_pos2 = 2;
7724 dgst_pos3 = 1;
7725 break;
7726
7727 case 190: hash_type = HASH_TYPE_SHA1;
7728 salt_type = SALT_TYPE_NONE;
7729 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7730 opts_type = OPTS_TYPE_PT_GENERATE_BE
7731 | OPTS_TYPE_PT_ADD80
7732 | OPTS_TYPE_PT_ADDBITS15;
7733 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7734 dgst_size = DGST_SIZE_4_5;
7735 parse_func = sha1linkedin_parse_hash;
7736 sort_by_digest = sort_by_digest_4_5;
7737 opti_type = OPTI_TYPE_ZERO_BYTE
7738 | OPTI_TYPE_PRECOMPUTE_INIT
7739 | OPTI_TYPE_EARLY_SKIP
7740 | OPTI_TYPE_NOT_ITERATED
7741 | OPTI_TYPE_NOT_SALTED;
7742 dgst_pos0 = 0;
7743 dgst_pos1 = 4;
7744 dgst_pos2 = 3;
7745 dgst_pos3 = 2;
7746 break;
7747
7748 case 200: hash_type = HASH_TYPE_MYSQL;
7749 salt_type = SALT_TYPE_NONE;
7750 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7751 opts_type = 0;
7752 kern_type = KERN_TYPE_MYSQL;
7753 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7754 parse_func = mysql323_parse_hash;
7755 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7756 opti_type = OPTI_TYPE_ZERO_BYTE;
7757 dgst_pos0 = 0;
7758 dgst_pos1 = 1;
7759 dgst_pos2 = 2;
7760 dgst_pos3 = 3;
7761 break;
7762
7763 case 300: hash_type = HASH_TYPE_SHA1;
7764 salt_type = SALT_TYPE_NONE;
7765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7766 opts_type = OPTS_TYPE_PT_GENERATE_BE
7767 | OPTS_TYPE_PT_ADD80
7768 | OPTS_TYPE_PT_ADDBITS15;
7769 kern_type = KERN_TYPE_MYSQL41;
7770 dgst_size = DGST_SIZE_4_5;
7771 parse_func = sha1_parse_hash;
7772 sort_by_digest = sort_by_digest_4_5;
7773 opti_type = OPTI_TYPE_ZERO_BYTE
7774 | OPTI_TYPE_PRECOMPUTE_INIT
7775 | OPTI_TYPE_PRECOMPUTE_MERKLE
7776 | OPTI_TYPE_EARLY_SKIP
7777 | OPTI_TYPE_NOT_ITERATED
7778 | OPTI_TYPE_NOT_SALTED;
7779 dgst_pos0 = 3;
7780 dgst_pos1 = 4;
7781 dgst_pos2 = 2;
7782 dgst_pos3 = 1;
7783 break;
7784
7785 case 400: hash_type = HASH_TYPE_MD5;
7786 salt_type = SALT_TYPE_EMBEDDED;
7787 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7788 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7789 kern_type = KERN_TYPE_PHPASS;
7790 dgst_size = DGST_SIZE_4_4;
7791 parse_func = phpass_parse_hash;
7792 sort_by_digest = sort_by_digest_4_4;
7793 opti_type = OPTI_TYPE_ZERO_BYTE
7794 | OPTI_TYPE_SLOW_HASH_SIMD;
7795 dgst_pos0 = 0;
7796 dgst_pos1 = 1;
7797 dgst_pos2 = 2;
7798 dgst_pos3 = 3;
7799 break;
7800
7801 case 500: hash_type = HASH_TYPE_MD5;
7802 salt_type = SALT_TYPE_EMBEDDED;
7803 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7804 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7805 kern_type = KERN_TYPE_MD5CRYPT;
7806 dgst_size = DGST_SIZE_4_4;
7807 parse_func = md5crypt_parse_hash;
7808 sort_by_digest = sort_by_digest_4_4;
7809 opti_type = OPTI_TYPE_ZERO_BYTE;
7810 dgst_pos0 = 0;
7811 dgst_pos1 = 1;
7812 dgst_pos2 = 2;
7813 dgst_pos3 = 3;
7814 break;
7815
7816 case 501: hash_type = HASH_TYPE_MD5;
7817 salt_type = SALT_TYPE_EMBEDDED;
7818 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7819 opts_type = OPTS_TYPE_PT_GENERATE_LE
7820 | OPTS_TYPE_HASH_COPY;
7821 kern_type = KERN_TYPE_MD5CRYPT;
7822 dgst_size = DGST_SIZE_4_4;
7823 parse_func = juniper_parse_hash;
7824 sort_by_digest = sort_by_digest_4_4;
7825 opti_type = OPTI_TYPE_ZERO_BYTE;
7826 dgst_pos0 = 0;
7827 dgst_pos1 = 1;
7828 dgst_pos2 = 2;
7829 dgst_pos3 = 3;
7830 break;
7831
7832 case 900: hash_type = HASH_TYPE_MD4;
7833 salt_type = SALT_TYPE_NONE;
7834 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7835 opts_type = OPTS_TYPE_PT_GENERATE_LE
7836 | OPTS_TYPE_PT_ADD80
7837 | OPTS_TYPE_PT_ADDBITS14;
7838 kern_type = KERN_TYPE_MD4;
7839 dgst_size = DGST_SIZE_4_4;
7840 parse_func = md4_parse_hash;
7841 sort_by_digest = sort_by_digest_4_4;
7842 opti_type = OPTI_TYPE_ZERO_BYTE
7843 | OPTI_TYPE_PRECOMPUTE_INIT
7844 | OPTI_TYPE_PRECOMPUTE_MERKLE
7845 | OPTI_TYPE_MEET_IN_MIDDLE
7846 | OPTI_TYPE_EARLY_SKIP
7847 | OPTI_TYPE_NOT_ITERATED
7848 | OPTI_TYPE_NOT_SALTED
7849 | OPTI_TYPE_RAW_HASH;
7850 dgst_pos0 = 0;
7851 dgst_pos1 = 3;
7852 dgst_pos2 = 2;
7853 dgst_pos3 = 1;
7854 break;
7855
7856 case 1000: hash_type = HASH_TYPE_MD4;
7857 salt_type = SALT_TYPE_NONE;
7858 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7859 opts_type = OPTS_TYPE_PT_GENERATE_LE
7860 | OPTS_TYPE_PT_ADD80
7861 | OPTS_TYPE_PT_ADDBITS14
7862 | OPTS_TYPE_PT_UNICODE;
7863 kern_type = KERN_TYPE_MD4_PWU;
7864 dgst_size = DGST_SIZE_4_4;
7865 parse_func = md4_parse_hash;
7866 sort_by_digest = sort_by_digest_4_4;
7867 opti_type = OPTI_TYPE_ZERO_BYTE
7868 | OPTI_TYPE_PRECOMPUTE_INIT
7869 | OPTI_TYPE_PRECOMPUTE_MERKLE
7870 | OPTI_TYPE_MEET_IN_MIDDLE
7871 | OPTI_TYPE_EARLY_SKIP
7872 | OPTI_TYPE_NOT_ITERATED
7873 | OPTI_TYPE_NOT_SALTED
7874 | OPTI_TYPE_RAW_HASH;
7875 dgst_pos0 = 0;
7876 dgst_pos1 = 3;
7877 dgst_pos2 = 2;
7878 dgst_pos3 = 1;
7879 break;
7880
7881 case 1100: hash_type = HASH_TYPE_MD4;
7882 salt_type = SALT_TYPE_INTERN;
7883 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7884 opts_type = OPTS_TYPE_PT_GENERATE_LE
7885 | OPTS_TYPE_PT_ADD80
7886 | OPTS_TYPE_PT_ADDBITS14
7887 | OPTS_TYPE_PT_UNICODE
7888 | OPTS_TYPE_ST_ADD80
7889 | OPTS_TYPE_ST_UNICODE
7890 | OPTS_TYPE_ST_LOWER;
7891 kern_type = KERN_TYPE_MD44_PWUSLT;
7892 dgst_size = DGST_SIZE_4_4;
7893 parse_func = dcc_parse_hash;
7894 sort_by_digest = sort_by_digest_4_4;
7895 opti_type = OPTI_TYPE_ZERO_BYTE
7896 | OPTI_TYPE_PRECOMPUTE_INIT
7897 | OPTI_TYPE_PRECOMPUTE_MERKLE
7898 | OPTI_TYPE_EARLY_SKIP
7899 | OPTI_TYPE_NOT_ITERATED;
7900 dgst_pos0 = 0;
7901 dgst_pos1 = 3;
7902 dgst_pos2 = 2;
7903 dgst_pos3 = 1;
7904 break;
7905
7906 case 1400: hash_type = HASH_TYPE_SHA256;
7907 salt_type = SALT_TYPE_NONE;
7908 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7909 opts_type = OPTS_TYPE_PT_GENERATE_BE
7910 | OPTS_TYPE_PT_ADD80
7911 | OPTS_TYPE_PT_ADDBITS15;
7912 kern_type = KERN_TYPE_SHA256;
7913 dgst_size = DGST_SIZE_4_8;
7914 parse_func = sha256_parse_hash;
7915 sort_by_digest = sort_by_digest_4_8;
7916 opti_type = OPTI_TYPE_ZERO_BYTE
7917 | OPTI_TYPE_PRECOMPUTE_INIT
7918 | OPTI_TYPE_PRECOMPUTE_MERKLE
7919 | OPTI_TYPE_EARLY_SKIP
7920 | OPTI_TYPE_NOT_ITERATED
7921 | OPTI_TYPE_NOT_SALTED
7922 | OPTI_TYPE_RAW_HASH;
7923 dgst_pos0 = 3;
7924 dgst_pos1 = 7;
7925 dgst_pos2 = 2;
7926 dgst_pos3 = 6;
7927 break;
7928
7929 case 1410: hash_type = HASH_TYPE_SHA256;
7930 salt_type = SALT_TYPE_INTERN;
7931 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7932 opts_type = OPTS_TYPE_PT_GENERATE_BE
7933 | OPTS_TYPE_ST_ADD80
7934 | OPTS_TYPE_ST_ADDBITS15;
7935 kern_type = KERN_TYPE_SHA256_PWSLT;
7936 dgst_size = DGST_SIZE_4_8;
7937 parse_func = sha256s_parse_hash;
7938 sort_by_digest = sort_by_digest_4_8;
7939 opti_type = OPTI_TYPE_ZERO_BYTE
7940 | OPTI_TYPE_PRECOMPUTE_INIT
7941 | OPTI_TYPE_PRECOMPUTE_MERKLE
7942 | OPTI_TYPE_EARLY_SKIP
7943 | OPTI_TYPE_NOT_ITERATED
7944 | OPTI_TYPE_APPENDED_SALT
7945 | OPTI_TYPE_RAW_HASH;
7946 dgst_pos0 = 3;
7947 dgst_pos1 = 7;
7948 dgst_pos2 = 2;
7949 dgst_pos3 = 6;
7950 break;
7951
7952 case 1420: hash_type = HASH_TYPE_SHA256;
7953 salt_type = SALT_TYPE_INTERN;
7954 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7955 opts_type = OPTS_TYPE_PT_GENERATE_BE
7956 | OPTS_TYPE_PT_ADD80
7957 | OPTS_TYPE_PT_ADDBITS15;
7958 kern_type = KERN_TYPE_SHA256_SLTPW;
7959 dgst_size = DGST_SIZE_4_8;
7960 parse_func = sha256s_parse_hash;
7961 sort_by_digest = sort_by_digest_4_8;
7962 opti_type = OPTI_TYPE_ZERO_BYTE
7963 | OPTI_TYPE_PRECOMPUTE_INIT
7964 | OPTI_TYPE_PRECOMPUTE_MERKLE
7965 | OPTI_TYPE_EARLY_SKIP
7966 | OPTI_TYPE_NOT_ITERATED
7967 | OPTI_TYPE_PREPENDED_SALT
7968 | OPTI_TYPE_RAW_HASH;
7969 dgst_pos0 = 3;
7970 dgst_pos1 = 7;
7971 dgst_pos2 = 2;
7972 dgst_pos3 = 6;
7973 break;
7974
7975 case 1421: hash_type = HASH_TYPE_SHA256;
7976 salt_type = SALT_TYPE_EMBEDDED;
7977 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7978 opts_type = OPTS_TYPE_PT_GENERATE_BE
7979 | OPTS_TYPE_PT_ADD80
7980 | OPTS_TYPE_PT_ADDBITS15;
7981 kern_type = KERN_TYPE_SHA256_SLTPW;
7982 dgst_size = DGST_SIZE_4_8;
7983 parse_func = hmailserver_parse_hash;
7984 sort_by_digest = sort_by_digest_4_8;
7985 opti_type = OPTI_TYPE_ZERO_BYTE
7986 | OPTI_TYPE_PRECOMPUTE_INIT
7987 | OPTI_TYPE_PRECOMPUTE_MERKLE
7988 | OPTI_TYPE_EARLY_SKIP
7989 | OPTI_TYPE_NOT_ITERATED
7990 | OPTI_TYPE_PREPENDED_SALT
7991 | OPTI_TYPE_RAW_HASH;
7992 dgst_pos0 = 3;
7993 dgst_pos1 = 7;
7994 dgst_pos2 = 2;
7995 dgst_pos3 = 6;
7996 break;
7997
7998 case 1430: hash_type = HASH_TYPE_SHA256;
7999 salt_type = SALT_TYPE_INTERN;
8000 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8001 opts_type = OPTS_TYPE_PT_GENERATE_BE
8002 | OPTS_TYPE_PT_UNICODE
8003 | OPTS_TYPE_ST_ADD80
8004 | OPTS_TYPE_ST_ADDBITS15;
8005 kern_type = KERN_TYPE_SHA256_PWUSLT;
8006 dgst_size = DGST_SIZE_4_8;
8007 parse_func = sha256s_parse_hash;
8008 sort_by_digest = sort_by_digest_4_8;
8009 opti_type = OPTI_TYPE_ZERO_BYTE
8010 | OPTI_TYPE_PRECOMPUTE_INIT
8011 | OPTI_TYPE_PRECOMPUTE_MERKLE
8012 | OPTI_TYPE_EARLY_SKIP
8013 | OPTI_TYPE_NOT_ITERATED
8014 | OPTI_TYPE_APPENDED_SALT
8015 | OPTI_TYPE_RAW_HASH;
8016 dgst_pos0 = 3;
8017 dgst_pos1 = 7;
8018 dgst_pos2 = 2;
8019 dgst_pos3 = 6;
8020 break;
8021
8022 case 1440: hash_type = HASH_TYPE_SHA256;
8023 salt_type = SALT_TYPE_INTERN;
8024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8025 opts_type = OPTS_TYPE_PT_GENERATE_BE
8026 | OPTS_TYPE_PT_ADD80
8027 | OPTS_TYPE_PT_ADDBITS15
8028 | OPTS_TYPE_PT_UNICODE;
8029 kern_type = KERN_TYPE_SHA256_SLTPWU;
8030 dgst_size = DGST_SIZE_4_8;
8031 parse_func = sha256s_parse_hash;
8032 sort_by_digest = sort_by_digest_4_8;
8033 opti_type = OPTI_TYPE_ZERO_BYTE
8034 | OPTI_TYPE_PRECOMPUTE_INIT
8035 | OPTI_TYPE_PRECOMPUTE_MERKLE
8036 | OPTI_TYPE_EARLY_SKIP
8037 | OPTI_TYPE_NOT_ITERATED
8038 | OPTI_TYPE_PREPENDED_SALT
8039 | OPTI_TYPE_RAW_HASH;
8040 dgst_pos0 = 3;
8041 dgst_pos1 = 7;
8042 dgst_pos2 = 2;
8043 dgst_pos3 = 6;
8044 break;
8045
8046 case 1441: hash_type = HASH_TYPE_SHA256;
8047 salt_type = SALT_TYPE_EMBEDDED;
8048 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8049 opts_type = OPTS_TYPE_PT_GENERATE_BE
8050 | OPTS_TYPE_PT_ADD80
8051 | OPTS_TYPE_PT_ADDBITS15
8052 | OPTS_TYPE_PT_UNICODE
8053 | OPTS_TYPE_ST_BASE64;
8054 kern_type = KERN_TYPE_SHA256_SLTPWU;
8055 dgst_size = DGST_SIZE_4_8;
8056 parse_func = episerver4_parse_hash;
8057 sort_by_digest = sort_by_digest_4_8;
8058 opti_type = OPTI_TYPE_ZERO_BYTE
8059 | OPTI_TYPE_PRECOMPUTE_INIT
8060 | OPTI_TYPE_PRECOMPUTE_MERKLE
8061 | OPTI_TYPE_EARLY_SKIP
8062 | OPTI_TYPE_NOT_ITERATED
8063 | OPTI_TYPE_PREPENDED_SALT
8064 | OPTI_TYPE_RAW_HASH;
8065 dgst_pos0 = 3;
8066 dgst_pos1 = 7;
8067 dgst_pos2 = 2;
8068 dgst_pos3 = 6;
8069 break;
8070
8071 case 1450: hash_type = HASH_TYPE_SHA256;
8072 salt_type = SALT_TYPE_INTERN;
8073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8074 opts_type = OPTS_TYPE_PT_GENERATE_BE
8075 | OPTS_TYPE_ST_ADD80;
8076 kern_type = KERN_TYPE_HMACSHA256_PW;
8077 dgst_size = DGST_SIZE_4_8;
8078 parse_func = hmacsha256_parse_hash;
8079 sort_by_digest = sort_by_digest_4_8;
8080 opti_type = OPTI_TYPE_ZERO_BYTE
8081 | OPTI_TYPE_NOT_ITERATED;
8082 dgst_pos0 = 3;
8083 dgst_pos1 = 7;
8084 dgst_pos2 = 2;
8085 dgst_pos3 = 6;
8086 break;
8087
8088 case 1460: hash_type = HASH_TYPE_SHA256;
8089 salt_type = SALT_TYPE_INTERN;
8090 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8091 opts_type = OPTS_TYPE_PT_GENERATE_BE
8092 | OPTS_TYPE_PT_ADD80
8093 | OPTS_TYPE_PT_ADDBITS15;
8094 kern_type = KERN_TYPE_HMACSHA256_SLT;
8095 dgst_size = DGST_SIZE_4_8;
8096 parse_func = hmacsha256_parse_hash;
8097 sort_by_digest = sort_by_digest_4_8;
8098 opti_type = OPTI_TYPE_ZERO_BYTE
8099 | OPTI_TYPE_NOT_ITERATED;
8100 dgst_pos0 = 3;
8101 dgst_pos1 = 7;
8102 dgst_pos2 = 2;
8103 dgst_pos3 = 6;
8104 break;
8105
8106 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8107 salt_type = SALT_TYPE_EMBEDDED;
8108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8109 opts_type = OPTS_TYPE_PT_GENERATE_LE
8110 | OPTS_TYPE_PT_BITSLICE;
8111 kern_type = KERN_TYPE_DESCRYPT;
8112 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8113 parse_func = descrypt_parse_hash;
8114 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8115 opti_type = OPTI_TYPE_ZERO_BYTE
8116 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8117 dgst_pos0 = 0;
8118 dgst_pos1 = 1;
8119 dgst_pos2 = 2;
8120 dgst_pos3 = 3;
8121 break;
8122
8123 case 1600: hash_type = HASH_TYPE_MD5;
8124 salt_type = SALT_TYPE_EMBEDDED;
8125 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8126 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8127 kern_type = KERN_TYPE_APR1CRYPT;
8128 dgst_size = DGST_SIZE_4_4;
8129 parse_func = md5apr1_parse_hash;
8130 sort_by_digest = sort_by_digest_4_4;
8131 opti_type = OPTI_TYPE_ZERO_BYTE;
8132 dgst_pos0 = 0;
8133 dgst_pos1 = 1;
8134 dgst_pos2 = 2;
8135 dgst_pos3 = 3;
8136 break;
8137
8138 case 1700: hash_type = HASH_TYPE_SHA512;
8139 salt_type = SALT_TYPE_NONE;
8140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8141 opts_type = OPTS_TYPE_PT_GENERATE_BE
8142 | OPTS_TYPE_PT_ADD80
8143 | OPTS_TYPE_PT_ADDBITS15;
8144 kern_type = KERN_TYPE_SHA512;
8145 dgst_size = DGST_SIZE_8_8;
8146 parse_func = sha512_parse_hash;
8147 sort_by_digest = sort_by_digest_8_8;
8148 opti_type = OPTI_TYPE_ZERO_BYTE
8149 | OPTI_TYPE_PRECOMPUTE_INIT
8150 | OPTI_TYPE_PRECOMPUTE_MERKLE
8151 | OPTI_TYPE_EARLY_SKIP
8152 | OPTI_TYPE_NOT_ITERATED
8153 | OPTI_TYPE_NOT_SALTED
8154 | OPTI_TYPE_USES_BITS_64
8155 | OPTI_TYPE_RAW_HASH;
8156 dgst_pos0 = 14;
8157 dgst_pos1 = 15;
8158 dgst_pos2 = 6;
8159 dgst_pos3 = 7;
8160 break;
8161
8162 case 1710: hash_type = HASH_TYPE_SHA512;
8163 salt_type = SALT_TYPE_INTERN;
8164 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8165 opts_type = OPTS_TYPE_PT_GENERATE_BE
8166 | OPTS_TYPE_ST_ADD80
8167 | OPTS_TYPE_ST_ADDBITS15;
8168 kern_type = KERN_TYPE_SHA512_PWSLT;
8169 dgst_size = DGST_SIZE_8_8;
8170 parse_func = sha512s_parse_hash;
8171 sort_by_digest = sort_by_digest_8_8;
8172 opti_type = OPTI_TYPE_ZERO_BYTE
8173 | OPTI_TYPE_PRECOMPUTE_INIT
8174 | OPTI_TYPE_PRECOMPUTE_MERKLE
8175 | OPTI_TYPE_EARLY_SKIP
8176 | OPTI_TYPE_NOT_ITERATED
8177 | OPTI_TYPE_APPENDED_SALT
8178 | OPTI_TYPE_USES_BITS_64
8179 | OPTI_TYPE_RAW_HASH;
8180 dgst_pos0 = 14;
8181 dgst_pos1 = 15;
8182 dgst_pos2 = 6;
8183 dgst_pos3 = 7;
8184 break;
8185
8186 case 1711: hash_type = HASH_TYPE_SHA512;
8187 salt_type = SALT_TYPE_EMBEDDED;
8188 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8189 opts_type = OPTS_TYPE_PT_GENERATE_BE
8190 | OPTS_TYPE_ST_ADD80
8191 | OPTS_TYPE_ST_ADDBITS15;
8192 kern_type = KERN_TYPE_SHA512_PWSLT;
8193 dgst_size = DGST_SIZE_8_8;
8194 parse_func = sha512b64s_parse_hash;
8195 sort_by_digest = sort_by_digest_8_8;
8196 opti_type = OPTI_TYPE_ZERO_BYTE
8197 | OPTI_TYPE_PRECOMPUTE_INIT
8198 | OPTI_TYPE_PRECOMPUTE_MERKLE
8199 | OPTI_TYPE_EARLY_SKIP
8200 | OPTI_TYPE_NOT_ITERATED
8201 | OPTI_TYPE_APPENDED_SALT
8202 | OPTI_TYPE_USES_BITS_64
8203 | OPTI_TYPE_RAW_HASH;
8204 dgst_pos0 = 14;
8205 dgst_pos1 = 15;
8206 dgst_pos2 = 6;
8207 dgst_pos3 = 7;
8208 break;
8209
8210 case 1720: hash_type = HASH_TYPE_SHA512;
8211 salt_type = SALT_TYPE_INTERN;
8212 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8213 opts_type = OPTS_TYPE_PT_GENERATE_BE
8214 | OPTS_TYPE_PT_ADD80
8215 | OPTS_TYPE_PT_ADDBITS15;
8216 kern_type = KERN_TYPE_SHA512_SLTPW;
8217 dgst_size = DGST_SIZE_8_8;
8218 parse_func = sha512s_parse_hash;
8219 sort_by_digest = sort_by_digest_8_8;
8220 opti_type = OPTI_TYPE_ZERO_BYTE
8221 | OPTI_TYPE_PRECOMPUTE_INIT
8222 | OPTI_TYPE_PRECOMPUTE_MERKLE
8223 | OPTI_TYPE_EARLY_SKIP
8224 | OPTI_TYPE_NOT_ITERATED
8225 | OPTI_TYPE_PREPENDED_SALT
8226 | OPTI_TYPE_USES_BITS_64
8227 | OPTI_TYPE_RAW_HASH;
8228 dgst_pos0 = 14;
8229 dgst_pos1 = 15;
8230 dgst_pos2 = 6;
8231 dgst_pos3 = 7;
8232 break;
8233
8234 case 1722: hash_type = HASH_TYPE_SHA512;
8235 salt_type = SALT_TYPE_EMBEDDED;
8236 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8237 opts_type = OPTS_TYPE_PT_GENERATE_BE
8238 | OPTS_TYPE_PT_ADD80
8239 | OPTS_TYPE_PT_ADDBITS15
8240 | OPTS_TYPE_ST_HEX;
8241 kern_type = KERN_TYPE_SHA512_SLTPW;
8242 dgst_size = DGST_SIZE_8_8;
8243 parse_func = osx512_parse_hash;
8244 sort_by_digest = sort_by_digest_8_8;
8245 opti_type = OPTI_TYPE_ZERO_BYTE
8246 | OPTI_TYPE_PRECOMPUTE_INIT
8247 | OPTI_TYPE_PRECOMPUTE_MERKLE
8248 | OPTI_TYPE_EARLY_SKIP
8249 | OPTI_TYPE_NOT_ITERATED
8250 | OPTI_TYPE_PREPENDED_SALT
8251 | OPTI_TYPE_USES_BITS_64
8252 | OPTI_TYPE_RAW_HASH;
8253 dgst_pos0 = 14;
8254 dgst_pos1 = 15;
8255 dgst_pos2 = 6;
8256 dgst_pos3 = 7;
8257 break;
8258
8259 case 1730: hash_type = HASH_TYPE_SHA512;
8260 salt_type = SALT_TYPE_INTERN;
8261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8262 opts_type = OPTS_TYPE_PT_GENERATE_BE
8263 | OPTS_TYPE_PT_UNICODE
8264 | OPTS_TYPE_ST_ADD80
8265 | OPTS_TYPE_ST_ADDBITS15;
8266 kern_type = KERN_TYPE_SHA512_PWSLTU;
8267 dgst_size = DGST_SIZE_8_8;
8268 parse_func = sha512s_parse_hash;
8269 sort_by_digest = sort_by_digest_8_8;
8270 opti_type = OPTI_TYPE_ZERO_BYTE
8271 | OPTI_TYPE_PRECOMPUTE_INIT
8272 | OPTI_TYPE_PRECOMPUTE_MERKLE
8273 | OPTI_TYPE_EARLY_SKIP
8274 | OPTI_TYPE_NOT_ITERATED
8275 | OPTI_TYPE_APPENDED_SALT
8276 | OPTI_TYPE_USES_BITS_64
8277 | OPTI_TYPE_RAW_HASH;
8278 dgst_pos0 = 14;
8279 dgst_pos1 = 15;
8280 dgst_pos2 = 6;
8281 dgst_pos3 = 7;
8282 break;
8283
8284 case 1731: hash_type = HASH_TYPE_SHA512;
8285 salt_type = SALT_TYPE_EMBEDDED;
8286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8287 opts_type = OPTS_TYPE_PT_GENERATE_BE
8288 | OPTS_TYPE_PT_UNICODE
8289 | OPTS_TYPE_ST_ADD80
8290 | OPTS_TYPE_ST_ADDBITS15
8291 | OPTS_TYPE_ST_HEX;
8292 kern_type = KERN_TYPE_SHA512_PWSLTU;
8293 dgst_size = DGST_SIZE_8_8;
8294 parse_func = mssql2012_parse_hash;
8295 sort_by_digest = sort_by_digest_8_8;
8296 opti_type = OPTI_TYPE_ZERO_BYTE
8297 | OPTI_TYPE_PRECOMPUTE_INIT
8298 | OPTI_TYPE_PRECOMPUTE_MERKLE
8299 | OPTI_TYPE_EARLY_SKIP
8300 | OPTI_TYPE_NOT_ITERATED
8301 | OPTI_TYPE_APPENDED_SALT
8302 | OPTI_TYPE_USES_BITS_64
8303 | OPTI_TYPE_RAW_HASH;
8304 dgst_pos0 = 14;
8305 dgst_pos1 = 15;
8306 dgst_pos2 = 6;
8307 dgst_pos3 = 7;
8308 break;
8309
8310 case 1740: hash_type = HASH_TYPE_SHA512;
8311 salt_type = SALT_TYPE_INTERN;
8312 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8313 opts_type = OPTS_TYPE_PT_GENERATE_BE
8314 | OPTS_TYPE_PT_ADD80
8315 | OPTS_TYPE_PT_ADDBITS15
8316 | OPTS_TYPE_PT_UNICODE;
8317 kern_type = KERN_TYPE_SHA512_SLTPWU;
8318 dgst_size = DGST_SIZE_8_8;
8319 parse_func = sha512s_parse_hash;
8320 sort_by_digest = sort_by_digest_8_8;
8321 opti_type = OPTI_TYPE_ZERO_BYTE
8322 | OPTI_TYPE_PRECOMPUTE_INIT
8323 | OPTI_TYPE_PRECOMPUTE_MERKLE
8324 | OPTI_TYPE_EARLY_SKIP
8325 | OPTI_TYPE_NOT_ITERATED
8326 | OPTI_TYPE_PREPENDED_SALT
8327 | OPTI_TYPE_USES_BITS_64
8328 | OPTI_TYPE_RAW_HASH;
8329 dgst_pos0 = 14;
8330 dgst_pos1 = 15;
8331 dgst_pos2 = 6;
8332 dgst_pos3 = 7;
8333 break;
8334
8335 case 1750: hash_type = HASH_TYPE_SHA512;
8336 salt_type = SALT_TYPE_INTERN;
8337 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8338 opts_type = OPTS_TYPE_PT_GENERATE_BE
8339 | OPTS_TYPE_ST_ADD80;
8340 kern_type = KERN_TYPE_HMACSHA512_PW;
8341 dgst_size = DGST_SIZE_8_8;
8342 parse_func = hmacsha512_parse_hash;
8343 sort_by_digest = sort_by_digest_8_8;
8344 opti_type = OPTI_TYPE_ZERO_BYTE
8345 | OPTI_TYPE_USES_BITS_64
8346 | OPTI_TYPE_NOT_ITERATED;
8347 dgst_pos0 = 14;
8348 dgst_pos1 = 15;
8349 dgst_pos2 = 6;
8350 dgst_pos3 = 7;
8351 break;
8352
8353 case 1760: hash_type = HASH_TYPE_SHA512;
8354 salt_type = SALT_TYPE_INTERN;
8355 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8356 opts_type = OPTS_TYPE_PT_GENERATE_BE
8357 | OPTS_TYPE_PT_ADD80
8358 | OPTS_TYPE_PT_ADDBITS15;
8359 kern_type = KERN_TYPE_HMACSHA512_SLT;
8360 dgst_size = DGST_SIZE_8_8;
8361 parse_func = hmacsha512_parse_hash;
8362 sort_by_digest = sort_by_digest_8_8;
8363 opti_type = OPTI_TYPE_ZERO_BYTE
8364 | OPTI_TYPE_USES_BITS_64
8365 | OPTI_TYPE_NOT_ITERATED;
8366 dgst_pos0 = 14;
8367 dgst_pos1 = 15;
8368 dgst_pos2 = 6;
8369 dgst_pos3 = 7;
8370 break;
8371
8372 case 1800: hash_type = HASH_TYPE_SHA512;
8373 salt_type = SALT_TYPE_EMBEDDED;
8374 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8375 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8376 kern_type = KERN_TYPE_SHA512CRYPT;
8377 dgst_size = DGST_SIZE_8_8;
8378 parse_func = sha512crypt_parse_hash;
8379 sort_by_digest = sort_by_digest_8_8;
8380 opti_type = OPTI_TYPE_ZERO_BYTE
8381 | OPTI_TYPE_USES_BITS_64;
8382 dgst_pos0 = 0;
8383 dgst_pos1 = 1;
8384 dgst_pos2 = 2;
8385 dgst_pos3 = 3;
8386 break;
8387
8388 case 2100: hash_type = HASH_TYPE_DCC2;
8389 salt_type = SALT_TYPE_EMBEDDED;
8390 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8391 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8392 | OPTS_TYPE_ST_LOWER
8393 | OPTS_TYPE_ST_UNICODE;
8394 kern_type = KERN_TYPE_DCC2;
8395 dgst_size = DGST_SIZE_4_4;
8396 parse_func = dcc2_parse_hash;
8397 sort_by_digest = sort_by_digest_4_4;
8398 opti_type = OPTI_TYPE_ZERO_BYTE
8399 | OPTI_TYPE_SLOW_HASH_SIMD;
8400 dgst_pos0 = 0;
8401 dgst_pos1 = 1;
8402 dgst_pos2 = 2;
8403 dgst_pos3 = 3;
8404 break;
8405
8406 case 2400: hash_type = HASH_TYPE_MD5;
8407 salt_type = SALT_TYPE_NONE;
8408 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8409 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8410 kern_type = KERN_TYPE_MD5PIX;
8411 dgst_size = DGST_SIZE_4_4;
8412 parse_func = md5pix_parse_hash;
8413 sort_by_digest = sort_by_digest_4_4;
8414 opti_type = OPTI_TYPE_ZERO_BYTE
8415 | OPTI_TYPE_PRECOMPUTE_INIT
8416 | OPTI_TYPE_PRECOMPUTE_MERKLE
8417 | OPTI_TYPE_EARLY_SKIP
8418 | OPTI_TYPE_NOT_ITERATED
8419 | OPTI_TYPE_NOT_SALTED;
8420 dgst_pos0 = 0;
8421 dgst_pos1 = 3;
8422 dgst_pos2 = 2;
8423 dgst_pos3 = 1;
8424 break;
8425
8426 case 2410: hash_type = HASH_TYPE_MD5;
8427 salt_type = SALT_TYPE_INTERN;
8428 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8429 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8430 kern_type = KERN_TYPE_MD5ASA;
8431 dgst_size = DGST_SIZE_4_4;
8432 parse_func = md5asa_parse_hash;
8433 sort_by_digest = sort_by_digest_4_4;
8434 opti_type = OPTI_TYPE_ZERO_BYTE
8435 | OPTI_TYPE_PRECOMPUTE_INIT
8436 | OPTI_TYPE_PRECOMPUTE_MERKLE
8437 | OPTI_TYPE_EARLY_SKIP
8438 | OPTI_TYPE_NOT_ITERATED;
8439 dgst_pos0 = 0;
8440 dgst_pos1 = 3;
8441 dgst_pos2 = 2;
8442 dgst_pos3 = 1;
8443 break;
8444
8445 case 2500: hash_type = HASH_TYPE_WPA;
8446 salt_type = SALT_TYPE_EMBEDDED;
8447 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8448 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8449 kern_type = KERN_TYPE_WPA;
8450 dgst_size = DGST_SIZE_4_4;
8451 parse_func = wpa_parse_hash;
8452 sort_by_digest = sort_by_digest_4_4;
8453 opti_type = OPTI_TYPE_ZERO_BYTE
8454 | OPTI_TYPE_SLOW_HASH_SIMD;
8455 dgst_pos0 = 0;
8456 dgst_pos1 = 1;
8457 dgst_pos2 = 2;
8458 dgst_pos3 = 3;
8459 break;
8460
8461 case 2600: hash_type = HASH_TYPE_MD5;
8462 salt_type = SALT_TYPE_VIRTUAL;
8463 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8464 opts_type = OPTS_TYPE_PT_GENERATE_LE
8465 | OPTS_TYPE_PT_ADD80
8466 | OPTS_TYPE_PT_ADDBITS14
8467 | OPTS_TYPE_ST_ADD80;
8468 kern_type = KERN_TYPE_MD55_PWSLT1;
8469 dgst_size = DGST_SIZE_4_4;
8470 parse_func = md5md5_parse_hash;
8471 sort_by_digest = sort_by_digest_4_4;
8472 opti_type = OPTI_TYPE_ZERO_BYTE
8473 | OPTI_TYPE_PRECOMPUTE_INIT
8474 | OPTI_TYPE_PRECOMPUTE_MERKLE
8475 | OPTI_TYPE_EARLY_SKIP;
8476 dgst_pos0 = 0;
8477 dgst_pos1 = 3;
8478 dgst_pos2 = 2;
8479 dgst_pos3 = 1;
8480 break;
8481
8482 case 2611: hash_type = HASH_TYPE_MD5;
8483 salt_type = SALT_TYPE_INTERN;
8484 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8485 opts_type = OPTS_TYPE_PT_GENERATE_LE
8486 | OPTS_TYPE_PT_ADD80
8487 | OPTS_TYPE_PT_ADDBITS14
8488 | OPTS_TYPE_ST_ADD80;
8489 kern_type = KERN_TYPE_MD55_PWSLT1;
8490 dgst_size = DGST_SIZE_4_4;
8491 parse_func = vb3_parse_hash;
8492 sort_by_digest = sort_by_digest_4_4;
8493 opti_type = OPTI_TYPE_ZERO_BYTE
8494 | OPTI_TYPE_PRECOMPUTE_INIT
8495 | OPTI_TYPE_PRECOMPUTE_MERKLE
8496 | OPTI_TYPE_EARLY_SKIP;
8497 dgst_pos0 = 0;
8498 dgst_pos1 = 3;
8499 dgst_pos2 = 2;
8500 dgst_pos3 = 1;
8501 break;
8502
8503 case 2612: hash_type = HASH_TYPE_MD5;
8504 salt_type = SALT_TYPE_EMBEDDED;
8505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8506 opts_type = OPTS_TYPE_PT_GENERATE_LE
8507 | OPTS_TYPE_PT_ADD80
8508 | OPTS_TYPE_PT_ADDBITS14
8509 | OPTS_TYPE_ST_ADD80
8510 | OPTS_TYPE_ST_HEX;
8511 kern_type = KERN_TYPE_MD55_PWSLT1;
8512 dgst_size = DGST_SIZE_4_4;
8513 parse_func = phps_parse_hash;
8514 sort_by_digest = sort_by_digest_4_4;
8515 opti_type = OPTI_TYPE_ZERO_BYTE
8516 | OPTI_TYPE_PRECOMPUTE_INIT
8517 | OPTI_TYPE_PRECOMPUTE_MERKLE
8518 | OPTI_TYPE_EARLY_SKIP;
8519 dgst_pos0 = 0;
8520 dgst_pos1 = 3;
8521 dgst_pos2 = 2;
8522 dgst_pos3 = 1;
8523 break;
8524
8525 case 2711: hash_type = HASH_TYPE_MD5;
8526 salt_type = SALT_TYPE_INTERN;
8527 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8528 opts_type = OPTS_TYPE_PT_GENERATE_LE
8529 | OPTS_TYPE_PT_ADD80
8530 | OPTS_TYPE_PT_ADDBITS14
8531 | OPTS_TYPE_ST_ADD80;
8532 kern_type = KERN_TYPE_MD55_PWSLT2;
8533 dgst_size = DGST_SIZE_4_4;
8534 parse_func = vb30_parse_hash;
8535 sort_by_digest = sort_by_digest_4_4;
8536 opti_type = OPTI_TYPE_ZERO_BYTE
8537 | OPTI_TYPE_PRECOMPUTE_INIT
8538 | OPTI_TYPE_EARLY_SKIP;
8539 dgst_pos0 = 0;
8540 dgst_pos1 = 3;
8541 dgst_pos2 = 2;
8542 dgst_pos3 = 1;
8543 break;
8544
8545 case 2811: hash_type = HASH_TYPE_MD5;
8546 salt_type = SALT_TYPE_INTERN;
8547 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8548 opts_type = OPTS_TYPE_PT_GENERATE_LE
8549 | OPTS_TYPE_PT_ADD80
8550 | OPTS_TYPE_PT_ADDBITS14;
8551 kern_type = KERN_TYPE_MD55_SLTPW;
8552 dgst_size = DGST_SIZE_4_4;
8553 parse_func = ipb2_parse_hash;
8554 sort_by_digest = sort_by_digest_4_4;
8555 opti_type = OPTI_TYPE_ZERO_BYTE
8556 | OPTI_TYPE_PRECOMPUTE_INIT
8557 | OPTI_TYPE_EARLY_SKIP;
8558 dgst_pos0 = 0;
8559 dgst_pos1 = 3;
8560 dgst_pos2 = 2;
8561 dgst_pos3 = 1;
8562 break;
8563
8564 case 3000: hash_type = HASH_TYPE_LM;
8565 salt_type = SALT_TYPE_NONE;
8566 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8567 opts_type = OPTS_TYPE_PT_GENERATE_LE
8568 | OPTS_TYPE_PT_UPPER
8569 | OPTS_TYPE_PT_BITSLICE;
8570 kern_type = KERN_TYPE_LM;
8571 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8572 parse_func = lm_parse_hash;
8573 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8574 opti_type = OPTI_TYPE_ZERO_BYTE
8575 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8576 dgst_pos0 = 0;
8577 dgst_pos1 = 1;
8578 dgst_pos2 = 2;
8579 dgst_pos3 = 3;
8580 break;
8581
8582 case 3100: hash_type = HASH_TYPE_ORACLEH;
8583 salt_type = SALT_TYPE_INTERN;
8584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8585 opts_type = OPTS_TYPE_PT_GENERATE_LE
8586 | OPTS_TYPE_PT_UPPER
8587 | OPTS_TYPE_ST_UPPER;
8588 kern_type = KERN_TYPE_ORACLEH;
8589 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8590 parse_func = oracleh_parse_hash;
8591 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8592 opti_type = OPTI_TYPE_ZERO_BYTE;
8593 dgst_pos0 = 0;
8594 dgst_pos1 = 1;
8595 dgst_pos2 = 2;
8596 dgst_pos3 = 3;
8597 break;
8598
8599 case 3200: hash_type = HASH_TYPE_BCRYPT;
8600 salt_type = SALT_TYPE_EMBEDDED;
8601 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8602 opts_type = OPTS_TYPE_PT_GENERATE_LE
8603 | OPTS_TYPE_ST_GENERATE_LE;
8604 kern_type = KERN_TYPE_BCRYPT;
8605 dgst_size = DGST_SIZE_4_6;
8606 parse_func = bcrypt_parse_hash;
8607 sort_by_digest = sort_by_digest_4_6;
8608 opti_type = OPTI_TYPE_ZERO_BYTE;
8609 dgst_pos0 = 0;
8610 dgst_pos1 = 1;
8611 dgst_pos2 = 2;
8612 dgst_pos3 = 3;
8613 break;
8614
8615 case 3710: hash_type = HASH_TYPE_MD5;
8616 salt_type = SALT_TYPE_INTERN;
8617 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8618 opts_type = OPTS_TYPE_PT_GENERATE_LE
8619 | OPTS_TYPE_PT_ADD80
8620 | OPTS_TYPE_PT_ADDBITS14;
8621 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8622 dgst_size = DGST_SIZE_4_4;
8623 parse_func = md5s_parse_hash;
8624 sort_by_digest = sort_by_digest_4_4;
8625 opti_type = OPTI_TYPE_ZERO_BYTE
8626 | OPTI_TYPE_PRECOMPUTE_INIT
8627 | OPTI_TYPE_PRECOMPUTE_MERKLE
8628 | OPTI_TYPE_EARLY_SKIP;
8629 dgst_pos0 = 0;
8630 dgst_pos1 = 3;
8631 dgst_pos2 = 2;
8632 dgst_pos3 = 1;
8633 break;
8634
8635 case 3711: hash_type = HASH_TYPE_MD5;
8636 salt_type = SALT_TYPE_EMBEDDED;
8637 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8638 opts_type = OPTS_TYPE_PT_GENERATE_LE
8639 | OPTS_TYPE_PT_ADD80
8640 | OPTS_TYPE_PT_ADDBITS14;
8641 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8642 dgst_size = DGST_SIZE_4_4;
8643 parse_func = mediawiki_b_parse_hash;
8644 sort_by_digest = sort_by_digest_4_4;
8645 opti_type = OPTI_TYPE_ZERO_BYTE
8646 | OPTI_TYPE_PRECOMPUTE_INIT
8647 | OPTI_TYPE_PRECOMPUTE_MERKLE
8648 | OPTI_TYPE_EARLY_SKIP;
8649 dgst_pos0 = 0;
8650 dgst_pos1 = 3;
8651 dgst_pos2 = 2;
8652 dgst_pos3 = 1;
8653 break;
8654
8655 case 3800: hash_type = HASH_TYPE_MD5;
8656 salt_type = SALT_TYPE_INTERN;
8657 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8658 opts_type = OPTS_TYPE_PT_GENERATE_LE
8659 | OPTS_TYPE_ST_ADDBITS14;
8660 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8661 dgst_size = DGST_SIZE_4_4;
8662 parse_func = md5s_parse_hash;
8663 sort_by_digest = sort_by_digest_4_4;
8664 opti_type = OPTI_TYPE_ZERO_BYTE
8665 | OPTI_TYPE_PRECOMPUTE_INIT
8666 | OPTI_TYPE_PRECOMPUTE_MERKLE
8667 | OPTI_TYPE_EARLY_SKIP
8668 | OPTI_TYPE_NOT_ITERATED
8669 | OPTI_TYPE_RAW_HASH;
8670 dgst_pos0 = 0;
8671 dgst_pos1 = 3;
8672 dgst_pos2 = 2;
8673 dgst_pos3 = 1;
8674 break;
8675
8676 case 4300: hash_type = HASH_TYPE_MD5;
8677 salt_type = SALT_TYPE_VIRTUAL;
8678 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8679 opts_type = OPTS_TYPE_PT_GENERATE_LE
8680 | OPTS_TYPE_PT_ADD80
8681 | OPTS_TYPE_PT_ADDBITS14
8682 | OPTS_TYPE_ST_ADD80;
8683 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8684 dgst_size = DGST_SIZE_4_4;
8685 parse_func = md5md5_parse_hash;
8686 sort_by_digest = sort_by_digest_4_4;
8687 opti_type = OPTI_TYPE_ZERO_BYTE
8688 | OPTI_TYPE_PRECOMPUTE_INIT
8689 | OPTI_TYPE_PRECOMPUTE_MERKLE
8690 | OPTI_TYPE_EARLY_SKIP;
8691 dgst_pos0 = 0;
8692 dgst_pos1 = 3;
8693 dgst_pos2 = 2;
8694 dgst_pos3 = 1;
8695 break;
8696
8697
8698 case 4400: hash_type = HASH_TYPE_MD5;
8699 salt_type = SALT_TYPE_NONE;
8700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8701 opts_type = OPTS_TYPE_PT_GENERATE_BE
8702 | OPTS_TYPE_PT_ADD80
8703 | OPTS_TYPE_PT_ADDBITS15;
8704 kern_type = KERN_TYPE_MD5_SHA1;
8705 dgst_size = DGST_SIZE_4_4;
8706 parse_func = md5_parse_hash;
8707 sort_by_digest = sort_by_digest_4_4;
8708 opti_type = OPTI_TYPE_ZERO_BYTE
8709 | OPTI_TYPE_PRECOMPUTE_INIT
8710 | OPTI_TYPE_PRECOMPUTE_MERKLE
8711 | OPTI_TYPE_EARLY_SKIP
8712 | OPTI_TYPE_NOT_ITERATED
8713 | OPTI_TYPE_NOT_SALTED
8714 | OPTI_TYPE_RAW_HASH;
8715 dgst_pos0 = 0;
8716 dgst_pos1 = 3;
8717 dgst_pos2 = 2;
8718 dgst_pos3 = 1;
8719 break;
8720
8721 case 4500: hash_type = HASH_TYPE_SHA1;
8722 salt_type = SALT_TYPE_NONE;
8723 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8724 opts_type = OPTS_TYPE_PT_GENERATE_BE
8725 | OPTS_TYPE_PT_ADD80
8726 | OPTS_TYPE_PT_ADDBITS15;
8727 kern_type = KERN_TYPE_SHA11;
8728 dgst_size = DGST_SIZE_4_5;
8729 parse_func = sha1_parse_hash;
8730 sort_by_digest = sort_by_digest_4_5;
8731 opti_type = OPTI_TYPE_ZERO_BYTE
8732 | OPTI_TYPE_PRECOMPUTE_INIT
8733 | OPTI_TYPE_PRECOMPUTE_MERKLE
8734 | OPTI_TYPE_EARLY_SKIP
8735 | OPTI_TYPE_NOT_SALTED;
8736 dgst_pos0 = 3;
8737 dgst_pos1 = 4;
8738 dgst_pos2 = 2;
8739 dgst_pos3 = 1;
8740 break;
8741
8742 case 4700: hash_type = HASH_TYPE_SHA1;
8743 salt_type = SALT_TYPE_NONE;
8744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8745 opts_type = OPTS_TYPE_PT_GENERATE_LE
8746 | OPTS_TYPE_PT_ADD80
8747 | OPTS_TYPE_PT_ADDBITS14;
8748 kern_type = KERN_TYPE_SHA1_MD5;
8749 dgst_size = DGST_SIZE_4_5;
8750 parse_func = sha1_parse_hash;
8751 sort_by_digest = sort_by_digest_4_5;
8752 opti_type = OPTI_TYPE_ZERO_BYTE
8753 | OPTI_TYPE_PRECOMPUTE_INIT
8754 | OPTI_TYPE_PRECOMPUTE_MERKLE
8755 | OPTI_TYPE_EARLY_SKIP
8756 | OPTI_TYPE_NOT_ITERATED
8757 | OPTI_TYPE_NOT_SALTED
8758 | OPTI_TYPE_RAW_HASH;
8759 dgst_pos0 = 3;
8760 dgst_pos1 = 4;
8761 dgst_pos2 = 2;
8762 dgst_pos3 = 1;
8763 break;
8764
8765 case 4800: hash_type = HASH_TYPE_MD5;
8766 salt_type = SALT_TYPE_EMBEDDED;
8767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8768 opts_type = OPTS_TYPE_PT_GENERATE_LE
8769 | OPTS_TYPE_PT_ADDBITS14;
8770 kern_type = KERN_TYPE_MD5_CHAP;
8771 dgst_size = DGST_SIZE_4_4;
8772 parse_func = chap_parse_hash;
8773 sort_by_digest = sort_by_digest_4_4;
8774 opti_type = OPTI_TYPE_ZERO_BYTE
8775 | OPTI_TYPE_PRECOMPUTE_INIT
8776 | OPTI_TYPE_PRECOMPUTE_MERKLE
8777 | OPTI_TYPE_MEET_IN_MIDDLE
8778 | OPTI_TYPE_EARLY_SKIP
8779 | OPTI_TYPE_NOT_ITERATED
8780 | OPTI_TYPE_RAW_HASH;
8781 dgst_pos0 = 0;
8782 dgst_pos1 = 3;
8783 dgst_pos2 = 2;
8784 dgst_pos3 = 1;
8785 break;
8786
8787 case 4900: hash_type = HASH_TYPE_SHA1;
8788 salt_type = SALT_TYPE_INTERN;
8789 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8790 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8791 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8792 dgst_size = DGST_SIZE_4_5;
8793 parse_func = sha1s_parse_hash;
8794 sort_by_digest = sort_by_digest_4_5;
8795 opti_type = OPTI_TYPE_ZERO_BYTE
8796 | OPTI_TYPE_PRECOMPUTE_INIT
8797 | OPTI_TYPE_PRECOMPUTE_MERKLE
8798 | OPTI_TYPE_EARLY_SKIP;
8799 dgst_pos0 = 3;
8800 dgst_pos1 = 4;
8801 dgst_pos2 = 2;
8802 dgst_pos3 = 1;
8803 break;
8804
8805 case 5000: hash_type = HASH_TYPE_KECCAK;
8806 salt_type = SALT_TYPE_EMBEDDED;
8807 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8808 opts_type = OPTS_TYPE_PT_GENERATE_LE
8809 | OPTS_TYPE_PT_ADD01;
8810 kern_type = KERN_TYPE_KECCAK;
8811 dgst_size = DGST_SIZE_8_25;
8812 parse_func = keccak_parse_hash;
8813 sort_by_digest = sort_by_digest_8_25;
8814 opti_type = OPTI_TYPE_ZERO_BYTE
8815 | OPTI_TYPE_USES_BITS_64
8816 | OPTI_TYPE_RAW_HASH;
8817 dgst_pos0 = 2;
8818 dgst_pos1 = 3;
8819 dgst_pos2 = 4;
8820 dgst_pos3 = 5;
8821 break;
8822
8823 case 5100: hash_type = HASH_TYPE_MD5H;
8824 salt_type = SALT_TYPE_NONE;
8825 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8826 opts_type = OPTS_TYPE_PT_GENERATE_LE
8827 | OPTS_TYPE_PT_ADD80
8828 | OPTS_TYPE_PT_ADDBITS14;
8829 kern_type = KERN_TYPE_MD5H;
8830 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8831 parse_func = md5half_parse_hash;
8832 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8833 opti_type = OPTI_TYPE_ZERO_BYTE
8834 | OPTI_TYPE_RAW_HASH;
8835 dgst_pos0 = 0;
8836 dgst_pos1 = 1;
8837 dgst_pos2 = 2;
8838 dgst_pos3 = 3;
8839 break;
8840
8841 case 5200: hash_type = HASH_TYPE_SHA256;
8842 salt_type = SALT_TYPE_EMBEDDED;
8843 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8844 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8845 kern_type = KERN_TYPE_PSAFE3;
8846 dgst_size = DGST_SIZE_4_8;
8847 parse_func = psafe3_parse_hash;
8848 sort_by_digest = sort_by_digest_4_8;
8849 opti_type = OPTI_TYPE_ZERO_BYTE;
8850 dgst_pos0 = 0;
8851 dgst_pos1 = 1;
8852 dgst_pos2 = 2;
8853 dgst_pos3 = 3;
8854 break;
8855
8856 case 5300: hash_type = HASH_TYPE_MD5;
8857 salt_type = SALT_TYPE_EMBEDDED;
8858 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8859 opts_type = OPTS_TYPE_PT_GENERATE_LE
8860 | OPTS_TYPE_ST_ADD80;
8861 kern_type = KERN_TYPE_IKEPSK_MD5;
8862 dgst_size = DGST_SIZE_4_4;
8863 parse_func = ikepsk_md5_parse_hash;
8864 sort_by_digest = sort_by_digest_4_4;
8865 opti_type = OPTI_TYPE_ZERO_BYTE;
8866 dgst_pos0 = 0;
8867 dgst_pos1 = 3;
8868 dgst_pos2 = 2;
8869 dgst_pos3 = 1;
8870 break;
8871
8872 case 5400: hash_type = HASH_TYPE_SHA1;
8873 salt_type = SALT_TYPE_EMBEDDED;
8874 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8875 opts_type = OPTS_TYPE_PT_GENERATE_BE
8876 | OPTS_TYPE_ST_ADD80;
8877 kern_type = KERN_TYPE_IKEPSK_SHA1;
8878 dgst_size = DGST_SIZE_4_5;
8879 parse_func = ikepsk_sha1_parse_hash;
8880 sort_by_digest = sort_by_digest_4_5;
8881 opti_type = OPTI_TYPE_ZERO_BYTE;
8882 dgst_pos0 = 3;
8883 dgst_pos1 = 4;
8884 dgst_pos2 = 2;
8885 dgst_pos3 = 1;
8886 break;
8887
8888 case 5500: hash_type = HASH_TYPE_NETNTLM;
8889 salt_type = SALT_TYPE_EMBEDDED;
8890 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8891 opts_type = OPTS_TYPE_PT_GENERATE_LE
8892 | OPTS_TYPE_PT_ADD80
8893 | OPTS_TYPE_PT_ADDBITS14
8894 | OPTS_TYPE_PT_UNICODE
8895 | OPTS_TYPE_ST_HEX;
8896 kern_type = KERN_TYPE_NETNTLMv1;
8897 dgst_size = DGST_SIZE_4_4;
8898 parse_func = netntlmv1_parse_hash;
8899 sort_by_digest = sort_by_digest_4_4;
8900 opti_type = OPTI_TYPE_ZERO_BYTE
8901 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8902 dgst_pos0 = 0;
8903 dgst_pos1 = 1;
8904 dgst_pos2 = 2;
8905 dgst_pos3 = 3;
8906 break;
8907
8908 case 5600: hash_type = HASH_TYPE_MD5;
8909 salt_type = SALT_TYPE_EMBEDDED;
8910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8911 opts_type = OPTS_TYPE_PT_GENERATE_LE
8912 | OPTS_TYPE_PT_ADD80
8913 | OPTS_TYPE_PT_ADDBITS14
8914 | OPTS_TYPE_PT_UNICODE;
8915 kern_type = KERN_TYPE_NETNTLMv2;
8916 dgst_size = DGST_SIZE_4_4;
8917 parse_func = netntlmv2_parse_hash;
8918 sort_by_digest = sort_by_digest_4_4;
8919 opti_type = OPTI_TYPE_ZERO_BYTE;
8920 dgst_pos0 = 0;
8921 dgst_pos1 = 3;
8922 dgst_pos2 = 2;
8923 dgst_pos3 = 1;
8924 break;
8925
8926 case 5700: hash_type = HASH_TYPE_SHA256;
8927 salt_type = SALT_TYPE_NONE;
8928 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8929 opts_type = OPTS_TYPE_PT_GENERATE_BE
8930 | OPTS_TYPE_PT_ADD80
8931 | OPTS_TYPE_PT_ADDBITS15;
8932 kern_type = KERN_TYPE_SHA256;
8933 dgst_size = DGST_SIZE_4_8;
8934 parse_func = cisco4_parse_hash;
8935 sort_by_digest = sort_by_digest_4_8;
8936 opti_type = OPTI_TYPE_ZERO_BYTE
8937 | OPTI_TYPE_PRECOMPUTE_INIT
8938 | OPTI_TYPE_PRECOMPUTE_MERKLE
8939 | OPTI_TYPE_EARLY_SKIP
8940 | OPTI_TYPE_NOT_ITERATED
8941 | OPTI_TYPE_NOT_SALTED
8942 | OPTI_TYPE_RAW_HASH;
8943 dgst_pos0 = 3;
8944 dgst_pos1 = 7;
8945 dgst_pos2 = 2;
8946 dgst_pos3 = 6;
8947 break;
8948
8949 case 5800: hash_type = HASH_TYPE_SHA1;
8950 salt_type = SALT_TYPE_INTERN;
8951 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8952 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8953 | OPTS_TYPE_ST_ADD80;
8954 kern_type = KERN_TYPE_ANDROIDPIN;
8955 dgst_size = DGST_SIZE_4_5;
8956 parse_func = androidpin_parse_hash;
8957 sort_by_digest = sort_by_digest_4_5;
8958 opti_type = OPTI_TYPE_ZERO_BYTE;
8959 dgst_pos0 = 0;
8960 dgst_pos1 = 1;
8961 dgst_pos2 = 2;
8962 dgst_pos3 = 3;
8963 break;
8964
8965 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8966 salt_type = SALT_TYPE_NONE;
8967 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8968 opts_type = OPTS_TYPE_PT_GENERATE_LE
8969 | OPTS_TYPE_PT_ADD80;
8970 kern_type = KERN_TYPE_RIPEMD160;
8971 dgst_size = DGST_SIZE_4_5;
8972 parse_func = ripemd160_parse_hash;
8973 sort_by_digest = sort_by_digest_4_5;
8974 opti_type = OPTI_TYPE_ZERO_BYTE;
8975 dgst_pos0 = 0;
8976 dgst_pos1 = 1;
8977 dgst_pos2 = 2;
8978 dgst_pos3 = 3;
8979 break;
8980
8981 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8982 salt_type = SALT_TYPE_NONE;
8983 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8984 opts_type = OPTS_TYPE_PT_GENERATE_BE
8985 | OPTS_TYPE_PT_ADD80;
8986 kern_type = KERN_TYPE_WHIRLPOOL;
8987 dgst_size = DGST_SIZE_4_16;
8988 parse_func = whirlpool_parse_hash;
8989 sort_by_digest = sort_by_digest_4_16;
8990 opti_type = OPTI_TYPE_ZERO_BYTE;
8991 dgst_pos0 = 0;
8992 dgst_pos1 = 1;
8993 dgst_pos2 = 2;
8994 dgst_pos3 = 3;
8995 break;
8996
8997 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8998 salt_type = SALT_TYPE_EMBEDDED;
8999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9000 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9001 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9002 dgst_size = DGST_SIZE_4_5;
9003 parse_func = truecrypt_parse_hash_2k;
9004 sort_by_digest = sort_by_digest_4_5;
9005 opti_type = OPTI_TYPE_ZERO_BYTE;
9006 dgst_pos0 = 0;
9007 dgst_pos1 = 1;
9008 dgst_pos2 = 2;
9009 dgst_pos3 = 3;
9010 break;
9011
9012 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9013 salt_type = SALT_TYPE_EMBEDDED;
9014 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9015 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9016 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9017 dgst_size = DGST_SIZE_4_5;
9018 parse_func = truecrypt_parse_hash_2k;
9019 sort_by_digest = sort_by_digest_4_5;
9020 opti_type = OPTI_TYPE_ZERO_BYTE;
9021 dgst_pos0 = 0;
9022 dgst_pos1 = 1;
9023 dgst_pos2 = 2;
9024 dgst_pos3 = 3;
9025 break;
9026
9027 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9028 salt_type = SALT_TYPE_EMBEDDED;
9029 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9030 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9031 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9032 dgst_size = DGST_SIZE_4_5;
9033 parse_func = truecrypt_parse_hash_2k;
9034 sort_by_digest = sort_by_digest_4_5;
9035 opti_type = OPTI_TYPE_ZERO_BYTE;
9036 dgst_pos0 = 0;
9037 dgst_pos1 = 1;
9038 dgst_pos2 = 2;
9039 dgst_pos3 = 3;
9040 break;
9041
9042 case 6221: hash_type = HASH_TYPE_SHA512;
9043 salt_type = SALT_TYPE_EMBEDDED;
9044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9045 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9046 kern_type = KERN_TYPE_TCSHA512_XTS512;
9047 dgst_size = DGST_SIZE_8_8;
9048 parse_func = truecrypt_parse_hash_1k;
9049 sort_by_digest = sort_by_digest_8_8;
9050 opti_type = OPTI_TYPE_ZERO_BYTE
9051 | OPTI_TYPE_USES_BITS_64;
9052 dgst_pos0 = 0;
9053 dgst_pos1 = 1;
9054 dgst_pos2 = 2;
9055 dgst_pos3 = 3;
9056 break;
9057
9058 case 6222: hash_type = HASH_TYPE_SHA512;
9059 salt_type = SALT_TYPE_EMBEDDED;
9060 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9061 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9062 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9063 dgst_size = DGST_SIZE_8_8;
9064 parse_func = truecrypt_parse_hash_1k;
9065 sort_by_digest = sort_by_digest_8_8;
9066 opti_type = OPTI_TYPE_ZERO_BYTE
9067 | OPTI_TYPE_USES_BITS_64;
9068 dgst_pos0 = 0;
9069 dgst_pos1 = 1;
9070 dgst_pos2 = 2;
9071 dgst_pos3 = 3;
9072 break;
9073
9074 case 6223: hash_type = HASH_TYPE_SHA512;
9075 salt_type = SALT_TYPE_EMBEDDED;
9076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9077 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9078 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9079 dgst_size = DGST_SIZE_8_8;
9080 parse_func = truecrypt_parse_hash_1k;
9081 sort_by_digest = sort_by_digest_8_8;
9082 opti_type = OPTI_TYPE_ZERO_BYTE
9083 | OPTI_TYPE_USES_BITS_64;
9084 dgst_pos0 = 0;
9085 dgst_pos1 = 1;
9086 dgst_pos2 = 2;
9087 dgst_pos3 = 3;
9088 break;
9089
9090 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9091 salt_type = SALT_TYPE_EMBEDDED;
9092 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9093 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9094 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9095 dgst_size = DGST_SIZE_4_8;
9096 parse_func = truecrypt_parse_hash_1k;
9097 sort_by_digest = sort_by_digest_4_8;
9098 opti_type = OPTI_TYPE_ZERO_BYTE;
9099 dgst_pos0 = 0;
9100 dgst_pos1 = 1;
9101 dgst_pos2 = 2;
9102 dgst_pos3 = 3;
9103 break;
9104
9105 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9106 salt_type = SALT_TYPE_EMBEDDED;
9107 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9108 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9109 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9110 dgst_size = DGST_SIZE_4_8;
9111 parse_func = truecrypt_parse_hash_1k;
9112 sort_by_digest = sort_by_digest_4_8;
9113 opti_type = OPTI_TYPE_ZERO_BYTE;
9114 dgst_pos0 = 0;
9115 dgst_pos1 = 1;
9116 dgst_pos2 = 2;
9117 dgst_pos3 = 3;
9118 break;
9119
9120 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9121 salt_type = SALT_TYPE_EMBEDDED;
9122 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9123 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9124 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9125 dgst_size = DGST_SIZE_4_8;
9126 parse_func = truecrypt_parse_hash_1k;
9127 sort_by_digest = sort_by_digest_4_8;
9128 opti_type = OPTI_TYPE_ZERO_BYTE;
9129 dgst_pos0 = 0;
9130 dgst_pos1 = 1;
9131 dgst_pos2 = 2;
9132 dgst_pos3 = 3;
9133 break;
9134
9135 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9136 salt_type = SALT_TYPE_EMBEDDED;
9137 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9138 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9139 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9140 dgst_size = DGST_SIZE_4_5;
9141 parse_func = truecrypt_parse_hash_1k;
9142 sort_by_digest = sort_by_digest_4_5;
9143 opti_type = OPTI_TYPE_ZERO_BYTE;
9144 dgst_pos0 = 0;
9145 dgst_pos1 = 1;
9146 dgst_pos2 = 2;
9147 dgst_pos3 = 3;
9148 break;
9149
9150 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9151 salt_type = SALT_TYPE_EMBEDDED;
9152 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9153 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9154 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9155 dgst_size = DGST_SIZE_4_5;
9156 parse_func = truecrypt_parse_hash_1k;
9157 sort_by_digest = sort_by_digest_4_5;
9158 opti_type = OPTI_TYPE_ZERO_BYTE;
9159 dgst_pos0 = 0;
9160 dgst_pos1 = 1;
9161 dgst_pos2 = 2;
9162 dgst_pos3 = 3;
9163 break;
9164
9165 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9166 salt_type = SALT_TYPE_EMBEDDED;
9167 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9168 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9169 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9170 dgst_size = DGST_SIZE_4_5;
9171 parse_func = truecrypt_parse_hash_1k;
9172 sort_by_digest = sort_by_digest_4_5;
9173 opti_type = OPTI_TYPE_ZERO_BYTE;
9174 dgst_pos0 = 0;
9175 dgst_pos1 = 1;
9176 dgst_pos2 = 2;
9177 dgst_pos3 = 3;
9178 break;
9179
9180 case 6300: hash_type = HASH_TYPE_MD5;
9181 salt_type = SALT_TYPE_EMBEDDED;
9182 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9183 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9184 kern_type = KERN_TYPE_MD5AIX;
9185 dgst_size = DGST_SIZE_4_4;
9186 parse_func = md5aix_parse_hash;
9187 sort_by_digest = sort_by_digest_4_4;
9188 opti_type = OPTI_TYPE_ZERO_BYTE;
9189 dgst_pos0 = 0;
9190 dgst_pos1 = 1;
9191 dgst_pos2 = 2;
9192 dgst_pos3 = 3;
9193 break;
9194
9195 case 6400: hash_type = HASH_TYPE_SHA256;
9196 salt_type = SALT_TYPE_EMBEDDED;
9197 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9198 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9199 kern_type = KERN_TYPE_SHA256AIX;
9200 dgst_size = DGST_SIZE_4_8;
9201 parse_func = sha256aix_parse_hash;
9202 sort_by_digest = sort_by_digest_4_8;
9203 opti_type = OPTI_TYPE_ZERO_BYTE;
9204 dgst_pos0 = 0;
9205 dgst_pos1 = 1;
9206 dgst_pos2 = 2;
9207 dgst_pos3 = 3;
9208 break;
9209
9210 case 6500: hash_type = HASH_TYPE_SHA512;
9211 salt_type = SALT_TYPE_EMBEDDED;
9212 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9213 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9214 kern_type = KERN_TYPE_SHA512AIX;
9215 dgst_size = DGST_SIZE_8_8;
9216 parse_func = sha512aix_parse_hash;
9217 sort_by_digest = sort_by_digest_8_8;
9218 opti_type = OPTI_TYPE_ZERO_BYTE
9219 | OPTI_TYPE_USES_BITS_64;
9220 dgst_pos0 = 0;
9221 dgst_pos1 = 1;
9222 dgst_pos2 = 2;
9223 dgst_pos3 = 3;
9224 break;
9225
9226 case 6600: hash_type = HASH_TYPE_AES;
9227 salt_type = SALT_TYPE_EMBEDDED;
9228 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9229 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9230 kern_type = KERN_TYPE_AGILEKEY;
9231 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9232 parse_func = agilekey_parse_hash;
9233 sort_by_digest = sort_by_digest_4_5;
9234 opti_type = OPTI_TYPE_ZERO_BYTE;
9235 dgst_pos0 = 0;
9236 dgst_pos1 = 1;
9237 dgst_pos2 = 2;
9238 dgst_pos3 = 3;
9239 break;
9240
9241 case 6700: hash_type = HASH_TYPE_SHA1;
9242 salt_type = SALT_TYPE_EMBEDDED;
9243 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9244 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9245 kern_type = KERN_TYPE_SHA1AIX;
9246 dgst_size = DGST_SIZE_4_5;
9247 parse_func = sha1aix_parse_hash;
9248 sort_by_digest = sort_by_digest_4_5;
9249 opti_type = OPTI_TYPE_ZERO_BYTE;
9250 dgst_pos0 = 0;
9251 dgst_pos1 = 1;
9252 dgst_pos2 = 2;
9253 dgst_pos3 = 3;
9254 break;
9255
9256 case 6800: hash_type = HASH_TYPE_AES;
9257 salt_type = SALT_TYPE_EMBEDDED;
9258 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9259 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9260 kern_type = KERN_TYPE_LASTPASS;
9261 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9262 parse_func = lastpass_parse_hash;
9263 sort_by_digest = sort_by_digest_4_8;
9264 opti_type = OPTI_TYPE_ZERO_BYTE;
9265 dgst_pos0 = 0;
9266 dgst_pos1 = 1;
9267 dgst_pos2 = 2;
9268 dgst_pos3 = 3;
9269 break;
9270
9271 case 6900: hash_type = HASH_TYPE_GOST;
9272 salt_type = SALT_TYPE_NONE;
9273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9274 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9275 kern_type = KERN_TYPE_GOST;
9276 dgst_size = DGST_SIZE_4_8;
9277 parse_func = gost_parse_hash;
9278 sort_by_digest = sort_by_digest_4_8;
9279 opti_type = OPTI_TYPE_ZERO_BYTE;
9280 dgst_pos0 = 0;
9281 dgst_pos1 = 1;
9282 dgst_pos2 = 2;
9283 dgst_pos3 = 3;
9284 break;
9285
9286 case 7100: hash_type = HASH_TYPE_SHA512;
9287 salt_type = SALT_TYPE_EMBEDDED;
9288 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9289 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9290 kern_type = KERN_TYPE_PBKDF2_SHA512;
9291 dgst_size = DGST_SIZE_8_16;
9292 parse_func = sha512osx_parse_hash;
9293 sort_by_digest = sort_by_digest_8_16;
9294 opti_type = OPTI_TYPE_ZERO_BYTE
9295 | OPTI_TYPE_USES_BITS_64
9296 | OPTI_TYPE_SLOW_HASH_SIMD;
9297 dgst_pos0 = 0;
9298 dgst_pos1 = 1;
9299 dgst_pos2 = 2;
9300 dgst_pos3 = 3;
9301 break;
9302
9303 case 7200: hash_type = HASH_TYPE_SHA512;
9304 salt_type = SALT_TYPE_EMBEDDED;
9305 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9306 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9307 kern_type = KERN_TYPE_PBKDF2_SHA512;
9308 dgst_size = DGST_SIZE_8_16;
9309 parse_func = sha512grub_parse_hash;
9310 sort_by_digest = sort_by_digest_8_16;
9311 opti_type = OPTI_TYPE_ZERO_BYTE
9312 | OPTI_TYPE_USES_BITS_64
9313 | OPTI_TYPE_SLOW_HASH_SIMD;
9314 dgst_pos0 = 0;
9315 dgst_pos1 = 1;
9316 dgst_pos2 = 2;
9317 dgst_pos3 = 3;
9318 break;
9319
9320 case 7300: hash_type = HASH_TYPE_SHA1;
9321 salt_type = SALT_TYPE_EMBEDDED;
9322 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9323 opts_type = OPTS_TYPE_PT_GENERATE_BE
9324 | OPTS_TYPE_ST_ADD80
9325 | OPTS_TYPE_ST_ADDBITS15;
9326 kern_type = KERN_TYPE_RAKP;
9327 dgst_size = DGST_SIZE_4_5;
9328 parse_func = rakp_parse_hash;
9329 sort_by_digest = sort_by_digest_4_5;
9330 opti_type = OPTI_TYPE_ZERO_BYTE
9331 | OPTI_TYPE_NOT_ITERATED;
9332 dgst_pos0 = 3;
9333 dgst_pos1 = 4;
9334 dgst_pos2 = 2;
9335 dgst_pos3 = 1;
9336 break;
9337
9338 case 7400: hash_type = HASH_TYPE_SHA256;
9339 salt_type = SALT_TYPE_EMBEDDED;
9340 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9341 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9342 kern_type = KERN_TYPE_SHA256CRYPT;
9343 dgst_size = DGST_SIZE_4_8;
9344 parse_func = sha256crypt_parse_hash;
9345 sort_by_digest = sort_by_digest_4_8;
9346 opti_type = OPTI_TYPE_ZERO_BYTE;
9347 dgst_pos0 = 0;
9348 dgst_pos1 = 1;
9349 dgst_pos2 = 2;
9350 dgst_pos3 = 3;
9351 break;
9352
9353 case 7500: hash_type = HASH_TYPE_KRB5PA;
9354 salt_type = SALT_TYPE_EMBEDDED;
9355 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9356 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9357 kern_type = KERN_TYPE_KRB5PA;
9358 dgst_size = DGST_SIZE_4_4;
9359 parse_func = krb5pa_parse_hash;
9360 sort_by_digest = sort_by_digest_4_4;
9361 opti_type = OPTI_TYPE_ZERO_BYTE
9362 | OPTI_TYPE_NOT_ITERATED;
9363 dgst_pos0 = 0;
9364 dgst_pos1 = 1;
9365 dgst_pos2 = 2;
9366 dgst_pos3 = 3;
9367 break;
9368
9369 case 7600: hash_type = HASH_TYPE_SHA1;
9370 salt_type = SALT_TYPE_INTERN;
9371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9372 opts_type = OPTS_TYPE_PT_GENERATE_BE
9373 | OPTS_TYPE_PT_ADD80
9374 | OPTS_TYPE_PT_ADDBITS15;
9375 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9376 dgst_size = DGST_SIZE_4_5;
9377 parse_func = redmine_parse_hash;
9378 sort_by_digest = sort_by_digest_4_5;
9379 opti_type = OPTI_TYPE_ZERO_BYTE
9380 | OPTI_TYPE_PRECOMPUTE_INIT
9381 | OPTI_TYPE_EARLY_SKIP
9382 | OPTI_TYPE_NOT_ITERATED
9383 | OPTI_TYPE_PREPENDED_SALT;
9384 dgst_pos0 = 3;
9385 dgst_pos1 = 4;
9386 dgst_pos2 = 2;
9387 dgst_pos3 = 1;
9388 break;
9389
9390 case 7700: hash_type = HASH_TYPE_SAPB;
9391 salt_type = SALT_TYPE_EMBEDDED;
9392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9393 opts_type = OPTS_TYPE_PT_GENERATE_LE
9394 | OPTS_TYPE_PT_UPPER
9395 | OPTS_TYPE_ST_UPPER;
9396 kern_type = KERN_TYPE_SAPB;
9397 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9398 parse_func = sapb_parse_hash;
9399 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9400 opti_type = OPTI_TYPE_ZERO_BYTE
9401 | OPTI_TYPE_PRECOMPUTE_INIT
9402 | OPTI_TYPE_NOT_ITERATED;
9403 dgst_pos0 = 0;
9404 dgst_pos1 = 1;
9405 dgst_pos2 = 2;
9406 dgst_pos3 = 3;
9407 break;
9408
9409 case 7800: hash_type = HASH_TYPE_SAPG;
9410 salt_type = SALT_TYPE_EMBEDDED;
9411 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9412 opts_type = OPTS_TYPE_PT_GENERATE_BE
9413 | OPTS_TYPE_ST_ADD80
9414 | OPTS_TYPE_ST_UPPER;
9415 kern_type = KERN_TYPE_SAPG;
9416 dgst_size = DGST_SIZE_4_5;
9417 parse_func = sapg_parse_hash;
9418 sort_by_digest = sort_by_digest_4_5;
9419 opti_type = OPTI_TYPE_ZERO_BYTE
9420 | OPTI_TYPE_PRECOMPUTE_INIT
9421 | OPTI_TYPE_NOT_ITERATED;
9422 dgst_pos0 = 3;
9423 dgst_pos1 = 4;
9424 dgst_pos2 = 2;
9425 dgst_pos3 = 1;
9426 break;
9427
9428 case 7900: hash_type = HASH_TYPE_SHA512;
9429 salt_type = SALT_TYPE_EMBEDDED;
9430 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9431 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9432 kern_type = KERN_TYPE_DRUPAL7;
9433 dgst_size = DGST_SIZE_8_8;
9434 parse_func = drupal7_parse_hash;
9435 sort_by_digest = sort_by_digest_8_8;
9436 opti_type = OPTI_TYPE_ZERO_BYTE
9437 | OPTI_TYPE_USES_BITS_64;
9438 dgst_pos0 = 0;
9439 dgst_pos1 = 1;
9440 dgst_pos2 = 2;
9441 dgst_pos3 = 3;
9442 break;
9443
9444 case 8000: hash_type = HASH_TYPE_SHA256;
9445 salt_type = SALT_TYPE_EMBEDDED;
9446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9447 opts_type = OPTS_TYPE_PT_GENERATE_BE
9448 | OPTS_TYPE_PT_UNICODE
9449 | OPTS_TYPE_ST_ADD80
9450 | OPTS_TYPE_ST_HEX;
9451 kern_type = KERN_TYPE_SYBASEASE;
9452 dgst_size = DGST_SIZE_4_8;
9453 parse_func = sybasease_parse_hash;
9454 sort_by_digest = sort_by_digest_4_8;
9455 opti_type = OPTI_TYPE_ZERO_BYTE
9456 | OPTI_TYPE_PRECOMPUTE_INIT
9457 | OPTI_TYPE_EARLY_SKIP
9458 | OPTI_TYPE_NOT_ITERATED
9459 | OPTI_TYPE_RAW_HASH;
9460 dgst_pos0 = 3;
9461 dgst_pos1 = 7;
9462 dgst_pos2 = 2;
9463 dgst_pos3 = 6;
9464 break;
9465
9466 case 8100: hash_type = HASH_TYPE_SHA1;
9467 salt_type = SALT_TYPE_EMBEDDED;
9468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9469 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9470 kern_type = KERN_TYPE_NETSCALER;
9471 dgst_size = DGST_SIZE_4_5;
9472 parse_func = netscaler_parse_hash;
9473 sort_by_digest = sort_by_digest_4_5;
9474 opti_type = OPTI_TYPE_ZERO_BYTE
9475 | OPTI_TYPE_PRECOMPUTE_INIT
9476 | OPTI_TYPE_PRECOMPUTE_MERKLE
9477 | OPTI_TYPE_EARLY_SKIP
9478 | OPTI_TYPE_NOT_ITERATED
9479 | OPTI_TYPE_PREPENDED_SALT
9480 | OPTI_TYPE_RAW_HASH;
9481 dgst_pos0 = 3;
9482 dgst_pos1 = 4;
9483 dgst_pos2 = 2;
9484 dgst_pos3 = 1;
9485 break;
9486
9487 case 8200: hash_type = HASH_TYPE_SHA256;
9488 salt_type = SALT_TYPE_EMBEDDED;
9489 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9490 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9491 kern_type = KERN_TYPE_CLOUDKEY;
9492 dgst_size = DGST_SIZE_4_8;
9493 parse_func = cloudkey_parse_hash;
9494 sort_by_digest = sort_by_digest_4_8;
9495 opti_type = OPTI_TYPE_ZERO_BYTE;
9496 dgst_pos0 = 0;
9497 dgst_pos1 = 1;
9498 dgst_pos2 = 2;
9499 dgst_pos3 = 3;
9500 break;
9501
9502 case 8300: hash_type = HASH_TYPE_SHA1;
9503 salt_type = SALT_TYPE_EMBEDDED;
9504 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9505 opts_type = OPTS_TYPE_PT_GENERATE_BE
9506 | OPTS_TYPE_ST_HEX
9507 | OPTS_TYPE_ST_ADD80;
9508 kern_type = KERN_TYPE_NSEC3;
9509 dgst_size = DGST_SIZE_4_5;
9510 parse_func = nsec3_parse_hash;
9511 sort_by_digest = sort_by_digest_4_5;
9512 opti_type = OPTI_TYPE_ZERO_BYTE;
9513 dgst_pos0 = 3;
9514 dgst_pos1 = 4;
9515 dgst_pos2 = 2;
9516 dgst_pos3 = 1;
9517 break;
9518
9519 case 8400: hash_type = HASH_TYPE_SHA1;
9520 salt_type = SALT_TYPE_INTERN;
9521 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9522 opts_type = OPTS_TYPE_PT_GENERATE_BE
9523 | OPTS_TYPE_PT_ADD80
9524 | OPTS_TYPE_PT_ADDBITS15;
9525 kern_type = KERN_TYPE_WBB3;
9526 dgst_size = DGST_SIZE_4_5;
9527 parse_func = wbb3_parse_hash;
9528 sort_by_digest = sort_by_digest_4_5;
9529 opti_type = OPTI_TYPE_ZERO_BYTE
9530 | OPTI_TYPE_PRECOMPUTE_INIT
9531 | OPTI_TYPE_NOT_ITERATED;
9532 dgst_pos0 = 3;
9533 dgst_pos1 = 4;
9534 dgst_pos2 = 2;
9535 dgst_pos3 = 1;
9536 break;
9537
9538 case 8500: hash_type = HASH_TYPE_DESRACF;
9539 salt_type = SALT_TYPE_EMBEDDED;
9540 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9541 opts_type = OPTS_TYPE_PT_GENERATE_LE
9542 | OPTS_TYPE_ST_UPPER;
9543 kern_type = KERN_TYPE_RACF;
9544 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9545 parse_func = racf_parse_hash;
9546 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9547 opti_type = OPTI_TYPE_ZERO_BYTE
9548 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9549 dgst_pos0 = 0;
9550 dgst_pos1 = 1;
9551 dgst_pos2 = 2;
9552 dgst_pos3 = 3;
9553 break;
9554
9555 case 8600: hash_type = HASH_TYPE_LOTUS5;
9556 salt_type = SALT_TYPE_NONE;
9557 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9558 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9559 kern_type = KERN_TYPE_LOTUS5;
9560 dgst_size = DGST_SIZE_4_4;
9561 parse_func = lotus5_parse_hash;
9562 sort_by_digest = sort_by_digest_4_4;
9563 opti_type = OPTI_TYPE_EARLY_SKIP
9564 | OPTI_TYPE_NOT_ITERATED
9565 | OPTI_TYPE_NOT_SALTED
9566 | OPTI_TYPE_RAW_HASH;
9567 dgst_pos0 = 0;
9568 dgst_pos1 = 1;
9569 dgst_pos2 = 2;
9570 dgst_pos3 = 3;
9571 break;
9572
9573 case 8700: hash_type = HASH_TYPE_LOTUS6;
9574 salt_type = SALT_TYPE_EMBEDDED;
9575 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9576 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9577 kern_type = KERN_TYPE_LOTUS6;
9578 dgst_size = DGST_SIZE_4_4;
9579 parse_func = lotus6_parse_hash;
9580 sort_by_digest = sort_by_digest_4_4;
9581 opti_type = OPTI_TYPE_EARLY_SKIP
9582 | OPTI_TYPE_NOT_ITERATED
9583 | OPTI_TYPE_RAW_HASH;
9584 dgst_pos0 = 0;
9585 dgst_pos1 = 1;
9586 dgst_pos2 = 2;
9587 dgst_pos3 = 3;
9588 break;
9589
9590 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9591 salt_type = SALT_TYPE_EMBEDDED;
9592 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9593 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9594 kern_type = KERN_TYPE_ANDROIDFDE;
9595 dgst_size = DGST_SIZE_4_4;
9596 parse_func = androidfde_parse_hash;
9597 sort_by_digest = sort_by_digest_4_4;
9598 opti_type = OPTI_TYPE_ZERO_BYTE;
9599 dgst_pos0 = 0;
9600 dgst_pos1 = 1;
9601 dgst_pos2 = 2;
9602 dgst_pos3 = 3;
9603 break;
9604
9605 case 8900: hash_type = HASH_TYPE_SCRYPT;
9606 salt_type = SALT_TYPE_EMBEDDED;
9607 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9608 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9609 kern_type = KERN_TYPE_SCRYPT;
9610 dgst_size = DGST_SIZE_4_8;
9611 parse_func = scrypt_parse_hash;
9612 sort_by_digest = sort_by_digest_4_8;
9613 opti_type = OPTI_TYPE_ZERO_BYTE;
9614 dgst_pos0 = 0;
9615 dgst_pos1 = 1;
9616 dgst_pos2 = 2;
9617 dgst_pos3 = 3;
9618 break;
9619
9620 case 9000: hash_type = HASH_TYPE_SHA1;
9621 salt_type = SALT_TYPE_EMBEDDED;
9622 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9623 opts_type = OPTS_TYPE_PT_GENERATE_LE
9624 | OPTS_TYPE_ST_GENERATE_LE;
9625 kern_type = KERN_TYPE_PSAFE2;
9626 dgst_size = DGST_SIZE_4_5;
9627 parse_func = psafe2_parse_hash;
9628 sort_by_digest = sort_by_digest_4_5;
9629 opti_type = OPTI_TYPE_ZERO_BYTE;
9630 dgst_pos0 = 0;
9631 dgst_pos1 = 1;
9632 dgst_pos2 = 2;
9633 dgst_pos3 = 3;
9634 break;
9635
9636 case 9100: hash_type = HASH_TYPE_LOTUS8;
9637 salt_type = SALT_TYPE_EMBEDDED;
9638 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9639 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9640 kern_type = KERN_TYPE_LOTUS8;
9641 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9642 parse_func = lotus8_parse_hash;
9643 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9644 opti_type = OPTI_TYPE_ZERO_BYTE;
9645 dgst_pos0 = 0;
9646 dgst_pos1 = 1;
9647 dgst_pos2 = 2;
9648 dgst_pos3 = 3;
9649 break;
9650
9651 case 9200: hash_type = HASH_TYPE_SHA256;
9652 salt_type = SALT_TYPE_EMBEDDED;
9653 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9654 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9655 kern_type = KERN_TYPE_PBKDF2_SHA256;
9656 dgst_size = DGST_SIZE_4_32;
9657 parse_func = cisco8_parse_hash;
9658 sort_by_digest = sort_by_digest_4_32;
9659 opti_type = OPTI_TYPE_ZERO_BYTE
9660 | OPTI_TYPE_SLOW_HASH_SIMD;
9661 dgst_pos0 = 0;
9662 dgst_pos1 = 1;
9663 dgst_pos2 = 2;
9664 dgst_pos3 = 3;
9665 break;
9666
9667 case 9300: hash_type = HASH_TYPE_SCRYPT;
9668 salt_type = SALT_TYPE_EMBEDDED;
9669 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9670 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9671 kern_type = KERN_TYPE_SCRYPT;
9672 dgst_size = DGST_SIZE_4_8;
9673 parse_func = cisco9_parse_hash;
9674 sort_by_digest = sort_by_digest_4_8;
9675 opti_type = OPTI_TYPE_ZERO_BYTE;
9676 dgst_pos0 = 0;
9677 dgst_pos1 = 1;
9678 dgst_pos2 = 2;
9679 dgst_pos3 = 3;
9680 break;
9681
9682 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9683 salt_type = SALT_TYPE_EMBEDDED;
9684 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9685 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9686 kern_type = KERN_TYPE_OFFICE2007;
9687 dgst_size = DGST_SIZE_4_4;
9688 parse_func = office2007_parse_hash;
9689 sort_by_digest = sort_by_digest_4_4;
9690 opti_type = OPTI_TYPE_ZERO_BYTE;
9691 dgst_pos0 = 0;
9692 dgst_pos1 = 1;
9693 dgst_pos2 = 2;
9694 dgst_pos3 = 3;
9695 break;
9696
9697 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9698 salt_type = SALT_TYPE_EMBEDDED;
9699 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9700 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9701 kern_type = KERN_TYPE_OFFICE2010;
9702 dgst_size = DGST_SIZE_4_4;
9703 parse_func = office2010_parse_hash;
9704 sort_by_digest = sort_by_digest_4_4;
9705 opti_type = OPTI_TYPE_ZERO_BYTE;
9706 dgst_pos0 = 0;
9707 dgst_pos1 = 1;
9708 dgst_pos2 = 2;
9709 dgst_pos3 = 3;
9710 break;
9711
9712 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9713 salt_type = SALT_TYPE_EMBEDDED;
9714 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9715 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9716 kern_type = KERN_TYPE_OFFICE2013;
9717 dgst_size = DGST_SIZE_4_4;
9718 parse_func = office2013_parse_hash;
9719 sort_by_digest = sort_by_digest_4_4;
9720 opti_type = OPTI_TYPE_ZERO_BYTE;
9721 dgst_pos0 = 0;
9722 dgst_pos1 = 1;
9723 dgst_pos2 = 2;
9724 dgst_pos3 = 3;
9725 break;
9726
9727 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9728 salt_type = SALT_TYPE_EMBEDDED;
9729 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9730 opts_type = OPTS_TYPE_PT_GENERATE_LE
9731 | OPTS_TYPE_PT_ADD80
9732 | OPTS_TYPE_PT_UNICODE;
9733 kern_type = KERN_TYPE_OLDOFFICE01;
9734 dgst_size = DGST_SIZE_4_4;
9735 parse_func = oldoffice01_parse_hash;
9736 sort_by_digest = sort_by_digest_4_4;
9737 opti_type = OPTI_TYPE_ZERO_BYTE
9738 | OPTI_TYPE_PRECOMPUTE_INIT
9739 | OPTI_TYPE_NOT_ITERATED;
9740 dgst_pos0 = 0;
9741 dgst_pos1 = 1;
9742 dgst_pos2 = 2;
9743 dgst_pos3 = 3;
9744 break;
9745
9746 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9747 salt_type = SALT_TYPE_EMBEDDED;
9748 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9749 opts_type = OPTS_TYPE_PT_GENERATE_LE
9750 | OPTS_TYPE_PT_ADD80;
9751 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9752 dgst_size = DGST_SIZE_4_4;
9753 parse_func = oldoffice01cm1_parse_hash;
9754 sort_by_digest = sort_by_digest_4_4;
9755 opti_type = OPTI_TYPE_ZERO_BYTE
9756 | OPTI_TYPE_PRECOMPUTE_INIT
9757 | OPTI_TYPE_NOT_ITERATED;
9758 dgst_pos0 = 0;
9759 dgst_pos1 = 1;
9760 dgst_pos2 = 2;
9761 dgst_pos3 = 3;
9762 break;
9763
9764 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9765 salt_type = SALT_TYPE_EMBEDDED;
9766 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9767 opts_type = OPTS_TYPE_PT_GENERATE_LE
9768 | OPTS_TYPE_PT_ADD80
9769 | OPTS_TYPE_PT_UNICODE
9770 | OPTS_TYPE_PT_NEVERCRACK;
9771 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9772 dgst_size = DGST_SIZE_4_4;
9773 parse_func = oldoffice01cm2_parse_hash;
9774 sort_by_digest = sort_by_digest_4_4;
9775 opti_type = OPTI_TYPE_ZERO_BYTE
9776 | OPTI_TYPE_PRECOMPUTE_INIT
9777 | OPTI_TYPE_NOT_ITERATED;
9778 dgst_pos0 = 0;
9779 dgst_pos1 = 1;
9780 dgst_pos2 = 2;
9781 dgst_pos3 = 3;
9782 break;
9783
9784 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9785 salt_type = SALT_TYPE_EMBEDDED;
9786 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9787 opts_type = OPTS_TYPE_PT_GENERATE_BE
9788 | OPTS_TYPE_PT_ADD80
9789 | OPTS_TYPE_PT_UNICODE;
9790 kern_type = KERN_TYPE_OLDOFFICE34;
9791 dgst_size = DGST_SIZE_4_4;
9792 parse_func = oldoffice34_parse_hash;
9793 sort_by_digest = sort_by_digest_4_4;
9794 opti_type = OPTI_TYPE_ZERO_BYTE
9795 | OPTI_TYPE_PRECOMPUTE_INIT
9796 | OPTI_TYPE_NOT_ITERATED;
9797 dgst_pos0 = 0;
9798 dgst_pos1 = 1;
9799 dgst_pos2 = 2;
9800 dgst_pos3 = 3;
9801 break;
9802
9803 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9804 salt_type = SALT_TYPE_EMBEDDED;
9805 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9806 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9807 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9808 dgst_size = DGST_SIZE_4_4;
9809 parse_func = oldoffice34cm1_parse_hash;
9810 sort_by_digest = sort_by_digest_4_4;
9811 opti_type = OPTI_TYPE_ZERO_BYTE
9812 | OPTI_TYPE_PRECOMPUTE_INIT
9813 | OPTI_TYPE_NOT_ITERATED;
9814 dgst_pos0 = 0;
9815 dgst_pos1 = 1;
9816 dgst_pos2 = 2;
9817 dgst_pos3 = 3;
9818 break;
9819
9820 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9821 salt_type = SALT_TYPE_EMBEDDED;
9822 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9823 opts_type = OPTS_TYPE_PT_GENERATE_BE
9824 | OPTS_TYPE_PT_ADD80
9825 | OPTS_TYPE_PT_UNICODE
9826 | OPTS_TYPE_PT_NEVERCRACK;
9827 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9828 dgst_size = DGST_SIZE_4_4;
9829 parse_func = oldoffice34cm2_parse_hash;
9830 sort_by_digest = sort_by_digest_4_4;
9831 opti_type = OPTI_TYPE_ZERO_BYTE
9832 | OPTI_TYPE_PRECOMPUTE_INIT
9833 | OPTI_TYPE_NOT_ITERATED;
9834 dgst_pos0 = 0;
9835 dgst_pos1 = 1;
9836 dgst_pos2 = 2;
9837 dgst_pos3 = 3;
9838 break;
9839
9840 case 9900: hash_type = HASH_TYPE_MD5;
9841 salt_type = SALT_TYPE_NONE;
9842 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9843 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9844 kern_type = KERN_TYPE_RADMIN2;
9845 dgst_size = DGST_SIZE_4_4;
9846 parse_func = radmin2_parse_hash;
9847 sort_by_digest = sort_by_digest_4_4;
9848 opti_type = OPTI_TYPE_ZERO_BYTE
9849 | OPTI_TYPE_PRECOMPUTE_INIT
9850 | OPTI_TYPE_EARLY_SKIP
9851 | OPTI_TYPE_NOT_ITERATED
9852 | OPTI_TYPE_NOT_SALTED;
9853 dgst_pos0 = 0;
9854 dgst_pos1 = 3;
9855 dgst_pos2 = 2;
9856 dgst_pos3 = 1;
9857 break;
9858
9859 case 10000: hash_type = HASH_TYPE_SHA256;
9860 salt_type = SALT_TYPE_EMBEDDED;
9861 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9862 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9863 kern_type = KERN_TYPE_PBKDF2_SHA256;
9864 dgst_size = DGST_SIZE_4_32;
9865 parse_func = djangopbkdf2_parse_hash;
9866 sort_by_digest = sort_by_digest_4_32;
9867 opti_type = OPTI_TYPE_ZERO_BYTE
9868 | OPTI_TYPE_SLOW_HASH_SIMD;
9869 dgst_pos0 = 0;
9870 dgst_pos1 = 1;
9871 dgst_pos2 = 2;
9872 dgst_pos3 = 3;
9873 break;
9874
9875 case 10100: hash_type = HASH_TYPE_SIPHASH;
9876 salt_type = SALT_TYPE_EMBEDDED;
9877 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9878 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9879 kern_type = KERN_TYPE_SIPHASH;
9880 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9881 parse_func = siphash_parse_hash;
9882 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9883 opti_type = OPTI_TYPE_ZERO_BYTE
9884 | OPTI_TYPE_NOT_ITERATED
9885 | OPTI_TYPE_RAW_HASH;
9886 dgst_pos0 = 0;
9887 dgst_pos1 = 1;
9888 dgst_pos2 = 2;
9889 dgst_pos3 = 3;
9890 break;
9891
9892 case 10200: hash_type = HASH_TYPE_MD5;
9893 salt_type = SALT_TYPE_EMBEDDED;
9894 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9895 opts_type = OPTS_TYPE_PT_GENERATE_LE
9896 | OPTS_TYPE_ST_ADD80
9897 | OPTS_TYPE_ST_ADDBITS14;
9898 kern_type = KERN_TYPE_HMACMD5_PW;
9899 dgst_size = DGST_SIZE_4_4;
9900 parse_func = crammd5_parse_hash;
9901 sort_by_digest = sort_by_digest_4_4;
9902 opti_type = OPTI_TYPE_ZERO_BYTE
9903 | OPTI_TYPE_NOT_ITERATED;
9904 dgst_pos0 = 0;
9905 dgst_pos1 = 3;
9906 dgst_pos2 = 2;
9907 dgst_pos3 = 1;
9908 break;
9909
9910 case 10300: hash_type = HASH_TYPE_SHA1;
9911 salt_type = SALT_TYPE_EMBEDDED;
9912 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9913 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9914 kern_type = KERN_TYPE_SAPH_SHA1;
9915 dgst_size = DGST_SIZE_4_5;
9916 parse_func = saph_sha1_parse_hash;
9917 sort_by_digest = sort_by_digest_4_5;
9918 opti_type = OPTI_TYPE_ZERO_BYTE;
9919 dgst_pos0 = 0;
9920 dgst_pos1 = 1;
9921 dgst_pos2 = 2;
9922 dgst_pos3 = 3;
9923 break;
9924
9925 case 10400: hash_type = HASH_TYPE_PDFU16;
9926 salt_type = SALT_TYPE_EMBEDDED;
9927 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9928 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9929 kern_type = KERN_TYPE_PDF11;
9930 dgst_size = DGST_SIZE_4_4;
9931 parse_func = pdf11_parse_hash;
9932 sort_by_digest = sort_by_digest_4_4;
9933 opti_type = OPTI_TYPE_ZERO_BYTE
9934 | OPTI_TYPE_NOT_ITERATED;
9935 dgst_pos0 = 0;
9936 dgst_pos1 = 1;
9937 dgst_pos2 = 2;
9938 dgst_pos3 = 3;
9939 break;
9940
9941 case 10410: hash_type = HASH_TYPE_PDFU16;
9942 salt_type = SALT_TYPE_EMBEDDED;
9943 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9944 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9945 kern_type = KERN_TYPE_PDF11CM1;
9946 dgst_size = DGST_SIZE_4_4;
9947 parse_func = pdf11cm1_parse_hash;
9948 sort_by_digest = sort_by_digest_4_4;
9949 opti_type = OPTI_TYPE_ZERO_BYTE
9950 | OPTI_TYPE_NOT_ITERATED;
9951 dgst_pos0 = 0;
9952 dgst_pos1 = 1;
9953 dgst_pos2 = 2;
9954 dgst_pos3 = 3;
9955 break;
9956
9957 case 10420: hash_type = HASH_TYPE_PDFU16;
9958 salt_type = SALT_TYPE_EMBEDDED;
9959 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9960 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9961 kern_type = KERN_TYPE_PDF11CM2;
9962 dgst_size = DGST_SIZE_4_4;
9963 parse_func = pdf11cm2_parse_hash;
9964 sort_by_digest = sort_by_digest_4_4;
9965 opti_type = OPTI_TYPE_ZERO_BYTE
9966 | OPTI_TYPE_NOT_ITERATED;
9967 dgst_pos0 = 0;
9968 dgst_pos1 = 1;
9969 dgst_pos2 = 2;
9970 dgst_pos3 = 3;
9971 break;
9972
9973 case 10500: hash_type = HASH_TYPE_PDFU16;
9974 salt_type = SALT_TYPE_EMBEDDED;
9975 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9976 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9977 kern_type = KERN_TYPE_PDF14;
9978 dgst_size = DGST_SIZE_4_4;
9979 parse_func = pdf14_parse_hash;
9980 sort_by_digest = sort_by_digest_4_4;
9981 opti_type = OPTI_TYPE_ZERO_BYTE
9982 | OPTI_TYPE_NOT_ITERATED;
9983 dgst_pos0 = 0;
9984 dgst_pos1 = 1;
9985 dgst_pos2 = 2;
9986 dgst_pos3 = 3;
9987 break;
9988
9989 case 10600: hash_type = HASH_TYPE_SHA256;
9990 salt_type = SALT_TYPE_EMBEDDED;
9991 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9992 opts_type = OPTS_TYPE_PT_GENERATE_BE
9993 | OPTS_TYPE_ST_ADD80
9994 | OPTS_TYPE_ST_ADDBITS15
9995 | OPTS_TYPE_HASH_COPY;
9996 kern_type = KERN_TYPE_SHA256_PWSLT;
9997 dgst_size = DGST_SIZE_4_8;
9998 parse_func = pdf17l3_parse_hash;
9999 sort_by_digest = sort_by_digest_4_8;
10000 opti_type = OPTI_TYPE_ZERO_BYTE
10001 | OPTI_TYPE_PRECOMPUTE_INIT
10002 | OPTI_TYPE_PRECOMPUTE_MERKLE
10003 | OPTI_TYPE_EARLY_SKIP
10004 | OPTI_TYPE_NOT_ITERATED
10005 | OPTI_TYPE_APPENDED_SALT
10006 | OPTI_TYPE_RAW_HASH;
10007 dgst_pos0 = 3;
10008 dgst_pos1 = 7;
10009 dgst_pos2 = 2;
10010 dgst_pos3 = 6;
10011 break;
10012
10013 case 10700: hash_type = HASH_TYPE_PDFU32;
10014 salt_type = SALT_TYPE_EMBEDDED;
10015 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10016 opts_type = OPTS_TYPE_PT_GENERATE_LE
10017 | OPTS_TYPE_HASH_COPY;
10018 kern_type = KERN_TYPE_PDF17L8;
10019 dgst_size = DGST_SIZE_4_8;
10020 parse_func = pdf17l8_parse_hash;
10021 sort_by_digest = sort_by_digest_4_8;
10022 opti_type = OPTI_TYPE_ZERO_BYTE
10023 | OPTI_TYPE_NOT_ITERATED;
10024 dgst_pos0 = 0;
10025 dgst_pos1 = 1;
10026 dgst_pos2 = 2;
10027 dgst_pos3 = 3;
10028 break;
10029
10030 case 10800: hash_type = HASH_TYPE_SHA384;
10031 salt_type = SALT_TYPE_NONE;
10032 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10033 opts_type = OPTS_TYPE_PT_GENERATE_BE
10034 | OPTS_TYPE_PT_ADD80
10035 | OPTS_TYPE_PT_ADDBITS15;
10036 kern_type = KERN_TYPE_SHA384;
10037 dgst_size = DGST_SIZE_8_8;
10038 parse_func = sha384_parse_hash;
10039 sort_by_digest = sort_by_digest_8_8;
10040 opti_type = OPTI_TYPE_ZERO_BYTE
10041 | OPTI_TYPE_PRECOMPUTE_INIT
10042 | OPTI_TYPE_PRECOMPUTE_MERKLE
10043 | OPTI_TYPE_EARLY_SKIP
10044 | OPTI_TYPE_NOT_ITERATED
10045 | OPTI_TYPE_NOT_SALTED
10046 | OPTI_TYPE_USES_BITS_64
10047 | OPTI_TYPE_RAW_HASH;
10048 dgst_pos0 = 6;
10049 dgst_pos1 = 7;
10050 dgst_pos2 = 4;
10051 dgst_pos3 = 5;
10052 break;
10053
10054 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10055 salt_type = SALT_TYPE_EMBEDDED;
10056 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10057 opts_type = OPTS_TYPE_PT_GENERATE_LE
10058 | OPTS_TYPE_ST_BASE64
10059 | OPTS_TYPE_HASH_COPY;
10060 kern_type = KERN_TYPE_PBKDF2_SHA256;
10061 dgst_size = DGST_SIZE_4_32;
10062 parse_func = pbkdf2_sha256_parse_hash;
10063 sort_by_digest = sort_by_digest_4_32;
10064 opti_type = OPTI_TYPE_ZERO_BYTE
10065 | OPTI_TYPE_SLOW_HASH_SIMD;
10066 dgst_pos0 = 0;
10067 dgst_pos1 = 1;
10068 dgst_pos2 = 2;
10069 dgst_pos3 = 3;
10070 break;
10071
10072 case 11000: hash_type = HASH_TYPE_MD5;
10073 salt_type = SALT_TYPE_INTERN;
10074 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10075 opts_type = OPTS_TYPE_PT_GENERATE_LE
10076 | OPTS_TYPE_PT_ADD80;
10077 kern_type = KERN_TYPE_PRESTASHOP;
10078 dgst_size = DGST_SIZE_4_4;
10079 parse_func = prestashop_parse_hash;
10080 sort_by_digest = sort_by_digest_4_4;
10081 opti_type = OPTI_TYPE_ZERO_BYTE
10082 | OPTI_TYPE_PRECOMPUTE_INIT
10083 | OPTI_TYPE_NOT_ITERATED
10084 | OPTI_TYPE_PREPENDED_SALT;
10085 dgst_pos0 = 0;
10086 dgst_pos1 = 3;
10087 dgst_pos2 = 2;
10088 dgst_pos3 = 1;
10089 break;
10090
10091 case 11100: hash_type = HASH_TYPE_MD5;
10092 salt_type = SALT_TYPE_EMBEDDED;
10093 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10094 opts_type = OPTS_TYPE_PT_GENERATE_LE
10095 | OPTS_TYPE_ST_ADD80;
10096 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10097 dgst_size = DGST_SIZE_4_4;
10098 parse_func = postgresql_auth_parse_hash;
10099 sort_by_digest = sort_by_digest_4_4;
10100 opti_type = OPTI_TYPE_ZERO_BYTE
10101 | OPTI_TYPE_PRECOMPUTE_INIT
10102 | OPTI_TYPE_PRECOMPUTE_MERKLE
10103 | OPTI_TYPE_EARLY_SKIP;
10104 dgst_pos0 = 0;
10105 dgst_pos1 = 3;
10106 dgst_pos2 = 2;
10107 dgst_pos3 = 1;
10108 break;
10109
10110 case 11200: hash_type = HASH_TYPE_SHA1;
10111 salt_type = SALT_TYPE_EMBEDDED;
10112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10113 opts_type = OPTS_TYPE_PT_GENERATE_BE
10114 | OPTS_TYPE_PT_ADD80
10115 | OPTS_TYPE_ST_HEX;
10116 kern_type = KERN_TYPE_MYSQL_AUTH;
10117 dgst_size = DGST_SIZE_4_5;
10118 parse_func = mysql_auth_parse_hash;
10119 sort_by_digest = sort_by_digest_4_5;
10120 opti_type = OPTI_TYPE_ZERO_BYTE
10121 | OPTI_TYPE_EARLY_SKIP;
10122 dgst_pos0 = 3;
10123 dgst_pos1 = 4;
10124 dgst_pos2 = 2;
10125 dgst_pos3 = 1;
10126 break;
10127
10128 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10129 salt_type = SALT_TYPE_EMBEDDED;
10130 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10131 opts_type = OPTS_TYPE_PT_GENERATE_LE
10132 | OPTS_TYPE_ST_HEX
10133 | OPTS_TYPE_ST_ADD80;
10134 kern_type = KERN_TYPE_BITCOIN_WALLET;
10135 dgst_size = DGST_SIZE_4_4;
10136 parse_func = bitcoin_wallet_parse_hash;
10137 sort_by_digest = sort_by_digest_4_4;
10138 opti_type = OPTI_TYPE_ZERO_BYTE;
10139 dgst_pos0 = 0;
10140 dgst_pos1 = 1;
10141 dgst_pos2 = 2;
10142 dgst_pos3 = 3;
10143 break;
10144
10145 case 11400: hash_type = HASH_TYPE_MD5;
10146 salt_type = SALT_TYPE_EMBEDDED;
10147 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10148 opts_type = OPTS_TYPE_PT_GENERATE_LE
10149 | OPTS_TYPE_PT_ADD80
10150 | OPTS_TYPE_HASH_COPY;
10151 kern_type = KERN_TYPE_SIP_AUTH;
10152 dgst_size = DGST_SIZE_4_4;
10153 parse_func = sip_auth_parse_hash;
10154 sort_by_digest = sort_by_digest_4_4;
10155 opti_type = OPTI_TYPE_ZERO_BYTE;
10156 dgst_pos0 = 0;
10157 dgst_pos1 = 3;
10158 dgst_pos2 = 2;
10159 dgst_pos3 = 1;
10160 break;
10161
10162 case 11500: hash_type = HASH_TYPE_CRC32;
10163 salt_type = SALT_TYPE_INTERN;
10164 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10165 opts_type = OPTS_TYPE_PT_GENERATE_LE
10166 | OPTS_TYPE_ST_GENERATE_LE
10167 | OPTS_TYPE_ST_HEX;
10168 kern_type = KERN_TYPE_CRC32;
10169 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10170 parse_func = crc32_parse_hash;
10171 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10172 opti_type = OPTI_TYPE_ZERO_BYTE;
10173 dgst_pos0 = 0;
10174 dgst_pos1 = 1;
10175 dgst_pos2 = 2;
10176 dgst_pos3 = 3;
10177 break;
10178
10179 case 11600: hash_type = HASH_TYPE_AES;
10180 salt_type = SALT_TYPE_EMBEDDED;
10181 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10182 opts_type = OPTS_TYPE_PT_GENERATE_LE
10183 | OPTS_TYPE_PT_NEVERCRACK;
10184 kern_type = KERN_TYPE_SEVEN_ZIP;
10185 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10186 parse_func = seven_zip_parse_hash;
10187 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10188 opti_type = OPTI_TYPE_ZERO_BYTE;
10189 dgst_pos0 = 0;
10190 dgst_pos1 = 1;
10191 dgst_pos2 = 2;
10192 dgst_pos3 = 3;
10193 break;
10194
10195 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10196 salt_type = SALT_TYPE_NONE;
10197 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10198 opts_type = OPTS_TYPE_PT_GENERATE_LE
10199 | OPTS_TYPE_PT_ADD01;
10200 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10201 dgst_size = DGST_SIZE_4_8;
10202 parse_func = gost2012sbog_256_parse_hash;
10203 sort_by_digest = sort_by_digest_4_8;
10204 opti_type = OPTI_TYPE_ZERO_BYTE;
10205 dgst_pos0 = 0;
10206 dgst_pos1 = 1;
10207 dgst_pos2 = 2;
10208 dgst_pos3 = 3;
10209 break;
10210
10211 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10212 salt_type = SALT_TYPE_NONE;
10213 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10214 opts_type = OPTS_TYPE_PT_GENERATE_LE
10215 | OPTS_TYPE_PT_ADD01;
10216 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10217 dgst_size = DGST_SIZE_4_16;
10218 parse_func = gost2012sbog_512_parse_hash;
10219 sort_by_digest = sort_by_digest_4_16;
10220 opti_type = OPTI_TYPE_ZERO_BYTE;
10221 dgst_pos0 = 0;
10222 dgst_pos1 = 1;
10223 dgst_pos2 = 2;
10224 dgst_pos3 = 3;
10225 break;
10226
10227 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10228 salt_type = SALT_TYPE_EMBEDDED;
10229 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10230 opts_type = OPTS_TYPE_PT_GENERATE_LE
10231 | OPTS_TYPE_ST_BASE64
10232 | OPTS_TYPE_HASH_COPY;
10233 kern_type = KERN_TYPE_PBKDF2_MD5;
10234 dgst_size = DGST_SIZE_4_32;
10235 parse_func = pbkdf2_md5_parse_hash;
10236 sort_by_digest = sort_by_digest_4_32;
10237 opti_type = OPTI_TYPE_ZERO_BYTE
10238 | OPTI_TYPE_SLOW_HASH_SIMD;
10239 dgst_pos0 = 0;
10240 dgst_pos1 = 1;
10241 dgst_pos2 = 2;
10242 dgst_pos3 = 3;
10243 break;
10244
10245 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10246 salt_type = SALT_TYPE_EMBEDDED;
10247 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10248 opts_type = OPTS_TYPE_PT_GENERATE_LE
10249 | OPTS_TYPE_ST_BASE64
10250 | OPTS_TYPE_HASH_COPY;
10251 kern_type = KERN_TYPE_PBKDF2_SHA1;
10252 dgst_size = DGST_SIZE_4_32;
10253 parse_func = pbkdf2_sha1_parse_hash;
10254 sort_by_digest = sort_by_digest_4_32;
10255 opti_type = OPTI_TYPE_ZERO_BYTE
10256 | OPTI_TYPE_SLOW_HASH_SIMD;
10257 dgst_pos0 = 0;
10258 dgst_pos1 = 1;
10259 dgst_pos2 = 2;
10260 dgst_pos3 = 3;
10261 break;
10262
10263 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10264 salt_type = SALT_TYPE_EMBEDDED;
10265 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10266 opts_type = OPTS_TYPE_PT_GENERATE_LE
10267 | OPTS_TYPE_ST_BASE64
10268 | OPTS_TYPE_HASH_COPY;
10269 kern_type = KERN_TYPE_PBKDF2_SHA512;
10270 dgst_size = DGST_SIZE_8_16;
10271 parse_func = pbkdf2_sha512_parse_hash;
10272 sort_by_digest = sort_by_digest_8_16;
10273 opti_type = OPTI_TYPE_ZERO_BYTE
10274 | OPTI_TYPE_USES_BITS_64
10275 | OPTI_TYPE_SLOW_HASH_SIMD;
10276 dgst_pos0 = 0;
10277 dgst_pos1 = 1;
10278 dgst_pos2 = 2;
10279 dgst_pos3 = 3;
10280 break;
10281
10282 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10283 salt_type = SALT_TYPE_EMBEDDED;
10284 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10285 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10286 kern_type = KERN_TYPE_ECRYPTFS;
10287 dgst_size = DGST_SIZE_8_8;
10288 parse_func = ecryptfs_parse_hash;
10289 sort_by_digest = sort_by_digest_8_8;
10290 opti_type = OPTI_TYPE_ZERO_BYTE
10291 | OPTI_TYPE_USES_BITS_64;
10292 dgst_pos0 = 0;
10293 dgst_pos1 = 1;
10294 dgst_pos2 = 2;
10295 dgst_pos3 = 3;
10296 break;
10297
10298 case 12300: hash_type = HASH_TYPE_ORACLET;
10299 salt_type = SALT_TYPE_EMBEDDED;
10300 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10301 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10302 kern_type = KERN_TYPE_ORACLET;
10303 dgst_size = DGST_SIZE_8_16;
10304 parse_func = oraclet_parse_hash;
10305 sort_by_digest = sort_by_digest_8_16;
10306 opti_type = OPTI_TYPE_ZERO_BYTE
10307 | OPTI_TYPE_USES_BITS_64;
10308 dgst_pos0 = 0;
10309 dgst_pos1 = 1;
10310 dgst_pos2 = 2;
10311 dgst_pos3 = 3;
10312 break;
10313
10314 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10315 salt_type = SALT_TYPE_EMBEDDED;
10316 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10317 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10318 kern_type = KERN_TYPE_BSDICRYPT;
10319 dgst_size = DGST_SIZE_4_4;
10320 parse_func = bsdicrypt_parse_hash;
10321 sort_by_digest = sort_by_digest_4_4;
10322 opti_type = OPTI_TYPE_ZERO_BYTE
10323 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10324 dgst_pos0 = 0;
10325 dgst_pos1 = 1;
10326 dgst_pos2 = 2;
10327 dgst_pos3 = 3;
10328 break;
10329
10330 case 12500: hash_type = HASH_TYPE_RAR3HP;
10331 salt_type = SALT_TYPE_EMBEDDED;
10332 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10333 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10334 kern_type = KERN_TYPE_RAR3;
10335 dgst_size = DGST_SIZE_4_4;
10336 parse_func = rar3hp_parse_hash;
10337 sort_by_digest = sort_by_digest_4_4;
10338 opti_type = OPTI_TYPE_ZERO_BYTE;
10339 dgst_pos0 = 0;
10340 dgst_pos1 = 1;
10341 dgst_pos2 = 2;
10342 dgst_pos3 = 3;
10343 break;
10344
10345 case 12600: hash_type = HASH_TYPE_SHA256;
10346 salt_type = SALT_TYPE_INTERN;
10347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10348 opts_type = OPTS_TYPE_PT_GENERATE_BE
10349 | OPTS_TYPE_PT_ADD80;
10350 kern_type = KERN_TYPE_CF10;
10351 dgst_size = DGST_SIZE_4_8;
10352 parse_func = cf10_parse_hash;
10353 sort_by_digest = sort_by_digest_4_8;
10354 opti_type = OPTI_TYPE_ZERO_BYTE
10355 | OPTI_TYPE_PRECOMPUTE_INIT
10356 | OPTI_TYPE_EARLY_SKIP
10357 | OPTI_TYPE_NOT_ITERATED;
10358 dgst_pos0 = 3;
10359 dgst_pos1 = 7;
10360 dgst_pos2 = 2;
10361 dgst_pos3 = 6;
10362 break;
10363
10364 case 12700: hash_type = HASH_TYPE_AES;
10365 salt_type = SALT_TYPE_EMBEDDED;
10366 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10367 opts_type = OPTS_TYPE_PT_GENERATE_LE
10368 | OPTS_TYPE_HASH_COPY;
10369 kern_type = KERN_TYPE_MYWALLET;
10370 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10371 parse_func = mywallet_parse_hash;
10372 sort_by_digest = sort_by_digest_4_5;
10373 opti_type = OPTI_TYPE_ZERO_BYTE;
10374 dgst_pos0 = 0;
10375 dgst_pos1 = 1;
10376 dgst_pos2 = 2;
10377 dgst_pos3 = 3;
10378 break;
10379
10380 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10381 salt_type = SALT_TYPE_EMBEDDED;
10382 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10383 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10384 kern_type = KERN_TYPE_MS_DRSR;
10385 dgst_size = DGST_SIZE_4_8;
10386 parse_func = ms_drsr_parse_hash;
10387 sort_by_digest = sort_by_digest_4_8;
10388 opti_type = OPTI_TYPE_ZERO_BYTE;
10389 dgst_pos0 = 0;
10390 dgst_pos1 = 1;
10391 dgst_pos2 = 2;
10392 dgst_pos3 = 3;
10393 break;
10394
10395 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10396 salt_type = SALT_TYPE_EMBEDDED;
10397 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10398 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10399 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10400 dgst_size = DGST_SIZE_4_8;
10401 parse_func = androidfde_samsung_parse_hash;
10402 sort_by_digest = sort_by_digest_4_8;
10403 opti_type = OPTI_TYPE_ZERO_BYTE;
10404 dgst_pos0 = 0;
10405 dgst_pos1 = 1;
10406 dgst_pos2 = 2;
10407 dgst_pos3 = 3;
10408 break;
10409
10410 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10411 salt_type = SALT_TYPE_EMBEDDED;
10412 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10413 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10414 kern_type = KERN_TYPE_RAR5;
10415 dgst_size = DGST_SIZE_4_4;
10416 parse_func = rar5_parse_hash;
10417 sort_by_digest = sort_by_digest_4_4;
10418 opti_type = OPTI_TYPE_ZERO_BYTE;
10419 dgst_pos0 = 0;
10420 dgst_pos1 = 1;
10421 dgst_pos2 = 2;
10422 dgst_pos3 = 3;
10423 break;
10424
10425 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10426 salt_type = SALT_TYPE_EMBEDDED;
10427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10428 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10429 kern_type = KERN_TYPE_KRB5TGS;
10430 dgst_size = DGST_SIZE_4_4;
10431 parse_func = krb5tgs_parse_hash;
10432 sort_by_digest = sort_by_digest_4_4;
10433 opti_type = OPTI_TYPE_ZERO_BYTE
10434 | OPTI_TYPE_NOT_ITERATED;
10435 dgst_pos0 = 0;
10436 dgst_pos1 = 1;
10437 dgst_pos2 = 2;
10438 dgst_pos3 = 3;
10439 break;
10440
10441 case 13200: hash_type = HASH_TYPE_AES;
10442 salt_type = SALT_TYPE_EMBEDDED;
10443 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10444 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10445 kern_type = KERN_TYPE_AXCRYPT;
10446 dgst_size = DGST_SIZE_4_4;
10447 parse_func = axcrypt_parse_hash;
10448 sort_by_digest = sort_by_digest_4_4;
10449 opti_type = OPTI_TYPE_ZERO_BYTE;
10450 dgst_pos0 = 0;
10451 dgst_pos1 = 1;
10452 dgst_pos2 = 2;
10453 dgst_pos3 = 3;
10454 break;
10455
10456 case 13300: hash_type = HASH_TYPE_SHA1;
10457 salt_type = SALT_TYPE_NONE;
10458 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10459 opts_type = OPTS_TYPE_PT_GENERATE_BE
10460 | OPTS_TYPE_PT_ADD80
10461 | OPTS_TYPE_PT_ADDBITS15;
10462 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10463 dgst_size = DGST_SIZE_4_5;
10464 parse_func = sha1axcrypt_parse_hash;
10465 sort_by_digest = sort_by_digest_4_5;
10466 opti_type = OPTI_TYPE_ZERO_BYTE
10467 | OPTI_TYPE_PRECOMPUTE_INIT
10468 | OPTI_TYPE_EARLY_SKIP
10469 | OPTI_TYPE_NOT_ITERATED
10470 | OPTI_TYPE_NOT_SALTED;
10471 dgst_pos0 = 0;
10472 dgst_pos1 = 4;
10473 dgst_pos2 = 3;
10474 dgst_pos3 = 2;
10475 break;
10476
10477 case 13400: hash_type = HASH_TYPE_AES;
10478 salt_type = SALT_TYPE_EMBEDDED;
10479 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10480 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10481 kern_type = KERN_TYPE_KEEPASS;
10482 dgst_size = DGST_SIZE_4_4;
10483 parse_func = keepass_parse_hash;
10484 sort_by_digest = sort_by_digest_4_4;
10485 opti_type = OPTI_TYPE_ZERO_BYTE;
10486 dgst_pos0 = 0;
10487 dgst_pos1 = 1;
10488 dgst_pos2 = 2;
10489 dgst_pos3 = 3;
10490 break;
10491
10492 case 13500: hash_type = HASH_TYPE_SHA1;
10493 salt_type = SALT_TYPE_EMBEDDED;
10494 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10495 opts_type = OPTS_TYPE_PT_GENERATE_BE
10496 | OPTS_TYPE_PT_UNICODE
10497 | OPTS_TYPE_PT_ADD80;
10498 kern_type = KERN_TYPE_PSTOKEN;
10499 dgst_size = DGST_SIZE_4_5;
10500 parse_func = pstoken_parse_hash;
10501 sort_by_digest = sort_by_digest_4_5;
10502 opti_type = OPTI_TYPE_ZERO_BYTE
10503 | OPTI_TYPE_PRECOMPUTE_INIT
10504 | OPTI_TYPE_EARLY_SKIP
10505 | OPTI_TYPE_NOT_ITERATED
10506 | OPTI_TYPE_PREPENDED_SALT
10507 | OPTI_TYPE_RAW_HASH;
10508 dgst_pos0 = 3;
10509 dgst_pos1 = 4;
10510 dgst_pos2 = 2;
10511 dgst_pos3 = 1;
10512 break;
10513
10514 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10515 salt_type = SALT_TYPE_EMBEDDED;
10516 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10517 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10518 kern_type = KERN_TYPE_ZIP2;
10519 dgst_size = DGST_SIZE_4_4;
10520 parse_func = zip2_parse_hash;
10521 sort_by_digest = sort_by_digest_4_4;
10522 opti_type = OPTI_TYPE_ZERO_BYTE;
10523 dgst_pos0 = 0;
10524 dgst_pos1 = 1;
10525 dgst_pos2 = 2;
10526 dgst_pos3 = 3;
10527 break;
10528
10529 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10530 salt_type = SALT_TYPE_EMBEDDED;
10531 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10532 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10533 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10534 dgst_size = DGST_SIZE_4_5;
10535 parse_func = veracrypt_parse_hash_655331;
10536 sort_by_digest = sort_by_digest_4_5;
10537 opti_type = OPTI_TYPE_ZERO_BYTE;
10538 dgst_pos0 = 0;
10539 dgst_pos1 = 1;
10540 dgst_pos2 = 2;
10541 dgst_pos3 = 3;
10542 break;
10543
10544 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10545 salt_type = SALT_TYPE_EMBEDDED;
10546 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10547 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10548 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10549 dgst_size = DGST_SIZE_4_5;
10550 parse_func = veracrypt_parse_hash_655331;
10551 sort_by_digest = sort_by_digest_4_5;
10552 opti_type = OPTI_TYPE_ZERO_BYTE;
10553 dgst_pos0 = 0;
10554 dgst_pos1 = 1;
10555 dgst_pos2 = 2;
10556 dgst_pos3 = 3;
10557 break;
10558
10559 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10560 salt_type = SALT_TYPE_EMBEDDED;
10561 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10562 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10563 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10564 dgst_size = DGST_SIZE_4_5;
10565 parse_func = veracrypt_parse_hash_655331;
10566 sort_by_digest = sort_by_digest_4_5;
10567 opti_type = OPTI_TYPE_ZERO_BYTE;
10568 dgst_pos0 = 0;
10569 dgst_pos1 = 1;
10570 dgst_pos2 = 2;
10571 dgst_pos3 = 3;
10572 break;
10573
10574 case 13721: hash_type = HASH_TYPE_SHA512;
10575 salt_type = SALT_TYPE_EMBEDDED;
10576 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10577 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10578 kern_type = KERN_TYPE_TCSHA512_XTS512;
10579 dgst_size = DGST_SIZE_8_8;
10580 parse_func = veracrypt_parse_hash_500000;
10581 sort_by_digest = sort_by_digest_8_8;
10582 opti_type = OPTI_TYPE_ZERO_BYTE
10583 | OPTI_TYPE_USES_BITS_64;
10584 dgst_pos0 = 0;
10585 dgst_pos1 = 1;
10586 dgst_pos2 = 2;
10587 dgst_pos3 = 3;
10588 break;
10589
10590 case 13722: hash_type = HASH_TYPE_SHA512;
10591 salt_type = SALT_TYPE_EMBEDDED;
10592 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10593 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10594 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10595 dgst_size = DGST_SIZE_8_8;
10596 parse_func = veracrypt_parse_hash_500000;
10597 sort_by_digest = sort_by_digest_8_8;
10598 opti_type = OPTI_TYPE_ZERO_BYTE
10599 | OPTI_TYPE_USES_BITS_64;
10600 dgst_pos0 = 0;
10601 dgst_pos1 = 1;
10602 dgst_pos2 = 2;
10603 dgst_pos3 = 3;
10604 break;
10605
10606 case 13723: hash_type = HASH_TYPE_SHA512;
10607 salt_type = SALT_TYPE_EMBEDDED;
10608 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10609 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10610 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10611 dgst_size = DGST_SIZE_8_8;
10612 parse_func = veracrypt_parse_hash_500000;
10613 sort_by_digest = sort_by_digest_8_8;
10614 opti_type = OPTI_TYPE_ZERO_BYTE
10615 | OPTI_TYPE_USES_BITS_64;
10616 dgst_pos0 = 0;
10617 dgst_pos1 = 1;
10618 dgst_pos2 = 2;
10619 dgst_pos3 = 3;
10620 break;
10621
10622 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10623 salt_type = SALT_TYPE_EMBEDDED;
10624 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10625 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10626 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10627 dgst_size = DGST_SIZE_4_8;
10628 parse_func = veracrypt_parse_hash_500000;
10629 sort_by_digest = sort_by_digest_4_8;
10630 opti_type = OPTI_TYPE_ZERO_BYTE;
10631 dgst_pos0 = 0;
10632 dgst_pos1 = 1;
10633 dgst_pos2 = 2;
10634 dgst_pos3 = 3;
10635 break;
10636
10637 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10638 salt_type = SALT_TYPE_EMBEDDED;
10639 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10640 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10641 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10642 dgst_size = DGST_SIZE_4_8;
10643 parse_func = veracrypt_parse_hash_500000;
10644 sort_by_digest = sort_by_digest_4_8;
10645 opti_type = OPTI_TYPE_ZERO_BYTE;
10646 dgst_pos0 = 0;
10647 dgst_pos1 = 1;
10648 dgst_pos2 = 2;
10649 dgst_pos3 = 3;
10650 break;
10651
10652 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10653 salt_type = SALT_TYPE_EMBEDDED;
10654 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10655 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10656 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10657 dgst_size = DGST_SIZE_4_8;
10658 parse_func = veracrypt_parse_hash_500000;
10659 sort_by_digest = sort_by_digest_4_8;
10660 opti_type = OPTI_TYPE_ZERO_BYTE;
10661 dgst_pos0 = 0;
10662 dgst_pos1 = 1;
10663 dgst_pos2 = 2;
10664 dgst_pos3 = 3;
10665 break;
10666
10667 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10668 salt_type = SALT_TYPE_EMBEDDED;
10669 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10670 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10671 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10672 dgst_size = DGST_SIZE_4_5;
10673 parse_func = veracrypt_parse_hash_327661;
10674 sort_by_digest = sort_by_digest_4_5;
10675 opti_type = OPTI_TYPE_ZERO_BYTE;
10676 dgst_pos0 = 0;
10677 dgst_pos1 = 1;
10678 dgst_pos2 = 2;
10679 dgst_pos3 = 3;
10680 break;
10681
10682 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10683 salt_type = SALT_TYPE_EMBEDDED;
10684 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10685 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10686 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10687 dgst_size = DGST_SIZE_4_5;
10688 parse_func = veracrypt_parse_hash_327661;
10689 sort_by_digest = sort_by_digest_4_5;
10690 opti_type = OPTI_TYPE_ZERO_BYTE;
10691 dgst_pos0 = 0;
10692 dgst_pos1 = 1;
10693 dgst_pos2 = 2;
10694 dgst_pos3 = 3;
10695 break;
10696
10697 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10698 salt_type = SALT_TYPE_EMBEDDED;
10699 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10700 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10701 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10702 dgst_size = DGST_SIZE_4_5;
10703 parse_func = veracrypt_parse_hash_327661;
10704 sort_by_digest = sort_by_digest_4_5;
10705 opti_type = OPTI_TYPE_ZERO_BYTE;
10706 dgst_pos0 = 0;
10707 dgst_pos1 = 1;
10708 dgst_pos2 = 2;
10709 dgst_pos3 = 3;
10710 break;
10711
10712 case 13751: hash_type = HASH_TYPE_SHA256;
10713 salt_type = SALT_TYPE_EMBEDDED;
10714 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10715 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10716 kern_type = KERN_TYPE_VCSHA256_XTS512;
10717 dgst_size = DGST_SIZE_4_8;
10718 parse_func = veracrypt_parse_hash_500000;
10719 sort_by_digest = sort_by_digest_4_8;
10720 opti_type = OPTI_TYPE_ZERO_BYTE;
10721 dgst_pos0 = 0;
10722 dgst_pos1 = 1;
10723 dgst_pos2 = 2;
10724 dgst_pos3 = 3;
10725 break;
10726
10727 case 13752: hash_type = HASH_TYPE_SHA256;
10728 salt_type = SALT_TYPE_EMBEDDED;
10729 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10730 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10731 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10732 dgst_size = DGST_SIZE_4_8;
10733 parse_func = veracrypt_parse_hash_500000;
10734 sort_by_digest = sort_by_digest_4_8;
10735 opti_type = OPTI_TYPE_ZERO_BYTE;
10736 dgst_pos0 = 0;
10737 dgst_pos1 = 1;
10738 dgst_pos2 = 2;
10739 dgst_pos3 = 3;
10740 break;
10741
10742 case 13753: hash_type = HASH_TYPE_SHA256;
10743 salt_type = SALT_TYPE_EMBEDDED;
10744 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10745 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10746 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10747 dgst_size = DGST_SIZE_4_8;
10748 parse_func = veracrypt_parse_hash_500000;
10749 sort_by_digest = sort_by_digest_4_8;
10750 opti_type = OPTI_TYPE_ZERO_BYTE;
10751 dgst_pos0 = 0;
10752 dgst_pos1 = 1;
10753 dgst_pos2 = 2;
10754 dgst_pos3 = 3;
10755 break;
10756
10757 case 13761: hash_type = HASH_TYPE_SHA256;
10758 salt_type = SALT_TYPE_EMBEDDED;
10759 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10760 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10761 kern_type = KERN_TYPE_VCSHA256_XTS512;
10762 dgst_size = DGST_SIZE_4_8;
10763 parse_func = veracrypt_parse_hash_200000;
10764 sort_by_digest = sort_by_digest_4_8;
10765 opti_type = OPTI_TYPE_ZERO_BYTE;
10766 dgst_pos0 = 0;
10767 dgst_pos1 = 1;
10768 dgst_pos2 = 2;
10769 dgst_pos3 = 3;
10770 break;
10771
10772 case 13762: hash_type = HASH_TYPE_SHA256;
10773 salt_type = SALT_TYPE_EMBEDDED;
10774 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10775 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10776 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10777 dgst_size = DGST_SIZE_4_8;
10778 parse_func = veracrypt_parse_hash_200000;
10779 sort_by_digest = sort_by_digest_4_8;
10780 opti_type = OPTI_TYPE_ZERO_BYTE;
10781 dgst_pos0 = 0;
10782 dgst_pos1 = 1;
10783 dgst_pos2 = 2;
10784 dgst_pos3 = 3;
10785 break;
10786
10787 case 13763: hash_type = HASH_TYPE_SHA256;
10788 salt_type = SALT_TYPE_EMBEDDED;
10789 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10790 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10791 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10792 dgst_size = DGST_SIZE_4_8;
10793 parse_func = veracrypt_parse_hash_200000;
10794 sort_by_digest = sort_by_digest_4_8;
10795 opti_type = OPTI_TYPE_ZERO_BYTE;
10796 dgst_pos0 = 0;
10797 dgst_pos1 = 1;
10798 dgst_pos2 = 2;
10799 dgst_pos3 = 3;
10800 break;
10801
10802
10803 default: usage_mini_print (PROGNAME); return (-1);
10804 }
10805
10806 /**
10807 * parser
10808 */
10809
10810 data.parse_func = parse_func;
10811
10812 /**
10813 * misc stuff
10814 */
10815
10816 if (hex_salt)
10817 {
10818 if (salt_type == SALT_TYPE_INTERN)
10819 {
10820 opts_type |= OPTS_TYPE_ST_HEX;
10821 }
10822 else
10823 {
10824 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10825
10826 return (-1);
10827 }
10828 }
10829
10830 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10831 | (salt_type == SALT_TYPE_EXTERN)
10832 | (salt_type == SALT_TYPE_EMBEDDED)
10833 | (salt_type == SALT_TYPE_VIRTUAL));
10834
10835 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10836
10837 data.hash_type = hash_type;
10838 data.attack_mode = attack_mode;
10839 data.attack_kern = attack_kern;
10840 data.attack_exec = attack_exec;
10841 data.kern_type = kern_type;
10842 data.opts_type = opts_type;
10843 data.dgst_size = dgst_size;
10844 data.salt_type = salt_type;
10845 data.isSalted = isSalted;
10846 data.sort_by_digest = sort_by_digest;
10847 data.dgst_pos0 = dgst_pos0;
10848 data.dgst_pos1 = dgst_pos1;
10849 data.dgst_pos2 = dgst_pos2;
10850 data.dgst_pos3 = dgst_pos3;
10851
10852 esalt_size = 0;
10853
10854 switch (hash_mode)
10855 {
10856 case 2500: esalt_size = sizeof (wpa_t); break;
10857 case 5300: esalt_size = sizeof (ikepsk_t); break;
10858 case 5400: esalt_size = sizeof (ikepsk_t); break;
10859 case 5500: esalt_size = sizeof (netntlm_t); break;
10860 case 5600: esalt_size = sizeof (netntlm_t); break;
10861 case 6211: esalt_size = sizeof (tc_t); break;
10862 case 6212: esalt_size = sizeof (tc_t); break;
10863 case 6213: esalt_size = sizeof (tc_t); break;
10864 case 6221: esalt_size = sizeof (tc_t); break;
10865 case 6222: esalt_size = sizeof (tc_t); break;
10866 case 6223: esalt_size = sizeof (tc_t); break;
10867 case 6231: esalt_size = sizeof (tc_t); break;
10868 case 6232: esalt_size = sizeof (tc_t); break;
10869 case 6233: esalt_size = sizeof (tc_t); break;
10870 case 6241: esalt_size = sizeof (tc_t); break;
10871 case 6242: esalt_size = sizeof (tc_t); break;
10872 case 6243: esalt_size = sizeof (tc_t); break;
10873 case 6600: esalt_size = sizeof (agilekey_t); break;
10874 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10875 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10876 case 7300: esalt_size = sizeof (rakp_t); break;
10877 case 7500: esalt_size = sizeof (krb5pa_t); break;
10878 case 8200: esalt_size = sizeof (cloudkey_t); break;
10879 case 8800: esalt_size = sizeof (androidfde_t); break;
10880 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10881 case 9400: esalt_size = sizeof (office2007_t); break;
10882 case 9500: esalt_size = sizeof (office2010_t); break;
10883 case 9600: esalt_size = sizeof (office2013_t); break;
10884 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10885 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10886 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10887 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10888 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10889 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10890 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10891 case 10200: esalt_size = sizeof (cram_md5_t); break;
10892 case 10400: esalt_size = sizeof (pdf_t); break;
10893 case 10410: esalt_size = sizeof (pdf_t); break;
10894 case 10420: esalt_size = sizeof (pdf_t); break;
10895 case 10500: esalt_size = sizeof (pdf_t); break;
10896 case 10600: esalt_size = sizeof (pdf_t); break;
10897 case 10700: esalt_size = sizeof (pdf_t); break;
10898 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10899 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10900 case 11400: esalt_size = sizeof (sip_t); break;
10901 case 11600: esalt_size = sizeof (seven_zip_t); break;
10902 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10903 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10904 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10905 case 13000: esalt_size = sizeof (rar5_t); break;
10906 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10907 case 13400: esalt_size = sizeof (keepass_t); break;
10908 case 13500: esalt_size = sizeof (pstoken_t); break;
10909 case 13600: esalt_size = sizeof (zip2_t); break;
10910 case 13711: esalt_size = sizeof (tc_t); break;
10911 case 13712: esalt_size = sizeof (tc_t); break;
10912 case 13713: esalt_size = sizeof (tc_t); break;
10913 case 13721: esalt_size = sizeof (tc_t); break;
10914 case 13722: esalt_size = sizeof (tc_t); break;
10915 case 13723: esalt_size = sizeof (tc_t); break;
10916 case 13731: esalt_size = sizeof (tc_t); break;
10917 case 13732: esalt_size = sizeof (tc_t); break;
10918 case 13733: esalt_size = sizeof (tc_t); break;
10919 case 13741: esalt_size = sizeof (tc_t); break;
10920 case 13742: esalt_size = sizeof (tc_t); break;
10921 case 13743: esalt_size = sizeof (tc_t); break;
10922 case 13751: esalt_size = sizeof (tc_t); break;
10923 case 13752: esalt_size = sizeof (tc_t); break;
10924 case 13753: esalt_size = sizeof (tc_t); break;
10925 case 13761: esalt_size = sizeof (tc_t); break;
10926 case 13762: esalt_size = sizeof (tc_t); break;
10927 case 13763: esalt_size = sizeof (tc_t); break;
10928 }
10929
10930 data.esalt_size = esalt_size;
10931
10932 /**
10933 * choose dictionary parser
10934 */
10935
10936 if (hash_type == HASH_TYPE_LM)
10937 {
10938 get_next_word_func = get_next_word_lm;
10939 }
10940 else if (opts_type & OPTS_TYPE_PT_UPPER)
10941 {
10942 get_next_word_func = get_next_word_uc;
10943 }
10944 else
10945 {
10946 get_next_word_func = get_next_word_std;
10947 }
10948
10949 /**
10950 * dictstat
10951 */
10952
10953 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10954
10955 #ifdef _POSIX
10956 size_t dictstat_nmemb = 0;
10957 #endif
10958
10959 #ifdef _WIN
10960 uint dictstat_nmemb = 0;
10961 #endif
10962
10963 char dictstat[256] = { 0 };
10964
10965 FILE *dictstat_fp = NULL;
10966
10967 if (keyspace == 0)
10968 {
10969 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10970
10971 dictstat_fp = fopen (dictstat, "rb");
10972
10973 if (dictstat_fp)
10974 {
10975 #ifdef _POSIX
10976 struct stat tmpstat;
10977
10978 fstat (fileno (dictstat_fp), &tmpstat);
10979 #endif
10980
10981 #ifdef _WIN
10982 struct stat64 tmpstat;
10983
10984 _fstat64 (fileno (dictstat_fp), &tmpstat);
10985 #endif
10986
10987 if (tmpstat.st_mtime < COMPTIME)
10988 {
10989 /* with v0.15 the format changed so we have to ensure user is using a good version
10990 since there is no version-header in the dictstat file */
10991
10992 fclose (dictstat_fp);
10993
10994 unlink (dictstat);
10995 }
10996 else
10997 {
10998 while (!feof (dictstat_fp))
10999 {
11000 dictstat_t d;
11001
11002 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11003
11004 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11005
11006 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11007 {
11008 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11009
11010 return -1;
11011 }
11012 }
11013
11014 fclose (dictstat_fp);
11015 }
11016 }
11017 }
11018
11019 /**
11020 * potfile
11021 */
11022
11023 char potfile[256] = { 0 };
11024
11025 if (potfile_path == NULL)
11026 {
11027 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11028 }
11029 else
11030 {
11031 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11032 }
11033
11034 data.pot_fp = NULL;
11035
11036 FILE *out_fp = NULL;
11037 FILE *pot_fp = NULL;
11038
11039 if (show == 1 || left == 1)
11040 {
11041 pot_fp = fopen (potfile, "rb");
11042
11043 if (pot_fp == NULL)
11044 {
11045 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11046
11047 return (-1);
11048 }
11049
11050 if (outfile != NULL)
11051 {
11052 if ((out_fp = fopen (outfile, "ab")) == NULL)
11053 {
11054 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11055
11056 fclose (pot_fp);
11057
11058 return (-1);
11059 }
11060 }
11061 else
11062 {
11063 out_fp = stdout;
11064 }
11065 }
11066 else
11067 {
11068 if (potfile_disable == 0)
11069 {
11070 pot_fp = fopen (potfile, "ab");
11071
11072 if (pot_fp == NULL)
11073 {
11074 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11075
11076 return (-1);
11077 }
11078
11079 data.pot_fp = pot_fp;
11080 }
11081 }
11082
11083 pot_t *pot = NULL;
11084
11085 uint pot_cnt = 0;
11086 uint pot_avail = 0;
11087
11088 if (show == 1 || left == 1)
11089 {
11090 SUPPRESS_OUTPUT = 1;
11091
11092 pot_avail = count_lines (pot_fp);
11093
11094 rewind (pot_fp);
11095
11096 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11097
11098 uint pot_hashes_avail = 0;
11099
11100 uint line_num = 0;
11101
11102 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11103
11104 while (!feof (pot_fp))
11105 {
11106 line_num++;
11107
11108 int line_len = fgetl (pot_fp, line_buf);
11109
11110 if (line_len == 0) continue;
11111
11112 char *plain_buf = line_buf + line_len;
11113
11114 pot_t *pot_ptr = &pot[pot_cnt];
11115
11116 hash_t *hashes_buf = &pot_ptr->hash;
11117
11118 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11119 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11120
11121 if (pot_cnt == pot_hashes_avail)
11122 {
11123 uint pos = 0;
11124
11125 for (pos = 0; pos < INCR_POT; pos++)
11126 {
11127 if ((pot_cnt + pos) >= pot_avail) break;
11128
11129 pot_t *tmp_pot = &pot[pot_cnt + pos];
11130
11131 hash_t *tmp_hash = &tmp_pot->hash;
11132
11133 tmp_hash->digest = mymalloc (dgst_size);
11134
11135 if (isSalted)
11136 {
11137 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11138 }
11139
11140 if (esalt_size)
11141 {
11142 tmp_hash->esalt = mymalloc (esalt_size);
11143 }
11144
11145 pot_hashes_avail++;
11146 }
11147 }
11148
11149 int plain_len = 0;
11150
11151 int parser_status;
11152
11153 int iter = MAX_CUT_TRIES;
11154
11155 do
11156 {
11157 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11158 {
11159 if (line_buf[i] == ':')
11160 {
11161 line_len--;
11162
11163 break;
11164 }
11165 }
11166
11167 if (data.hash_mode != 2500)
11168 {
11169 parser_status = parse_func (line_buf, line_len, hashes_buf);
11170 }
11171 else
11172 {
11173 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11174
11175 if (line_len > max_salt_size)
11176 {
11177 parser_status = PARSER_GLOBAL_LENGTH;
11178 }
11179 else
11180 {
11181 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11182
11183 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11184
11185 hashes_buf->salt->salt_len = line_len;
11186
11187 parser_status = PARSER_OK;
11188 }
11189 }
11190
11191 // if NOT parsed without error, we add the ":" to the plain
11192
11193 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11194 {
11195 plain_len++;
11196 plain_buf--;
11197 }
11198
11199 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11200
11201 if (parser_status < PARSER_GLOBAL_ZERO)
11202 {
11203 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11204
11205 continue;
11206 }
11207
11208 if (plain_len >= 255) continue;
11209
11210 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11211
11212 pot_ptr->plain_len = plain_len;
11213
11214 pot_cnt++;
11215 }
11216
11217 myfree (line_buf);
11218
11219 fclose (pot_fp);
11220
11221 SUPPRESS_OUTPUT = 0;
11222
11223 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11224 }
11225
11226 /**
11227 * word len
11228 */
11229
11230 uint pw_min = PW_MIN;
11231 uint pw_max = PW_MAX;
11232
11233 switch (hash_mode)
11234 {
11235 case 125: if (pw_max > 32) pw_max = 32;
11236 break;
11237 case 400: if (pw_max > 40) pw_max = 40;
11238 break;
11239 case 500: if (pw_max > 16) pw_max = 16;
11240 break;
11241 case 1500: if (pw_max > 8) pw_max = 8;
11242 break;
11243 case 1600: if (pw_max > 16) pw_max = 16;
11244 break;
11245 case 1800: if (pw_max > 16) pw_max = 16;
11246 break;
11247 case 2100: if (pw_max > 16) pw_max = 16;
11248 break;
11249 case 2500: if (pw_min < 8) pw_min = 8;
11250 break;
11251 case 3000: if (pw_max > 7) pw_max = 7;
11252 break;
11253 case 5200: if (pw_max > 24) pw_max = 24;
11254 break;
11255 case 5800: if (pw_max > 16) pw_max = 16;
11256 break;
11257 case 6300: if (pw_max > 16) pw_max = 16;
11258 break;
11259 case 7400: if (pw_max > 16) pw_max = 16;
11260 break;
11261 case 7500: if (pw_max > 8) pw_max = 8;
11262 break;
11263 case 7900: if (pw_max > 48) pw_max = 48;
11264 break;
11265 case 8500: if (pw_max > 8) pw_max = 8;
11266 break;
11267 case 8600: if (pw_max > 16) pw_max = 16;
11268 break;
11269 case 9710: pw_min = 5;
11270 pw_max = 5;
11271 break;
11272 case 9810: pw_min = 5;
11273 pw_max = 5;
11274 break;
11275 case 10410: pw_min = 5;
11276 pw_max = 5;
11277 break;
11278 case 10300: if (pw_max < 3) pw_min = 3;
11279 if (pw_max > 40) pw_max = 40;
11280 break;
11281 case 10500: if (pw_max < 3) pw_min = 3;
11282 if (pw_max > 40) pw_max = 40;
11283 break;
11284 case 10700: if (pw_max > 16) pw_max = 16;
11285 break;
11286 case 11300: if (pw_max > 40) pw_max = 40;
11287 break;
11288 case 11600: if (pw_max > 32) pw_max = 32;
11289 break;
11290 case 12500: if (pw_max > 20) pw_max = 20;
11291 break;
11292 case 12800: if (pw_max > 24) pw_max = 24;
11293 break;
11294 }
11295
11296 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11297 {
11298 switch (attack_kern)
11299 {
11300 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11301 break;
11302 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11303 break;
11304 }
11305 }
11306
11307 /**
11308 * charsets : keep them together for more easy maintainnce
11309 */
11310
11311 cs_t mp_sys[6] = { { { 0 }, 0 } };
11312 cs_t mp_usr[4] = { { { 0 }, 0 } };
11313
11314 mp_setup_sys (mp_sys);
11315
11316 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11317 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11318 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11319 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11320
11321 /**
11322 * load hashes, part I: find input mode, count hashes
11323 */
11324
11325 uint hashlist_mode = 0;
11326 uint hashlist_format = HLFMT_HASHCAT;
11327
11328 uint hashes_avail = 0;
11329
11330 if (benchmark == 0)
11331 {
11332 struct stat f;
11333
11334 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11335
11336 if ((hash_mode == 2500) ||
11337 (hash_mode == 5200) ||
11338 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11339 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11340 (hash_mode == 9000))
11341 {
11342 hashlist_mode = HL_MODE_ARG;
11343
11344 char *hashfile = myargv[optind];
11345
11346 data.hashfile = hashfile;
11347
11348 logfile_top_var_string ("target", hashfile);
11349 }
11350
11351 if (hashlist_mode == HL_MODE_ARG)
11352 {
11353 if (hash_mode == 2500)
11354 {
11355 struct stat st;
11356
11357 if (stat (data.hashfile, &st) == -1)
11358 {
11359 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11360
11361 return (-1);
11362 }
11363
11364 hashes_avail = st.st_size / sizeof (hccap_t);
11365 }
11366 else
11367 {
11368 hashes_avail = 1;
11369 }
11370 }
11371 else if (hashlist_mode == HL_MODE_FILE)
11372 {
11373 char *hashfile = myargv[optind];
11374
11375 data.hashfile = hashfile;
11376
11377 logfile_top_var_string ("target", hashfile);
11378
11379 FILE *fp = NULL;
11380
11381 if ((fp = fopen (hashfile, "rb")) == NULL)
11382 {
11383 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11384
11385 return (-1);
11386 }
11387
11388 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11389
11390 hashes_avail = count_lines (fp);
11391
11392 rewind (fp);
11393
11394 if (hashes_avail == 0)
11395 {
11396 log_error ("ERROR: hashfile is empty or corrupt");
11397
11398 fclose (fp);
11399
11400 return (-1);
11401 }
11402
11403 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11404
11405 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11406 {
11407 log_error ("ERROR: remove not supported in native hashfile-format mode");
11408
11409 fclose (fp);
11410
11411 return (-1);
11412 }
11413
11414 fclose (fp);
11415 }
11416 }
11417 else
11418 {
11419 hashlist_mode = HL_MODE_ARG;
11420
11421 hashes_avail = 1;
11422 }
11423
11424 if (hash_mode == 3000) hashes_avail *= 2;
11425
11426 data.hashlist_mode = hashlist_mode;
11427 data.hashlist_format = hashlist_format;
11428
11429 logfile_top_uint (hashlist_mode);
11430 logfile_top_uint (hashlist_format);
11431
11432 /**
11433 * load hashes, part II: allocate required memory, set pointers
11434 */
11435
11436 hash_t *hashes_buf = NULL;
11437 void *digests_buf = NULL;
11438 salt_t *salts_buf = NULL;
11439 void *esalts_buf = NULL;
11440
11441 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11442
11443 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11444
11445 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11446 {
11447 u32 hash_pos;
11448
11449 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11450 {
11451 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11452
11453 hashes_buf[hash_pos].hash_info = hash_info;
11454
11455 if (username && (remove || show || left))
11456 {
11457 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11458 }
11459
11460 if (benchmark)
11461 {
11462 hash_info->orighash = (char *) mymalloc (256);
11463 }
11464 }
11465 }
11466
11467 if (isSalted)
11468 {
11469 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11470
11471 if (esalt_size)
11472 {
11473 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11474 }
11475 }
11476 else
11477 {
11478 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11479 }
11480
11481 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11482 {
11483 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11484
11485 if (isSalted)
11486 {
11487 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11488
11489 if (esalt_size)
11490 {
11491 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11492 }
11493 }
11494 else
11495 {
11496 hashes_buf[hash_pos].salt = &salts_buf[0];
11497 }
11498 }
11499
11500 /**
11501 * load hashes, part III: parse hashes or generate them if benchmark
11502 */
11503
11504 uint hashes_cnt = 0;
11505
11506 if (benchmark == 0)
11507 {
11508 if (keyspace == 1)
11509 {
11510 // useless to read hash file for keyspace, cheat a little bit w/ optind
11511 }
11512 else if (hashes_avail == 0)
11513 {
11514 }
11515 else if (hashlist_mode == HL_MODE_ARG)
11516 {
11517 char *input_buf = myargv[optind];
11518
11519 uint input_len = strlen (input_buf);
11520
11521 logfile_top_var_string ("target", input_buf);
11522
11523 char *hash_buf = NULL;
11524 int hash_len = 0;
11525
11526 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11527
11528 bool hash_fmt_error = 0;
11529
11530 if (hash_len < 1) hash_fmt_error = 1;
11531 if (hash_buf == NULL) hash_fmt_error = 1;
11532
11533 if (hash_fmt_error)
11534 {
11535 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11536 }
11537 else
11538 {
11539 if (opts_type & OPTS_TYPE_HASH_COPY)
11540 {
11541 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11542
11543 hash_info_tmp->orighash = mystrdup (hash_buf);
11544 }
11545
11546 if (isSalted)
11547 {
11548 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11549 }
11550
11551 int parser_status = PARSER_OK;
11552
11553 if (hash_mode == 2500)
11554 {
11555 if (hash_len == 0)
11556 {
11557 log_error ("ERROR: hccap file not specified");
11558
11559 return (-1);
11560 }
11561
11562 hashlist_mode = HL_MODE_FILE;
11563
11564 data.hashlist_mode = hashlist_mode;
11565
11566 FILE *fp = fopen (hash_buf, "rb");
11567
11568 if (fp == NULL)
11569 {
11570 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11571
11572 return (-1);
11573 }
11574
11575 if (hashes_avail < 1)
11576 {
11577 log_error ("ERROR: hccap file is empty or corrupt");
11578
11579 fclose (fp);
11580
11581 return (-1);
11582 }
11583
11584 uint hccap_size = sizeof (hccap_t);
11585
11586 char *in = (char *) mymalloc (hccap_size);
11587
11588 while (!feof (fp))
11589 {
11590 int n = fread (in, hccap_size, 1, fp);
11591
11592 if (n != 1)
11593 {
11594 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11595
11596 break;
11597 }
11598
11599 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11600
11601 if (parser_status != PARSER_OK)
11602 {
11603 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11604
11605 continue;
11606 }
11607
11608 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11609
11610 if ((show == 1) || (left == 1))
11611 {
11612 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11613
11614 char *salt_ptr = (char *) tmp_salt->salt_buf;
11615
11616 int cur_pos = tmp_salt->salt_len;
11617 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11618
11619 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11620
11621 // do the appending task
11622
11623 snprintf (salt_ptr + cur_pos,
11624 rem_len,
11625 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11626 wpa->orig_mac1[0],
11627 wpa->orig_mac1[1],
11628 wpa->orig_mac1[2],
11629 wpa->orig_mac1[3],
11630 wpa->orig_mac1[4],
11631 wpa->orig_mac1[5],
11632 wpa->orig_mac2[0],
11633 wpa->orig_mac2[1],
11634 wpa->orig_mac2[2],
11635 wpa->orig_mac2[3],
11636 wpa->orig_mac2[4],
11637 wpa->orig_mac2[5]);
11638
11639 // memset () the remaining part of the salt
11640
11641 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11642 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11643
11644 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11645
11646 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11647 }
11648
11649 if (show == 1) handle_show_request (pot, pot_cnt, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf, out_fp);
11650 if (left == 1) handle_left_request (pot, pot_cnt, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf, out_fp);
11651
11652 hashes_cnt++;
11653 }
11654
11655 fclose (fp);
11656
11657 myfree (in);
11658 }
11659 else if (hash_mode == 3000)
11660 {
11661 if (hash_len == 32)
11662 {
11663 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11664
11665 hash_t *lm_hash_left = NULL;
11666
11667 if (parser_status == PARSER_OK)
11668 {
11669 lm_hash_left = &hashes_buf[hashes_cnt];
11670
11671 hashes_cnt++;
11672 }
11673 else
11674 {
11675 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11676 }
11677
11678 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11679
11680 hash_t *lm_hash_right = NULL;
11681
11682 if (parser_status == PARSER_OK)
11683 {
11684 lm_hash_right = &hashes_buf[hashes_cnt];
11685
11686 hashes_cnt++;
11687 }
11688 else
11689 {
11690 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11691 }
11692
11693 // show / left
11694
11695 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11696 {
11697 if (show == 1) handle_show_request_lm (pot, pot_cnt, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11698 if (left == 1) handle_left_request_lm (pot, pot_cnt, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11699 }
11700 }
11701 else
11702 {
11703 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11704
11705 if (parser_status == PARSER_OK)
11706 {
11707 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11708 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11709 }
11710
11711 if (parser_status == PARSER_OK)
11712 {
11713 hashes_cnt++;
11714 }
11715 else
11716 {
11717 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11718 }
11719 }
11720 }
11721 else
11722 {
11723 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11724
11725 if (parser_status == PARSER_OK)
11726 {
11727 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11728 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11729 }
11730
11731 if (parser_status == PARSER_OK)
11732 {
11733 hashes_cnt++;
11734 }
11735 else
11736 {
11737 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11738 }
11739 }
11740 }
11741 }
11742 else if (hashlist_mode == HL_MODE_FILE)
11743 {
11744 char *hashfile = data.hashfile;
11745
11746 FILE *fp;
11747
11748 if ((fp = fopen (hashfile, "rb")) == NULL)
11749 {
11750 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11751
11752 return (-1);
11753 }
11754
11755 uint line_num = 0;
11756
11757 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11758
11759 while (!feof (fp))
11760 {
11761 line_num++;
11762
11763 int line_len = fgetl (fp, line_buf);
11764
11765 if (line_len == 0) continue;
11766
11767 char *hash_buf = NULL;
11768 int hash_len = 0;
11769
11770 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11771
11772 bool hash_fmt_error = 0;
11773
11774 if (hash_len < 1) hash_fmt_error = 1;
11775 if (hash_buf == NULL) hash_fmt_error = 1;
11776
11777 if (hash_fmt_error)
11778 {
11779 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11780
11781 continue;
11782 }
11783
11784 if (username)
11785 {
11786 char *user_buf = NULL;
11787 int user_len = 0;
11788
11789 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11790
11791 if (remove || show)
11792 {
11793 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11794
11795 *user = (user_t *) mymalloc (sizeof (user_t));
11796
11797 user_t *user_ptr = *user;
11798
11799 if (user_buf != NULL)
11800 {
11801 user_ptr->user_name = mystrdup (user_buf);
11802 }
11803 else
11804 {
11805 user_ptr->user_name = mystrdup ("");
11806 }
11807
11808 user_ptr->user_len = user_len;
11809 }
11810 }
11811
11812 if (opts_type & OPTS_TYPE_HASH_COPY)
11813 {
11814 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11815
11816 hash_info_tmp->orighash = mystrdup (hash_buf);
11817 }
11818
11819 if (isSalted)
11820 {
11821 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11822 }
11823
11824 if (hash_mode == 3000)
11825 {
11826 if (hash_len == 32)
11827 {
11828 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11829
11830 if (parser_status < PARSER_GLOBAL_ZERO)
11831 {
11832 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11833
11834 continue;
11835 }
11836
11837 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11838
11839 hashes_cnt++;
11840
11841 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11842
11843 if (parser_status < PARSER_GLOBAL_ZERO)
11844 {
11845 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11846
11847 continue;
11848 }
11849
11850 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11851
11852 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11853
11854 hashes_cnt++;
11855
11856 // show / left
11857
11858 if (show == 1) handle_show_request_lm (pot, pot_cnt, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11859 if (left == 1) handle_left_request_lm (pot, pot_cnt, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11860 }
11861 else
11862 {
11863 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11864
11865 if (parser_status < PARSER_GLOBAL_ZERO)
11866 {
11867 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11868
11869 continue;
11870 }
11871
11872 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11873
11874 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11875 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11876
11877 hashes_cnt++;
11878 }
11879 }
11880 else
11881 {
11882 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11883
11884 if (parser_status < PARSER_GLOBAL_ZERO)
11885 {
11886 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11887
11888 continue;
11889 }
11890
11891 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11892
11893 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11894 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11895
11896 hashes_cnt++;
11897 }
11898 }
11899
11900 myfree (line_buf);
11901
11902 fclose (fp);
11903
11904 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11905
11906 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11907 }
11908 }
11909 else
11910 {
11911 if (isSalted)
11912 {
11913 hashes_buf[0].salt->salt_len = 8;
11914
11915 // special salt handling
11916
11917 switch (hash_mode)
11918 {
11919 case 1500: hashes_buf[0].salt->salt_len = 2;
11920 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11921 break;
11922 case 1731: hashes_buf[0].salt->salt_len = 4;
11923 break;
11924 case 2410: hashes_buf[0].salt->salt_len = 4;
11925 break;
11926 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11927 break;
11928 case 3100: hashes_buf[0].salt->salt_len = 1;
11929 break;
11930 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11931 break;
11932 case 5800: hashes_buf[0].salt->salt_len = 16;
11933 break;
11934 case 6800: hashes_buf[0].salt->salt_len = 32;
11935 break;
11936 case 8400: hashes_buf[0].salt->salt_len = 40;
11937 break;
11938 case 8800: hashes_buf[0].salt->salt_len = 16;
11939 break;
11940 case 8900: hashes_buf[0].salt->salt_len = 16;
11941 hashes_buf[0].salt->scrypt_N = 1024;
11942 hashes_buf[0].salt->scrypt_r = 1;
11943 hashes_buf[0].salt->scrypt_p = 1;
11944 break;
11945 case 9100: hashes_buf[0].salt->salt_len = 16;
11946 break;
11947 case 9300: hashes_buf[0].salt->salt_len = 14;
11948 hashes_buf[0].salt->scrypt_N = 16384;
11949 hashes_buf[0].salt->scrypt_r = 1;
11950 hashes_buf[0].salt->scrypt_p = 1;
11951 break;
11952 case 9400: hashes_buf[0].salt->salt_len = 16;
11953 break;
11954 case 9500: hashes_buf[0].salt->salt_len = 16;
11955 break;
11956 case 9600: hashes_buf[0].salt->salt_len = 16;
11957 break;
11958 case 9700: hashes_buf[0].salt->salt_len = 16;
11959 break;
11960 case 9710: hashes_buf[0].salt->salt_len = 16;
11961 break;
11962 case 9720: hashes_buf[0].salt->salt_len = 16;
11963 break;
11964 case 9800: hashes_buf[0].salt->salt_len = 16;
11965 break;
11966 case 9810: hashes_buf[0].salt->salt_len = 16;
11967 break;
11968 case 9820: hashes_buf[0].salt->salt_len = 16;
11969 break;
11970 case 10300: hashes_buf[0].salt->salt_len = 12;
11971 break;
11972 case 11500: hashes_buf[0].salt->salt_len = 4;
11973 break;
11974 case 11600: hashes_buf[0].salt->salt_len = 4;
11975 break;
11976 case 12400: hashes_buf[0].salt->salt_len = 4;
11977 break;
11978 case 12500: hashes_buf[0].salt->salt_len = 8;
11979 break;
11980 case 12600: hashes_buf[0].salt->salt_len = 64;
11981 break;
11982 }
11983
11984 // special esalt handling
11985
11986 switch (hash_mode)
11987 {
11988 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11989 break;
11990 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11991 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11992 break;
11993 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11994 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11995 break;
11996 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11997 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11998 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11999 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12000 break;
12001 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12002 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12003 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12004 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12005 break;
12006 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12007 break;
12008 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12009 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12010 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12011 break;
12012 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12013 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12014 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12015 break;
12016 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12017 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12018 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12019 break;
12020 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12021 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12022 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12023 break;
12024 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12025 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12026 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12027 break;
12028 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12029 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12030 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12031 break;
12032 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12033 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12034 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12035 break;
12036 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12037 break;
12038 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12039 break;
12040 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12041 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12042 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12043 break;
12044 }
12045 }
12046
12047 // set hashfile
12048
12049 switch (hash_mode)
12050 {
12051 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12052 break;
12053 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12054 break;
12055 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12056 break;
12057 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12058 break;
12059 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12060 break;
12061 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12062 break;
12063 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12064 break;
12065 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12066 break;
12067 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12068 break;
12069 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12070 break;
12071 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12072 break;
12073 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12074 break;
12075 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12076 break;
12077 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12078 break;
12079 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12080 break;
12081 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12082 break;
12083 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12084 break;
12085 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12086 break;
12087 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12088 break;
12089 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12090 break;
12091 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12092 break;
12093 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12094 break;
12095 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12096 break;
12097 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12098 break;
12099 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12100 break;
12101 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12102 break;
12103 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12104 break;
12105 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12106 break;
12107 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12108 break;
12109 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12110 break;
12111 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12112 break;
12113 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12114 break;
12115 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12116 break;
12117 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12118 break;
12119 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12120 break;
12121 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12122 break;
12123 }
12124
12125 // set default iterations
12126
12127 switch (hash_mode)
12128 {
12129 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12130 break;
12131 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12132 break;
12133 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12134 break;
12135 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12136 break;
12137 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12138 break;
12139 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12140 break;
12141 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12142 break;
12143 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12144 break;
12145 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12146 break;
12147 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12148 break;
12149 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12150 break;
12151 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12152 break;
12153 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12154 break;
12155 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12156 break;
12157 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12158 break;
12159 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12160 break;
12161 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12162 break;
12163 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12164 break;
12165 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12166 break;
12167 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12168 break;
12169 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12170 break;
12171 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12172 break;
12173 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12174 break;
12175 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12176 break;
12177 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12178 break;
12179 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12180 break;
12181 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12182 break;
12183 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12184 break;
12185 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12186 break;
12187 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12188 break;
12189 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12190 break;
12191 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12192 break;
12193 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12194 break;
12195 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12196 break;
12197 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12198 break;
12199 case 8900: hashes_buf[0].salt->salt_iter = 1;
12200 break;
12201 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12202 break;
12203 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12204 break;
12205 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12206 break;
12207 case 9300: hashes_buf[0].salt->salt_iter = 1;
12208 break;
12209 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12210 break;
12211 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12212 break;
12213 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12214 break;
12215 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12216 break;
12217 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12218 break;
12219 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12220 break;
12221 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12222 break;
12223 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12224 break;
12225 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12226 break;
12227 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12228 break;
12229 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12230 break;
12231 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12232 break;
12233 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12234 break;
12235 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12236 break;
12237 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12238 break;
12239 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12240 break;
12241 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12242 break;
12243 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12244 break;
12245 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12246 break;
12247 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12248 break;
12249 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12250 break;
12251 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12252 break;
12253 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12254 break;
12255 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12256 break;
12257 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12258 break;
12259 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12260 break;
12261 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12262 break;
12263 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12264 break;
12265 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12266 break;
12267 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12268 break;
12269 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12270 break;
12271 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12272 break;
12273 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12274 break;
12275 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12276 break;
12277 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12278 break;
12279 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12280 break;
12281 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12282 break;
12283 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12284 break;
12285 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12286 break;
12287 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12288 break;
12289 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12290 break;
12291 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12292 break;
12293 }
12294
12295 hashes_cnt = 1;
12296 }
12297
12298 if (show == 1 || left == 1)
12299 {
12300 for (uint i = 0; i < pot_cnt; i++)
12301 {
12302 pot_t *pot_ptr = &pot[i];
12303
12304 hash_t *hashes_buf = &pot_ptr->hash;
12305
12306 local_free (hashes_buf->digest);
12307
12308 if (isSalted)
12309 {
12310 local_free (hashes_buf->salt);
12311 }
12312 }
12313
12314 local_free (pot);
12315
12316 if (data.quiet == 0) log_info_nn ("");
12317
12318 return (0);
12319 }
12320
12321 if (keyspace == 0)
12322 {
12323 if (hashes_cnt == 0)
12324 {
12325 log_error ("ERROR: No hashes loaded");
12326
12327 return (-1);
12328 }
12329 }
12330
12331 /**
12332 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12333 */
12334
12335 if (data.outfile != NULL)
12336 {
12337 if (data.hashfile != NULL)
12338 {
12339 #ifdef _POSIX
12340 struct stat tmpstat_outfile;
12341 struct stat tmpstat_hashfile;
12342 #endif
12343
12344 #ifdef _WIN
12345 struct stat64 tmpstat_outfile;
12346 struct stat64 tmpstat_hashfile;
12347 #endif
12348
12349 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12350
12351 if (tmp_outfile_fp)
12352 {
12353 #ifdef _POSIX
12354 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12355 #endif
12356
12357 #ifdef _WIN
12358 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12359 #endif
12360
12361 fclose (tmp_outfile_fp);
12362 }
12363
12364 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12365
12366 if (tmp_hashfile_fp)
12367 {
12368 #ifdef _POSIX
12369 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12370 #endif
12371
12372 #ifdef _WIN
12373 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12374 #endif
12375
12376 fclose (tmp_hashfile_fp);
12377 }
12378
12379 if (tmp_outfile_fp && tmp_outfile_fp)
12380 {
12381 tmpstat_outfile.st_mode = 0;
12382 tmpstat_outfile.st_nlink = 0;
12383 tmpstat_outfile.st_uid = 0;
12384 tmpstat_outfile.st_gid = 0;
12385 tmpstat_outfile.st_rdev = 0;
12386 tmpstat_outfile.st_atime = 0;
12387
12388 tmpstat_hashfile.st_mode = 0;
12389 tmpstat_hashfile.st_nlink = 0;
12390 tmpstat_hashfile.st_uid = 0;
12391 tmpstat_hashfile.st_gid = 0;
12392 tmpstat_hashfile.st_rdev = 0;
12393 tmpstat_hashfile.st_atime = 0;
12394
12395 #ifdef _POSIX
12396 tmpstat_outfile.st_blksize = 0;
12397 tmpstat_outfile.st_blocks = 0;
12398
12399 tmpstat_hashfile.st_blksize = 0;
12400 tmpstat_hashfile.st_blocks = 0;
12401 #endif
12402
12403 #ifdef _POSIX
12404 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12405 {
12406 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12407
12408 return (-1);
12409 }
12410 #endif
12411
12412 #ifdef _WIN
12413 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12414 {
12415 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12416
12417 return (-1);
12418 }
12419 #endif
12420 }
12421 }
12422 }
12423
12424 /**
12425 * Remove duplicates
12426 */
12427
12428 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12429
12430 if (isSalted)
12431 {
12432 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12433 }
12434 else
12435 {
12436 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12437 }
12438
12439 uint hashes_cnt_orig = hashes_cnt;
12440
12441 hashes_cnt = 1;
12442
12443 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12444 {
12445 if (isSalted)
12446 {
12447 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12448 {
12449 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12450 }
12451 }
12452 else
12453 {
12454 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12455 }
12456
12457 if (hashes_pos > hashes_cnt)
12458 {
12459 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12460 }
12461
12462 hashes_cnt++;
12463 }
12464
12465 /**
12466 * Potfile removes
12467 */
12468
12469 uint potfile_remove_cracks = 0;
12470
12471 if (potfile_disable == 0)
12472 {
12473 hash_t hash_buf;
12474
12475 hash_buf.digest = mymalloc (dgst_size);
12476 hash_buf.salt = NULL;
12477 hash_buf.esalt = NULL;
12478 hash_buf.hash_info = NULL;
12479 hash_buf.cracked = 0;
12480
12481 if (isSalted)
12482 {
12483 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12484 }
12485
12486 if (esalt_size)
12487 {
12488 hash_buf.esalt = mymalloc (esalt_size);
12489 }
12490
12491 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12492
12493 // no solution for these special hash types (for instane because they use hashfile in output etc)
12494 if ((hash_mode != 5200) &&
12495 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12496 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12497 (hash_mode != 9000))
12498 {
12499 FILE *fp = fopen (potfile, "rb");
12500
12501 if (fp != NULL)
12502 {
12503 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12504
12505 // to be safe work with a copy (because of line_len loop, i etc)
12506 // moved up here because it's easier to handle continue case
12507 // it's just 64kb
12508
12509 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12510
12511 while (!feof (fp))
12512 {
12513 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12514
12515 if (ptr == NULL) break;
12516
12517 int line_len = strlen (line_buf);
12518
12519 if (line_len == 0) continue;
12520
12521 int iter = MAX_CUT_TRIES;
12522
12523 for (int i = line_len - 1; i && iter; i--, line_len--)
12524 {
12525 if (line_buf[i] != ':') continue;
12526
12527 if (isSalted)
12528 {
12529 memset (hash_buf.salt, 0, sizeof (salt_t));
12530 }
12531
12532 hash_t *found = NULL;
12533
12534 if (hash_mode == 6800)
12535 {
12536 if (i < 64) // 64 = 16 * uint in salt_buf[]
12537 {
12538 // manipulate salt_buf
12539 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12540
12541 hash_buf.salt->salt_len = i;
12542
12543 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12544 }
12545 }
12546 else if (hash_mode == 2500)
12547 {
12548 if (i < 64) // 64 = 16 * uint in salt_buf[]
12549 {
12550 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12551 // manipulate salt_buf
12552
12553 memcpy (line_buf_cpy, line_buf, i);
12554
12555 char *mac2_pos = strrchr (line_buf_cpy, ':');
12556
12557 if (mac2_pos == NULL) continue;
12558
12559 mac2_pos[0] = 0;
12560 mac2_pos++;
12561
12562 if (strlen (mac2_pos) != 12) continue;
12563
12564 char *mac1_pos = strrchr (line_buf_cpy, ':');
12565
12566 if (mac1_pos == NULL) continue;
12567
12568 mac1_pos[0] = 0;
12569 mac1_pos++;
12570
12571 if (strlen (mac1_pos) != 12) continue;
12572
12573 uint essid_length = mac1_pos - line_buf_cpy - 1;
12574
12575 // here we need the ESSID
12576 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12577
12578 hash_buf.salt->salt_len = essid_length;
12579
12580 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12581
12582 if (found)
12583 {
12584 wpa_t *wpa = (wpa_t *) found->esalt;
12585
12586 // compare hex string(s) vs binary MAC address(es)
12587
12588 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12589 {
12590 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12591 {
12592 found = NULL;
12593
12594 break;
12595 }
12596 }
12597
12598 // early skip ;)
12599 if (!found) continue;
12600
12601 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12602 {
12603 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12604 {
12605 found = NULL;
12606
12607 break;
12608 }
12609 }
12610 }
12611 }
12612 }
12613 else
12614 {
12615 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12616
12617 if (parser_status == PARSER_OK)
12618 {
12619 if (isSalted)
12620 {
12621 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12622 }
12623 else
12624 {
12625 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12626 }
12627 }
12628 }
12629
12630 if (found == NULL) continue;
12631
12632 if (!found->cracked) potfile_remove_cracks++;
12633
12634 found->cracked = 1;
12635
12636 if (found) break;
12637
12638 iter--;
12639 }
12640 }
12641
12642 myfree (line_buf_cpy);
12643
12644 myfree (line_buf);
12645
12646 fclose (fp);
12647 }
12648 }
12649
12650 if (esalt_size)
12651 {
12652 local_free (hash_buf.esalt);
12653 }
12654
12655 if (isSalted)
12656 {
12657 local_free (hash_buf.salt);
12658 }
12659
12660 local_free (hash_buf.digest);
12661 }
12662
12663 /**
12664 * Now generate all the buffers required for later
12665 */
12666
12667 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12668
12669 salt_t *salts_buf_new = NULL;
12670 void *esalts_buf_new = NULL;
12671
12672 if (isSalted)
12673 {
12674 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12675
12676 if (esalt_size)
12677 {
12678 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12679 }
12680 }
12681 else
12682 {
12683 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12684 }
12685
12686 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12687
12688 uint digests_cnt = hashes_cnt;
12689 uint digests_done = 0;
12690
12691 size_t size_digests = digests_cnt * dgst_size;
12692 size_t size_shown = digests_cnt * sizeof (uint);
12693
12694 uint *digests_shown = (uint *) mymalloc (size_shown);
12695 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12696
12697 uint salts_cnt = 0;
12698 uint salts_done = 0;
12699
12700 hashinfo_t **hash_info = NULL;
12701
12702 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12703 {
12704 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12705
12706 if (username && (remove || show))
12707 {
12708 uint user_pos;
12709
12710 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12711 {
12712 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12713
12714 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12715 }
12716 }
12717 }
12718
12719 uint *salts_shown = (uint *) mymalloc (size_shown);
12720
12721 salt_t *salt_buf;
12722
12723 {
12724 // copied from inner loop
12725
12726 salt_buf = &salts_buf_new[salts_cnt];
12727
12728 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12729
12730 if (esalt_size)
12731 {
12732 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12733 }
12734
12735 salt_buf->digests_cnt = 0;
12736 salt_buf->digests_done = 0;
12737 salt_buf->digests_offset = 0;
12738
12739 salts_cnt++;
12740 }
12741
12742 if (hashes_buf[0].cracked == 1)
12743 {
12744 digests_shown[0] = 1;
12745
12746 digests_done++;
12747
12748 salt_buf->digests_done++;
12749 }
12750
12751 salt_buf->digests_cnt++;
12752
12753 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12754
12755 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12756 {
12757 hash_info[0] = hashes_buf[0].hash_info;
12758 }
12759
12760 // copy from inner loop
12761
12762 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12763 {
12764 if (isSalted)
12765 {
12766 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12767 {
12768 salt_buf = &salts_buf_new[salts_cnt];
12769
12770 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12771
12772 if (esalt_size)
12773 {
12774 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12775 }
12776
12777 salt_buf->digests_cnt = 0;
12778 salt_buf->digests_done = 0;
12779 salt_buf->digests_offset = hashes_pos;
12780
12781 salts_cnt++;
12782 }
12783 }
12784
12785 if (hashes_buf[hashes_pos].cracked == 1)
12786 {
12787 digests_shown[hashes_pos] = 1;
12788
12789 digests_done++;
12790
12791 salt_buf->digests_done++;
12792 }
12793
12794 salt_buf->digests_cnt++;
12795
12796 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12797
12798 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12799 {
12800 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12801 }
12802 }
12803
12804 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12805 {
12806 salt_t *salt_buf = &salts_buf_new[salt_pos];
12807
12808 if (salt_buf->digests_done == salt_buf->digests_cnt)
12809 {
12810 salts_shown[salt_pos] = 1;
12811
12812 salts_done++;
12813 }
12814
12815 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12816 }
12817
12818 local_free (digests_buf);
12819 local_free (salts_buf);
12820 local_free (esalts_buf);
12821
12822 digests_buf = digests_buf_new;
12823 salts_buf = salts_buf_new;
12824 esalts_buf = esalts_buf_new;
12825
12826 local_free (hashes_buf);
12827
12828 /**
12829 * special modification not set from parser
12830 */
12831
12832 switch (hash_mode)
12833 {
12834 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12835 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12836 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12837 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12838 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12839 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12840 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12841 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12842 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12843 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12844 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12845 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12846 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12847 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12848 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12849 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12850 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12851 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12852 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12853 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12854 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12855 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12856 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12857 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12858 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12859 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12860 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12861 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12862 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12863 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12864 }
12865
12866 if (truecrypt_keyfiles)
12867 {
12868 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12869
12870 char *keyfiles = strdup (truecrypt_keyfiles);
12871
12872 char *keyfile = strtok (keyfiles, ",");
12873
12874 do
12875 {
12876 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12877
12878 } while ((keyfile = strtok (NULL, ",")) != NULL);
12879
12880 free (keyfiles);
12881 }
12882
12883 if (veracrypt_keyfiles)
12884 {
12885 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12886
12887 char *keyfiles = strdup (veracrypt_keyfiles);
12888
12889 char *keyfile = strtok (keyfiles, ",");
12890
12891 do
12892 {
12893 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12894
12895 } while ((keyfile = strtok (NULL, ",")) != NULL);
12896
12897 free (keyfiles);
12898 }
12899
12900 data.digests_cnt = digests_cnt;
12901 data.digests_done = digests_done;
12902 data.digests_buf = digests_buf;
12903 data.digests_shown = digests_shown;
12904 data.digests_shown_tmp = digests_shown_tmp;
12905
12906 data.salts_cnt = salts_cnt;
12907 data.salts_done = salts_done;
12908 data.salts_buf = salts_buf;
12909 data.salts_shown = salts_shown;
12910
12911 data.esalts_buf = esalts_buf;
12912 data.hash_info = hash_info;
12913
12914 /**
12915 * Automatic Optimizers
12916 */
12917
12918 if (salts_cnt == 1)
12919 opti_type |= OPTI_TYPE_SINGLE_SALT;
12920
12921 if (digests_cnt == 1)
12922 opti_type |= OPTI_TYPE_SINGLE_HASH;
12923
12924 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12925 opti_type |= OPTI_TYPE_NOT_ITERATED;
12926
12927 if (attack_mode == ATTACK_MODE_BF)
12928 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12929
12930 data.opti_type = opti_type;
12931
12932 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12933 {
12934 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12935 {
12936 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12937 {
12938 if (opts_type & OPTS_TYPE_ST_ADD80)
12939 {
12940 opts_type &= ~OPTS_TYPE_ST_ADD80;
12941 opts_type |= OPTS_TYPE_PT_ADD80;
12942 }
12943
12944 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12945 {
12946 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12947 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12948 }
12949
12950 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12951 {
12952 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12953 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12954 }
12955 }
12956 }
12957 }
12958
12959 /**
12960 * Some algorithm, like descrypt, can benefit from JIT compilation
12961 */
12962
12963 int force_jit_compilation = -1;
12964
12965 if (hash_mode == 8900)
12966 {
12967 force_jit_compilation = 8900;
12968 }
12969 else if (hash_mode == 9300)
12970 {
12971 force_jit_compilation = 8900;
12972 }
12973 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12974 {
12975 force_jit_compilation = 1500;
12976 }
12977
12978 /**
12979 * generate bitmap tables
12980 */
12981
12982 const uint bitmap_shift1 = 5;
12983 const uint bitmap_shift2 = 13;
12984
12985 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12986
12987 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12988 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12989 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12990 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12991 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12992 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12993 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12994 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12995
12996 uint bitmap_bits;
12997 uint bitmap_nums;
12998 uint bitmap_mask;
12999 uint bitmap_size;
13000
13001 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13002 {
13003 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13004
13005 bitmap_nums = 1 << bitmap_bits;
13006
13007 bitmap_mask = bitmap_nums - 1;
13008
13009 bitmap_size = bitmap_nums * sizeof (uint);
13010
13011 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13012
13013 if (generate_bitmaps (digests_cnt, dgst_size, bitmap_shift1, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, digests_cnt / 2) == 0x7fffffff) continue;
13014 if (generate_bitmaps (digests_cnt, dgst_size, bitmap_shift2, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, digests_cnt / 2) == 0x7fffffff) continue;
13015
13016 break;
13017 }
13018
13019 bitmap_nums = 1 << bitmap_bits;
13020
13021 bitmap_mask = bitmap_nums - 1;
13022
13023 bitmap_size = bitmap_nums * sizeof (uint);
13024
13025 generate_bitmaps (digests_cnt, dgst_size, bitmap_shift1, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, -1);
13026 generate_bitmaps (digests_cnt, dgst_size, bitmap_shift2, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s2_a, bitmap_s2_b, bitmap_s2_c, bitmap_s2_d, -1);
13027
13028 /**
13029 * prepare quick rule
13030 */
13031
13032 data.rule_buf_l = rule_buf_l;
13033 data.rule_buf_r = rule_buf_r;
13034
13035 int rule_len_l = (int) strlen (rule_buf_l);
13036 int rule_len_r = (int) strlen (rule_buf_r);
13037
13038 data.rule_len_l = rule_len_l;
13039 data.rule_len_r = rule_len_r;
13040
13041 /**
13042 * load rules
13043 */
13044
13045 uint *all_kernel_rules_cnt = NULL;
13046
13047 kernel_rule_t **all_kernel_rules_buf = NULL;
13048
13049 if (rp_files_cnt)
13050 {
13051 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13052
13053 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13054 }
13055
13056 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13057
13058 int rule_len = 0;
13059
13060 for (uint i = 0; i < rp_files_cnt; i++)
13061 {
13062 uint kernel_rules_avail = 0;
13063
13064 uint kernel_rules_cnt = 0;
13065
13066 kernel_rule_t *kernel_rules_buf = NULL;
13067
13068 char *rp_file = rp_files[i];
13069
13070 char in[BLOCK_SIZE] = { 0 };
13071 char out[BLOCK_SIZE] = { 0 };
13072
13073 FILE *fp = NULL;
13074
13075 uint rule_line = 0;
13076
13077 if ((fp = fopen (rp_file, "rb")) == NULL)
13078 {
13079 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13080
13081 return (-1);
13082 }
13083
13084 while (!feof (fp))
13085 {
13086 memset (rule_buf, 0, HCBUFSIZ);
13087
13088 rule_len = fgetl (fp, rule_buf);
13089
13090 rule_line++;
13091
13092 if (rule_len == 0) continue;
13093
13094 if (rule_buf[0] == '#') continue;
13095
13096 if (kernel_rules_avail == kernel_rules_cnt)
13097 {
13098 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13099
13100 kernel_rules_avail += INCR_RULES;
13101 }
13102
13103 memset (in, 0, BLOCK_SIZE);
13104 memset (out, 0, BLOCK_SIZE);
13105
13106 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13107
13108 if (result == -1)
13109 {
13110 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13111
13112 continue;
13113 }
13114
13115 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13116 {
13117 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13118
13119 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13120
13121 continue;
13122 }
13123
13124 /* its so slow
13125 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13126 {
13127 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13128
13129 continue;
13130 }
13131 */
13132
13133 kernel_rules_cnt++;
13134 }
13135
13136 fclose (fp);
13137
13138 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13139
13140 all_kernel_rules_buf[i] = kernel_rules_buf;
13141 }
13142
13143 /**
13144 * merge rules or automatic rule generator
13145 */
13146
13147 uint kernel_rules_cnt = 0;
13148
13149 kernel_rule_t *kernel_rules_buf = NULL;
13150
13151 if (attack_mode == ATTACK_MODE_STRAIGHT)
13152 {
13153 if (rp_files_cnt)
13154 {
13155 kernel_rules_cnt = 1;
13156
13157 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13158
13159 repeats[0] = kernel_rules_cnt;
13160
13161 for (uint i = 0; i < rp_files_cnt; i++)
13162 {
13163 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13164
13165 repeats[i + 1] = kernel_rules_cnt;
13166 }
13167
13168 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13169
13170 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13171
13172 for (uint i = 0; i < kernel_rules_cnt; i++)
13173 {
13174 uint out_pos = 0;
13175
13176 kernel_rule_t *out = &kernel_rules_buf[i];
13177
13178 for (uint j = 0; j < rp_files_cnt; j++)
13179 {
13180 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13181 uint in_pos;
13182
13183 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13184
13185 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13186 {
13187 if (out_pos == RULES_MAX - 1)
13188 {
13189 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13190
13191 break;
13192 }
13193
13194 out->cmds[out_pos] = in->cmds[in_pos];
13195 }
13196 }
13197 }
13198
13199 local_free (repeats);
13200 }
13201 else if (rp_gen)
13202 {
13203 uint kernel_rules_avail = 0;
13204
13205 while (kernel_rules_cnt < rp_gen)
13206 {
13207 if (kernel_rules_avail == kernel_rules_cnt)
13208 {
13209 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13210
13211 kernel_rules_avail += INCR_RULES;
13212 }
13213
13214 memset (rule_buf, 0, HCBUFSIZ);
13215
13216 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13217
13218 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13219
13220 kernel_rules_cnt++;
13221 }
13222 }
13223 }
13224
13225 myfree (rule_buf);
13226
13227 /**
13228 * generate NOP rules
13229 */
13230
13231 if (kernel_rules_cnt == 0)
13232 {
13233 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13234
13235 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13236
13237 kernel_rules_cnt++;
13238 }
13239
13240 data.kernel_rules_cnt = kernel_rules_cnt;
13241 data.kernel_rules_buf = kernel_rules_buf;
13242
13243 /**
13244 * OpenCL platforms: detect
13245 */
13246
13247 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13248 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13249
13250 cl_uint platforms_cnt = 0;
13251 cl_uint platform_devices_cnt = 0;
13252
13253 if (keyspace == 0)
13254 {
13255 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13256
13257 if (platforms_cnt == 0)
13258 {
13259 log_info ("");
13260 log_info ("ATTENTION! No OpenCL compatible platform found");
13261 log_info ("");
13262 log_info ("You're probably missing the OpenCL runtime installation");
13263 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13264 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13265 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13266 log_info ("");
13267
13268 return (-1);
13269 }
13270
13271 if (opencl_platforms_filter != (uint) -1)
13272 {
13273 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13274
13275 if (opencl_platforms_filter > platform_cnt_mask)
13276 {
13277 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13278
13279 return (-1);
13280 }
13281 }
13282 }
13283
13284 /**
13285 * OpenCL device types:
13286 * In case the user did not specify --opencl-device-types and the user runs hashcat in a system with only a CPU only he probably want to use that CPU.
13287 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13288 */
13289
13290 if (opencl_device_types == NULL)
13291 {
13292 cl_device_type device_types_all = 0;
13293
13294 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13295 {
13296 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13297
13298 cl_platform_id platform = platforms[platform_id];
13299
13300 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13301
13302 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13303 {
13304 cl_device_id device = platform_devices[platform_devices_id];
13305
13306 cl_device_type device_type;
13307
13308 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13309
13310 device_types_all |= device_type;
13311 }
13312 }
13313
13314 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13315 {
13316 device_types_filter |= CL_DEVICE_TYPE_CPU;
13317 }
13318 }
13319
13320 /**
13321 * OpenCL devices: simply push all devices from all platforms into the same device array
13322 */
13323
13324 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13325
13326 data.devices_param = devices_param;
13327
13328 uint devices_cnt = 0;
13329
13330 uint devices_active = 0;
13331
13332 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13333 {
13334 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13335
13336 cl_platform_id platform = platforms[platform_id];
13337
13338 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13339
13340 char platform_vendor[INFOSZ] = { 0 };
13341
13342 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13343
13344 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13345 // this causes trouble with vendor id based macros
13346 // we'll assign generic to those without special optimization available
13347
13348 cl_uint platform_vendor_id = 0;
13349
13350 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13351 {
13352 platform_vendor_id = VENDOR_ID_AMD;
13353 }
13354 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13355 {
13356 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13357 }
13358 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13359 {
13360 platform_vendor_id = VENDOR_ID_APPLE;
13361 }
13362 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13363 {
13364 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13365 }
13366 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13367 {
13368 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13369 }
13370 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13371 {
13372 platform_vendor_id = VENDOR_ID_MESA;
13373 }
13374 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13375 {
13376 platform_vendor_id = VENDOR_ID_NV;
13377 }
13378 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13379 {
13380 platform_vendor_id = VENDOR_ID_POCL;
13381 }
13382 else
13383 {
13384 platform_vendor_id = VENDOR_ID_GENERIC;
13385 }
13386
13387 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13388 {
13389 size_t param_value_size = 0;
13390
13391 const uint device_id = devices_cnt;
13392
13393 hc_device_param_t *device_param = &data.devices_param[device_id];
13394
13395 device_param->platform_vendor_id = platform_vendor_id;
13396
13397 device_param->device = platform_devices[platform_devices_id];
13398
13399 device_param->device_id = device_id;
13400
13401 device_param->platform_devices_id = platform_devices_id;
13402
13403 // device_type
13404
13405 cl_device_type device_type;
13406
13407 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13408
13409 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13410
13411 device_param->device_type = device_type;
13412
13413 // device_name
13414
13415 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13416
13417 char *device_name = (char *) mymalloc (param_value_size);
13418
13419 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13420
13421 device_param->device_name = device_name;
13422
13423 // device_vendor
13424
13425 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13426
13427 char *device_vendor = (char *) mymalloc (param_value_size);
13428
13429 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13430
13431 device_param->device_vendor = device_vendor;
13432
13433 cl_uint device_vendor_id = 0;
13434
13435 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13436 {
13437 device_vendor_id = VENDOR_ID_AMD;
13438 }
13439 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13440 {
13441 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13442 }
13443 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13444 {
13445 device_vendor_id = VENDOR_ID_APPLE;
13446 }
13447 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13448 {
13449 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13450 }
13451 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13452 {
13453 device_vendor_id = VENDOR_ID_INTEL_SDK;
13454 }
13455 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13456 {
13457 device_vendor_id = VENDOR_ID_MESA;
13458 }
13459 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13460 {
13461 device_vendor_id = VENDOR_ID_NV;
13462 }
13463 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13464 {
13465 device_vendor_id = VENDOR_ID_POCL;
13466 }
13467 else
13468 {
13469 device_vendor_id = VENDOR_ID_GENERIC;
13470 }
13471
13472 device_param->device_vendor_id = device_vendor_id;
13473
13474 // tuning db
13475
13476 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13477
13478 // device_version
13479
13480 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13481
13482 char *device_version = (char *) mymalloc (param_value_size);
13483
13484 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13485
13486 device_param->device_version = device_version;
13487
13488 // device_opencl_version
13489
13490 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13491
13492 char *device_opencl_version = (char *) mymalloc (param_value_size);
13493
13494 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13495
13496 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13497
13498 myfree (device_opencl_version);
13499
13500 // vector_width
13501
13502 cl_uint vector_width;
13503
13504 if (opencl_vector_width_chgd == 0)
13505 {
13506 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13507 {
13508 if (opti_type & OPTI_TYPE_USES_BITS_64)
13509 {
13510 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13511 }
13512 else
13513 {
13514 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13515 }
13516 }
13517 else
13518 {
13519 vector_width = (cl_uint) tuningdb_entry->vector_width;
13520 }
13521 }
13522 else
13523 {
13524 vector_width = opencl_vector_width;
13525 }
13526
13527 if (vector_width > 16) vector_width = 16;
13528
13529 device_param->vector_width = vector_width;
13530
13531 // max_compute_units
13532
13533 cl_uint device_processors;
13534
13535 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13536
13537 device_param->device_processors = device_processors;
13538
13539 // device_maxmem_alloc
13540 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13541
13542 cl_ulong device_maxmem_alloc;
13543
13544 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13545
13546 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13547
13548 // device_global_mem
13549
13550 cl_ulong device_global_mem;
13551
13552 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13553
13554 device_param->device_global_mem = device_global_mem;
13555
13556 // max_work_group_size
13557
13558 size_t device_maxworkgroup_size;
13559
13560 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13561
13562 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13563
13564 // max_clock_frequency
13565
13566 cl_uint device_maxclock_frequency;
13567
13568 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13569
13570 device_param->device_maxclock_frequency = device_maxclock_frequency;
13571
13572 // device_endian_little
13573
13574 cl_bool device_endian_little;
13575
13576 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13577
13578 if (device_endian_little == CL_FALSE)
13579 {
13580 if (data.quiet == 0) log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13581
13582 device_param->skipped = 1;
13583 }
13584
13585 // device_available
13586
13587 cl_bool device_available;
13588
13589 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13590
13591 if (device_available == CL_FALSE)
13592 {
13593 if (data.quiet == 0) log_info ("Device #%u: WARNING: device not available", device_id + 1);
13594
13595 device_param->skipped = 1;
13596 }
13597
13598 // device_compiler_available
13599
13600 cl_bool device_compiler_available;
13601
13602 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13603
13604 if (device_compiler_available == CL_FALSE)
13605 {
13606 if (data.quiet == 0) log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13607
13608 device_param->skipped = 1;
13609 }
13610
13611 // device_execution_capabilities
13612
13613 cl_device_exec_capabilities device_execution_capabilities;
13614
13615 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13616
13617 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13618 {
13619 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13620
13621 device_param->skipped = 1;
13622 }
13623
13624 // device_extensions
13625
13626 size_t device_extensions_size;
13627
13628 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13629
13630 char *device_extensions = mymalloc (device_extensions_size + 1);
13631
13632 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13633
13634 if (strstr (device_extensions, "base_atomics") == 0)
13635 {
13636 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13637
13638 device_param->skipped = 1;
13639 }
13640
13641 if (strstr (device_extensions, "byte_addressable_store") == 0)
13642 {
13643 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13644
13645 device_param->skipped = 1;
13646 }
13647
13648 myfree (device_extensions);
13649
13650 // device_local_mem_size
13651
13652 cl_ulong device_local_mem_size;
13653
13654 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13655
13656 if (device_local_mem_size < 32768)
13657 {
13658 if (data.quiet == 0) log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13659
13660 device_param->skipped = 1;
13661 }
13662
13663 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13664 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13665 // This results in both utilizing it for 50%
13666 // However, Intel has much better SIMD control over their own hardware
13667 // It makes sense to give them full control over their own hardware
13668
13669 if (device_type & CL_DEVICE_TYPE_CPU)
13670 {
13671 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13672 {
13673 if (data.quiet == 0) log_info ("Device #%u: WARNING: not native intel opencl platform", device_id + 1);
13674
13675 device_param->skipped = 1;
13676 }
13677 }
13678
13679 // skipped
13680
13681 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13682 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13683
13684 // driver_version
13685
13686 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13687
13688 char *driver_version = (char *) mymalloc (param_value_size);
13689
13690 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13691
13692 device_param->driver_version = driver_version;
13693
13694 // device_name_chksum
13695
13696 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13697
13698 #if __x86_64__
13699 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 64, device_param->platform_vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
13700 #else
13701 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 32, device_param->platform_vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
13702 #endif
13703
13704 uint device_name_digest[4] = { 0 };
13705
13706 md5_64 ((uint *) device_name_chksum, device_name_digest);
13707
13708 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13709
13710 device_param->device_name_chksum = device_name_chksum;
13711
13712 // device_processor_cores
13713
13714 if (device_type & CL_DEVICE_TYPE_CPU)
13715 {
13716 cl_uint device_processor_cores = 1;
13717
13718 device_param->device_processor_cores = device_processor_cores;
13719 }
13720
13721 if (device_type & CL_DEVICE_TYPE_GPU)
13722 {
13723 if (device_vendor_id == VENDOR_ID_AMD)
13724 {
13725 cl_uint device_processor_cores = 0;
13726
13727 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13728
13729 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13730
13731 device_param->device_processor_cores = device_processor_cores;
13732 }
13733 else if (device_vendor_id == VENDOR_ID_NV)
13734 {
13735 cl_uint kernel_exec_timeout = 0;
13736
13737 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13738
13739 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13740
13741 device_param->kernel_exec_timeout = kernel_exec_timeout;
13742
13743 cl_uint device_processor_cores = 0;
13744
13745 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13746
13747 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13748
13749 device_param->device_processor_cores = device_processor_cores;
13750
13751 cl_uint sm_minor = 0;
13752 cl_uint sm_major = 0;
13753
13754 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13755 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13756
13757 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13758 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13759
13760 device_param->sm_minor = sm_minor;
13761 device_param->sm_major = sm_major;
13762 }
13763 else
13764 {
13765 cl_uint device_processor_cores = 1;
13766
13767 device_param->device_processor_cores = device_processor_cores;
13768 }
13769 }
13770
13771 // display results
13772
13773 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13774 {
13775 if (machine_readable == 0)
13776 {
13777 if (device_param->skipped == 0)
13778 {
13779 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13780 device_id + 1,
13781 device_name,
13782 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13783 (unsigned int) (device_global_mem / 1024 / 1024),
13784 (unsigned int) device_processors);
13785 }
13786 else
13787 {
13788 log_info ("Device #%u: %s, skipped",
13789 device_id + 1,
13790 device_name);
13791 }
13792 }
13793 }
13794
13795 // common driver check
13796
13797 if (device_param->skipped == 0)
13798 {
13799 if (device_type & CL_DEVICE_TYPE_GPU)
13800 {
13801 if (platform_vendor_id == VENDOR_ID_AMD)
13802 {
13803 int catalyst_check = (force == 1) ? 0 : 1;
13804
13805 int catalyst_warn = 0;
13806
13807 int catalyst_broken = 0;
13808
13809 if (catalyst_check == 1)
13810 {
13811 catalyst_warn = 1;
13812
13813 // v14.9 and higher
13814 if (atoi (device_param->driver_version) >= 1573)
13815 {
13816 catalyst_warn = 0;
13817 }
13818
13819 catalyst_check = 0;
13820 }
13821
13822 if (catalyst_broken == 1)
13823 {
13824 log_info ("");
13825 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13826 log_info ("It will pass over cracked hashes and does not report them as cracked");
13827 log_info ("You are STRONGLY encouraged not to use it");
13828 log_info ("You can use --force to override this but do not post error reports if you do so");
13829 log_info ("");
13830
13831 return (-1);
13832 }
13833
13834 if (catalyst_warn == 1)
13835 {
13836 log_info ("");
13837 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13838 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13839 log_info ("See hashcat's homepage for official supported catalyst drivers");
13840 #ifdef _WIN
13841 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13842 #endif
13843 log_info ("You can use --force to override this but do not post error reports if you do so");
13844 log_info ("");
13845
13846 return (-1);
13847 }
13848 }
13849 else if (platform_vendor_id == VENDOR_ID_NV)
13850 {
13851 if (device_param->kernel_exec_timeout != 0)
13852 {
13853 if (data.quiet == 0) log_info ("Device #%u: WARNING! Kernel exec timeout is not disabled, it might cause you errors of code 702", device_id + 1);
13854 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13855 }
13856 }
13857 }
13858
13859 /* turns out pocl still creates segfaults (because of llvm)
13860 if (device_type & CL_DEVICE_TYPE_CPU)
13861 {
13862 if (platform_vendor_id == VENDOR_ID_AMD)
13863 {
13864 if (force == 0)
13865 {
13866 log_info ("");
13867 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13868 log_info ("You are STRONGLY encouraged not to use it");
13869 log_info ("You can use --force to override this but do not post error reports if you do so");
13870 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13871 log_info ("");
13872
13873 return (-1);
13874 }
13875 }
13876 }
13877 */
13878
13879 /**
13880 * kernel accel and loops tuning db adjustment
13881 */
13882
13883 device_param->kernel_accel_min = 1;
13884 device_param->kernel_accel_max = 1024;
13885
13886 device_param->kernel_loops_min = 1;
13887 device_param->kernel_loops_max = 1024;
13888
13889 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13890
13891 if (tuningdb_entry)
13892 {
13893 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13894 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13895
13896 if (_kernel_accel)
13897 {
13898 device_param->kernel_accel_min = _kernel_accel;
13899 device_param->kernel_accel_max = _kernel_accel;
13900 }
13901
13902 if (_kernel_loops)
13903 {
13904 if (workload_profile == 1)
13905 {
13906 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13907 }
13908 else if (workload_profile == 2)
13909 {
13910 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13911 }
13912
13913 device_param->kernel_loops_min = _kernel_loops;
13914 device_param->kernel_loops_max = _kernel_loops;
13915 }
13916 }
13917
13918 // commandline parameters overwrite tuningdb entries
13919
13920 if (kernel_accel)
13921 {
13922 device_param->kernel_accel_min = kernel_accel;
13923 device_param->kernel_accel_max = kernel_accel;
13924 }
13925
13926 if (kernel_loops)
13927 {
13928 device_param->kernel_loops_min = kernel_loops;
13929 device_param->kernel_loops_max = kernel_loops;
13930 }
13931
13932 /**
13933 * activate device
13934 */
13935
13936 devices_active++;
13937 }
13938
13939 // next please
13940
13941 devices_cnt++;
13942 }
13943 }
13944
13945 if (keyspace == 0 && devices_active == 0)
13946 {
13947 log_error ("ERROR: No devices found/left");
13948
13949 return (-1);
13950 }
13951
13952 // additional check to see if the user has chosen a device that is not within the range of available devices (i.e. larger than devices_cnt)
13953
13954 if (devices_filter != (uint) -1)
13955 {
13956 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13957
13958 if (devices_filter > devices_cnt_mask)
13959 {
13960 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13961
13962 return (-1);
13963 }
13964 }
13965
13966 data.devices_cnt = devices_cnt;
13967
13968 data.devices_active = devices_active;
13969
13970 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13971 {
13972 if (machine_readable == 0)
13973 {
13974 log_info ("");
13975 }
13976 }
13977
13978 /**
13979 * HM devices: init
13980 */
13981
13982 #ifdef HAVE_HWMON
13983 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
13984 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
13985
13986 if (gpu_temp_disable == 0)
13987 {
13988 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13989
13990 if (nvml_init (nvml) == 0)
13991 data.hm_nv = nvml;
13992
13993 if (data.hm_nv)
13994 {
13995 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13996 {
13997 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13998
13999 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
14000
14001 int tmp_out = 0;
14002
14003 for (int i = 0; i < tmp_in; i++)
14004 {
14005 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
14006 }
14007
14008 for (int i = 0; i < tmp_out; i++)
14009 {
14010 unsigned int speed;
14011
14012 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_get_supported = 1;
14013
14014 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14015
14016 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, NVML_GOM_ALL_ON);
14017
14018 unsigned int minLimit;
14019 unsigned int maxLimit;
14020
14021 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, &minLimit, &maxLimit) == NVML_SUCCESS)
14022 {
14023 if (maxLimit > 0)
14024 {
14025 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, maxLimit);
14026 }
14027 }
14028 }
14029 }
14030 }
14031
14032 data.hm_amd = NULL;
14033
14034 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14035
14036 if (adl_init (adl) == 0)
14037 data.hm_amd = adl;
14038
14039 if (data.hm_amd)
14040 {
14041 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14042 {
14043 // total number of adapters
14044
14045 int hm_adapters_num;
14046
14047 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
14048
14049 // adapter info
14050
14051 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
14052
14053 if (lpAdapterInfo == NULL) return (-1);
14054
14055 // get a list (of ids of) valid/usable adapters
14056
14057 int num_adl_adapters = 0;
14058
14059 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14060
14061 if (num_adl_adapters > 0)
14062 {
14063 hc_thread_mutex_lock (mux_adl);
14064
14065 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
14066
14067 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14068
14069 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14070 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14071
14072 hc_thread_mutex_unlock (mux_adl);
14073 }
14074
14075 myfree (valid_adl_device_list);
14076 myfree (lpAdapterInfo);
14077 }
14078 }
14079
14080 if (data.hm_amd == NULL && data.hm_nv == NULL)
14081 {
14082 gpu_temp_disable = 1;
14083 }
14084 }
14085
14086 /**
14087 * OpenCL devices: allocate buffer for device specific information
14088 */
14089
14090 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14091 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14092
14093 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14094
14095 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14096
14097 /**
14098 * User-defined GPU temp handling
14099 */
14100
14101 if (gpu_temp_disable == 1)
14102 {
14103 gpu_temp_abort = 0;
14104 gpu_temp_retain = 0;
14105 }
14106
14107 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14108 {
14109 if (gpu_temp_abort < gpu_temp_retain)
14110 {
14111 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14112
14113 return (-1);
14114 }
14115 }
14116
14117 data.gpu_temp_disable = gpu_temp_disable;
14118 data.gpu_temp_abort = gpu_temp_abort;
14119 data.gpu_temp_retain = gpu_temp_retain;
14120 #endif
14121
14122 /**
14123 * enable custom signal handler(s)
14124 */
14125
14126 if (benchmark == 0)
14127 {
14128 hc_signal (sigHandler_default);
14129 }
14130 else
14131 {
14132 hc_signal (sigHandler_benchmark);
14133 }
14134
14135 /**
14136 * inform the user
14137 */
14138
14139 if (data.quiet == 0)
14140 {
14141 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14142
14143 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);
14144
14145 if (attack_mode == ATTACK_MODE_STRAIGHT)
14146 {
14147 log_info ("Rules: %u", kernel_rules_cnt);
14148 }
14149
14150 if (opti_type)
14151 {
14152 log_info ("Applicable Optimizers:");
14153
14154 for (uint i = 0; i < 32; i++)
14155 {
14156 const uint opti_bit = 1u << i;
14157
14158 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14159 }
14160 }
14161
14162 /**
14163 * Watchdog and Temperature balance
14164 */
14165
14166 #ifdef HAVE_HWMON
14167 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
14168 {
14169 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14170 }
14171
14172 if (gpu_temp_abort == 0)
14173 {
14174 log_info ("Watchdog: Temperature abort trigger disabled");
14175 }
14176 else
14177 {
14178 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14179 }
14180
14181 if (gpu_temp_retain == 0)
14182 {
14183 log_info ("Watchdog: Temperature retain trigger disabled");
14184 }
14185 else
14186 {
14187 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14188 }
14189
14190 if (data.quiet == 0) log_info ("");
14191 #endif
14192 }
14193
14194 #ifdef HAVE_HWMON
14195
14196 /**
14197 * HM devices: copy
14198 */
14199
14200 if (gpu_temp_disable == 0)
14201 {
14202 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14203 {
14204 hc_device_param_t *device_param = &data.devices_param[device_id];
14205
14206 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14207
14208 if (device_param->skipped) continue;
14209
14210 const uint platform_devices_id = device_param->platform_devices_id;
14211
14212 if (device_param->device_vendor_id == VENDOR_ID_NV)
14213 {
14214 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14215 }
14216
14217 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14218 {
14219 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14220 }
14221 }
14222 }
14223
14224 /**
14225 * Temporary fix:
14226 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14227 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14228 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14229 * Driver / ADL bug?
14230 */
14231
14232 if (powertune_enable == 1)
14233 {
14234 hc_thread_mutex_lock (mux_adl);
14235
14236 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14237 {
14238 hc_device_param_t *device_param = &data.devices_param[device_id];
14239
14240 if (device_param->skipped) continue;
14241
14242 if (data.hm_device[device_id].od_version == 6)
14243 {
14244 // set powertune value only
14245
14246 int powertune_supported = 0;
14247
14248 int ADL_rc = 0;
14249
14250 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14251 {
14252 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14253
14254 return (-1);
14255 }
14256
14257 if (powertune_supported != 0)
14258 {
14259 // powertune set
14260 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14261
14262 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14263 {
14264 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14265
14266 return (-1);
14267 }
14268
14269 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14270 {
14271 log_error ("ERROR: Failed to set new ADL PowerControl values");
14272
14273 return (-1);
14274 }
14275 }
14276 }
14277 }
14278
14279 hc_thread_mutex_unlock (mux_adl);
14280 }
14281
14282 #endif // HAVE_HWMON
14283
14284 #ifdef DEBUG
14285 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14286 #endif
14287
14288 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14289
14290 uint kernel_power_all = 0;
14291
14292 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14293 {
14294 /**
14295 * host buffer
14296 */
14297
14298 hc_device_param_t *device_param = &data.devices_param[device_id];
14299
14300 if (device_param->skipped) continue;
14301
14302 /**
14303 * device properties
14304 */
14305
14306 const char *device_name_chksum = device_param->device_name_chksum;
14307 const u32 device_processors = device_param->device_processors;
14308 const u32 device_processor_cores = device_param->device_processor_cores;
14309
14310 /**
14311 * create context for each device
14312 */
14313
14314 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14315
14316 /**
14317 * create command-queue
14318 */
14319
14320 // not supported with NV
14321 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14322
14323 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14324
14325 /**
14326 * kernel threads: some algorithms need a fixed kernel-threads count
14327 * because of shared memory usage or bitslice
14328 * there needs to be some upper limit, otherwise there's too much overhead
14329 */
14330
14331 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14332
14333 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14334 {
14335 kernel_threads = KERNEL_THREADS_MAX_CPU;
14336 }
14337
14338 if (hash_mode == 1500) kernel_threads = 64; // DES
14339 if (hash_mode == 3000) kernel_threads = 64; // DES
14340 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14341 if (hash_mode == 7500) kernel_threads = 64; // RC4
14342 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14343 if (hash_mode == 9700) kernel_threads = 64; // RC4
14344 if (hash_mode == 9710) kernel_threads = 64; // RC4
14345 if (hash_mode == 9800) kernel_threads = 64; // RC4
14346 if (hash_mode == 9810) kernel_threads = 64; // RC4
14347 if (hash_mode == 10400) kernel_threads = 64; // RC4
14348 if (hash_mode == 10410) kernel_threads = 64; // RC4
14349 if (hash_mode == 10500) kernel_threads = 64; // RC4
14350 if (hash_mode == 13100) kernel_threads = 64; // RC4
14351
14352 /**
14353 * create input buffers on device : calculate size of fixed memory buffers
14354 */
14355
14356 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14357 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14358
14359 device_param->size_root_css = size_root_css;
14360 device_param->size_markov_css = size_markov_css;
14361
14362 size_t size_results = sizeof (uint);
14363
14364 device_param->size_results = size_results;
14365
14366 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14367 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14368
14369 size_t size_plains = digests_cnt * sizeof (plain_t);
14370 size_t size_salts = salts_cnt * sizeof (salt_t);
14371 size_t size_esalts = salts_cnt * esalt_size;
14372
14373 device_param->size_plains = size_plains;
14374 device_param->size_digests = size_digests;
14375 device_param->size_shown = size_shown;
14376 device_param->size_salts = size_salts;
14377
14378 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14379 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14380 size_t size_tm = 32 * sizeof (bs_word_t);
14381
14382 // scryptV stuff
14383
14384 size_t size_scryptV = 1;
14385
14386 if ((hash_mode == 8900) || (hash_mode == 9300))
14387 {
14388 uint tmto_start = 0;
14389 uint tmto_stop = 10;
14390
14391 if (scrypt_tmto)
14392 {
14393 tmto_start = scrypt_tmto;
14394 }
14395 else
14396 {
14397 // in case the user did not specify the tmto manually
14398 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14399 // but set the lower end only in case the user has a device with too less memory
14400
14401 if (hash_mode == 8900)
14402 {
14403 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14404 {
14405 tmto_start = 1;
14406 }
14407 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14408 {
14409 tmto_start = 2;
14410 }
14411 }
14412 else if (hash_mode == 9300)
14413 {
14414 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14415 {
14416 tmto_start = 2;
14417 }
14418 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14419 {
14420 tmto_start = 2;
14421 }
14422 }
14423 }
14424
14425 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14426 {
14427 // TODO: in theory the following calculation needs to be done per salt, not global
14428 // we assume all hashes have the same scrypt settings
14429
14430 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14431
14432 size_scryptV /= 1 << tmto;
14433
14434 size_scryptV *= device_processors * device_processor_cores;
14435
14436 if (size_scryptV > device_param->device_maxmem_alloc)
14437 {
14438 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14439
14440 continue;
14441 }
14442
14443 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14444 {
14445 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14446 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14447 }
14448
14449 break;
14450 }
14451
14452 if (data.salts_buf[0].scrypt_phy == 0)
14453 {
14454 log_error ("ERROR: can't allocate enough device memory");
14455
14456 return -1;
14457 }
14458
14459 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14460 }
14461
14462 /**
14463 * some algorithms need a fixed kernel-loops count
14464 */
14465
14466 if (hash_mode == 1500)
14467 {
14468 const u32 kernel_loops_fixed = 1024;
14469
14470 device_param->kernel_loops_min = kernel_loops_fixed;
14471 device_param->kernel_loops_max = kernel_loops_fixed;
14472 }
14473
14474 if (hash_mode == 3000)
14475 {
14476 const u32 kernel_loops_fixed = 1024;
14477
14478 device_param->kernel_loops_min = kernel_loops_fixed;
14479 device_param->kernel_loops_max = kernel_loops_fixed;
14480 }
14481
14482 if (hash_mode == 8900)
14483 {
14484 const u32 kernel_loops_fixed = 1;
14485
14486 device_param->kernel_loops_min = kernel_loops_fixed;
14487 device_param->kernel_loops_max = kernel_loops_fixed;
14488 }
14489
14490 if (hash_mode == 9300)
14491 {
14492 const u32 kernel_loops_fixed = 1;
14493
14494 device_param->kernel_loops_min = kernel_loops_fixed;
14495 device_param->kernel_loops_max = kernel_loops_fixed;
14496 }
14497
14498 if (hash_mode == 12500)
14499 {
14500 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14501
14502 device_param->kernel_loops_min = kernel_loops_fixed;
14503 device_param->kernel_loops_max = kernel_loops_fixed;
14504 }
14505
14506 /**
14507 * some algorithms have a maximum kernel-loops count
14508 */
14509
14510 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14511 {
14512 u32 innerloop_cnt = 0;
14513
14514 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14515 {
14516 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14517 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14518 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14519 }
14520 else
14521 {
14522 innerloop_cnt = data.salts_buf[0].salt_iter;
14523 }
14524
14525 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14526 (innerloop_cnt <= device_param->kernel_loops_max))
14527 {
14528 device_param->kernel_loops_max = innerloop_cnt;
14529 }
14530 }
14531
14532 u32 kernel_accel_min = device_param->kernel_accel_min;
14533 u32 kernel_accel_max = device_param->kernel_accel_max;
14534
14535 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14536
14537 size_t size_pws = 4;
14538 size_t size_tmps = 4;
14539 size_t size_hooks = 4;
14540
14541 while (kernel_accel_max >= kernel_accel_min)
14542 {
14543 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14544
14545 // size_pws
14546
14547 size_pws = kernel_power_max * sizeof (pw_t);
14548
14549 // size_tmps
14550
14551 switch (hash_mode)
14552 {
14553 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14554 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14555 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14556 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14557 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14558 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14559 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14560 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14561 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14562 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14563 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14564 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14565 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14566 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14567 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14568 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14569 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14570 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14571 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14572 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14573 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14574 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14575 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14576 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14577 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14578 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14579 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14580 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14581 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14582 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14583 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14584 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14585 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14586 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14587 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14588 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14589 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14590 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14591 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14592 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14593 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14594 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14595 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14596 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14597 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14598 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14599 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14600 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14601 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14602 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14603 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14604 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14605 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14606 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14607 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14608 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14609 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14610 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14611 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14612 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14613 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14614 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14615 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14616 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14617 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14618 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14619 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14620 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14621 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14622 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14623 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14624 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14625 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14626 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14627 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14628 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14629 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14630 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14631 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14632 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14633 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14634 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14635 };
14636
14637 // size_hooks
14638
14639 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14640 {
14641 // none yet
14642 }
14643
14644 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14645 // if not, decrease amplifier and try again
14646
14647 int skip = 0;
14648
14649 const u64 size_total
14650 = bitmap_size
14651 + bitmap_size
14652 + bitmap_size
14653 + bitmap_size
14654 + bitmap_size
14655 + bitmap_size
14656 + bitmap_size
14657 + bitmap_size
14658 + size_bfs
14659 + size_combs
14660 + size_digests
14661 + size_esalts
14662 + size_hooks
14663 + size_markov_css
14664 + size_plains
14665 + size_pws
14666 + size_pws // not a bug
14667 + size_results
14668 + size_root_css
14669 + size_rules
14670 + size_rules_c
14671 + size_salts
14672 + size_scryptV
14673 + size_shown
14674 + size_tm
14675 + size_tmps;
14676
14677 // Don't ask me, ask AMD!
14678
14679 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14680 if (size_total > device_param->device_global_mem) skip = 1;
14681
14682 if (skip == 1)
14683 {
14684 kernel_accel_max--;
14685
14686 continue;
14687 }
14688
14689 break;
14690 }
14691
14692 /*
14693 if (kernel_accel_max == 0)
14694 {
14695 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14696
14697 return -1;
14698 }
14699 */
14700
14701 device_param->kernel_accel_min = kernel_accel_min;
14702 device_param->kernel_accel_max = kernel_accel_max;
14703
14704 /*
14705 if (kernel_accel_max < kernel_accel)
14706 {
14707 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14708
14709 device_param->kernel_accel = kernel_accel_max;
14710 }
14711 */
14712
14713 device_param->size_bfs = size_bfs;
14714 device_param->size_combs = size_combs;
14715 device_param->size_rules = size_rules;
14716 device_param->size_rules_c = size_rules_c;
14717 device_param->size_pws = size_pws;
14718 device_param->size_tmps = size_tmps;
14719 device_param->size_hooks = size_hooks;
14720
14721 // do not confuse kernel_accel_max with kernel_accel here
14722
14723 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14724
14725 device_param->kernel_threads = kernel_threads;
14726 device_param->kernel_power_user = kernel_power;
14727
14728 kernel_power_all += kernel_power;
14729
14730 /**
14731 * default building options
14732 */
14733
14734 char build_opts[1024] = { 0 };
14735
14736 // we don't have sm_* on vendors not NV but it doesn't matter
14737
14738 #if _WIN
14739 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);
14740 #else
14741 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);
14742 #endif
14743
14744 char build_opts_new[1024] = { 0 };
14745
14746 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);
14747
14748 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14749
14750 /*
14751 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14752 {
14753 // we do vectorizing much better than the auto-vectorizer
14754
14755 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14756
14757 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14758 }
14759 */
14760
14761 #ifdef DEBUG
14762 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14763 #endif
14764
14765 /**
14766 * main kernel
14767 */
14768
14769 {
14770 /**
14771 * kernel source filename
14772 */
14773
14774 char source_file[256] = { 0 };
14775
14776 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14777
14778 struct stat sst;
14779
14780 if (stat (source_file, &sst) == -1)
14781 {
14782 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14783
14784 return -1;
14785 }
14786
14787 /**
14788 * kernel cached filename
14789 */
14790
14791 char cached_file[256] = { 0 };
14792
14793 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14794
14795 int cached = 1;
14796
14797 struct stat cst;
14798
14799 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14800 {
14801 cached = 0;
14802 }
14803
14804 /**
14805 * kernel compile or load
14806 */
14807
14808 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14809
14810 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14811
14812 if (force_jit_compilation == -1)
14813 {
14814 if (cached == 0)
14815 {
14816 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14817
14818 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14819
14820 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14821
14822 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14823
14824 #ifdef DEBUG
14825 size_t build_log_size = 0;
14826
14827 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14828
14829 if (build_log_size > 1)
14830 {
14831 char *build_log = (char *) malloc (build_log_size + 1);
14832
14833 memset (build_log, 0, build_log_size + 1);
14834
14835 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14836
14837 puts (build_log);
14838
14839 free (build_log);
14840 }
14841 #endif
14842
14843 if (rc != 0)
14844 {
14845 device_param->skipped = true;
14846
14847 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14848
14849 continue;
14850 }
14851
14852 size_t binary_size;
14853
14854 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14855
14856 u8 *binary = (u8 *) mymalloc (binary_size);
14857
14858 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14859
14860 writeProgramBin (cached_file, binary, binary_size);
14861
14862 local_free (binary);
14863 }
14864 else
14865 {
14866 #ifdef DEBUG
14867 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14868 #endif
14869
14870 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14871
14872 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14873
14874 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14875 }
14876 }
14877 else
14878 {
14879 #ifdef DEBUG
14880 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14881 #endif
14882
14883 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14884
14885 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14886
14887 char build_opts_update[1024] = { 0 };
14888
14889 if (force_jit_compilation == 1500)
14890 {
14891 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14892 }
14893 else if (force_jit_compilation == 8900)
14894 {
14895 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);
14896 }
14897 else
14898 {
14899 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14900 }
14901
14902 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14903
14904 #ifdef DEBUG
14905 size_t build_log_size = 0;
14906
14907 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14908
14909 if (build_log_size > 1)
14910 {
14911 char *build_log = (char *) malloc (build_log_size + 1);
14912
14913 memset (build_log, 0, build_log_size + 1);
14914
14915 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14916
14917 puts (build_log);
14918
14919 free (build_log);
14920 }
14921 #endif
14922
14923 if (rc != 0)
14924 {
14925 device_param->skipped = true;
14926
14927 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14928 }
14929 }
14930
14931 local_free (kernel_lengths);
14932 local_free (kernel_sources[0]);
14933 local_free (kernel_sources);
14934 }
14935
14936 /**
14937 * word generator kernel
14938 */
14939
14940 if (attack_mode != ATTACK_MODE_STRAIGHT)
14941 {
14942 /**
14943 * kernel mp source filename
14944 */
14945
14946 char source_file[256] = { 0 };
14947
14948 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14949
14950 struct stat sst;
14951
14952 if (stat (source_file, &sst) == -1)
14953 {
14954 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14955
14956 return -1;
14957 }
14958
14959 /**
14960 * kernel mp cached filename
14961 */
14962
14963 char cached_file[256] = { 0 };
14964
14965 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14966
14967 int cached = 1;
14968
14969 struct stat cst;
14970
14971 if (stat (cached_file, &cst) == -1)
14972 {
14973 cached = 0;
14974 }
14975
14976 /**
14977 * kernel compile or load
14978 */
14979
14980 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14981
14982 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14983
14984 if (cached == 0)
14985 {
14986 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14987 if (quiet == 0) log_info ("");
14988
14989 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14990
14991 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14992
14993 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14994
14995 if (rc != 0)
14996 {
14997 device_param->skipped = true;
14998
14999 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15000
15001 continue;
15002 }
15003
15004 size_t binary_size;
15005
15006 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15007
15008 u8 *binary = (u8 *) mymalloc (binary_size);
15009
15010 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15011
15012 writeProgramBin (cached_file, binary, binary_size);
15013
15014 local_free (binary);
15015 }
15016 else
15017 {
15018 #ifdef DEBUG
15019 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15020 #endif
15021
15022 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15023
15024 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15025
15026 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15027 }
15028
15029 local_free (kernel_lengths);
15030 local_free (kernel_sources[0]);
15031 local_free (kernel_sources);
15032 }
15033
15034 /**
15035 * amplifier kernel
15036 */
15037
15038 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15039 {
15040
15041 }
15042 else
15043 {
15044 /**
15045 * kernel amp source filename
15046 */
15047
15048 char source_file[256] = { 0 };
15049
15050 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15051
15052 struct stat sst;
15053
15054 if (stat (source_file, &sst) == -1)
15055 {
15056 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15057
15058 return -1;
15059 }
15060
15061 /**
15062 * kernel amp cached filename
15063 */
15064
15065 char cached_file[256] = { 0 };
15066
15067 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15068
15069 int cached = 1;
15070
15071 struct stat cst;
15072
15073 if (stat (cached_file, &cst) == -1)
15074 {
15075 cached = 0;
15076 }
15077
15078 /**
15079 * kernel compile or load
15080 */
15081
15082 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15083
15084 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15085
15086 if (cached == 0)
15087 {
15088 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15089 if (quiet == 0) log_info ("");
15090
15091 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15092
15093 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15094
15095 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15096
15097 if (rc != 0)
15098 {
15099 device_param->skipped = true;
15100
15101 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15102
15103 continue;
15104 }
15105
15106 size_t binary_size;
15107
15108 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15109
15110 u8 *binary = (u8 *) mymalloc (binary_size);
15111
15112 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15113
15114 writeProgramBin (cached_file, binary, binary_size);
15115
15116 local_free (binary);
15117 }
15118 else
15119 {
15120 #ifdef DEBUG
15121 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15122 #endif
15123
15124 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15125
15126 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15127
15128 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15129 }
15130
15131 local_free (kernel_lengths);
15132 local_free (kernel_sources[0]);
15133 local_free (kernel_sources);
15134 }
15135
15136 // some algorithm collide too fast, make that impossible
15137
15138 if (benchmark == 1)
15139 {
15140 ((uint *) digests_buf)[0] = -1;
15141 ((uint *) digests_buf)[1] = -1;
15142 ((uint *) digests_buf)[2] = -1;
15143 ((uint *) digests_buf)[3] = -1;
15144 }
15145
15146 /**
15147 * global buffers
15148 */
15149
15150 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15151 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15152 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15153 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15154 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15155 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15156 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15157 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15158 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15159 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15160 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15161 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15162 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15163 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15164 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15165 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15166 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15167 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15168
15169 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);
15170 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);
15171 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);
15172 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);
15173 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);
15174 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);
15175 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);
15176 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);
15177 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15178 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15179 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15180
15181 /**
15182 * special buffers
15183 */
15184
15185 if (attack_kern == ATTACK_KERN_STRAIGHT)
15186 {
15187 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15188 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15189
15190 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15191 }
15192 else if (attack_kern == ATTACK_KERN_COMBI)
15193 {
15194 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15195 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15196 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15197 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15198 }
15199 else if (attack_kern == ATTACK_KERN_BF)
15200 {
15201 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15202 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15203 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15204 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15205 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15206 }
15207
15208 if (size_esalts)
15209 {
15210 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15211
15212 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15213 }
15214
15215 /**
15216 * main host data
15217 */
15218
15219 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15220
15221 device_param->pws_buf = pws_buf;
15222
15223 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15224
15225 device_param->combs_buf = combs_buf;
15226
15227 void *hooks_buf = mymalloc (size_hooks);
15228
15229 device_param->hooks_buf = hooks_buf;
15230
15231 /**
15232 * kernel args
15233 */
15234
15235 device_param->kernel_params_buf32[21] = bitmap_mask;
15236 device_param->kernel_params_buf32[22] = bitmap_shift1;
15237 device_param->kernel_params_buf32[23] = bitmap_shift2;
15238 device_param->kernel_params_buf32[24] = 0; // salt_pos
15239 device_param->kernel_params_buf32[25] = 0; // loop_pos
15240 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15241 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15242 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15243 device_param->kernel_params_buf32[29] = 0; // digests_offset
15244 device_param->kernel_params_buf32[30] = 0; // combs_mode
15245 device_param->kernel_params_buf32[31] = 0; // gid_max
15246
15247 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15248 ? &device_param->d_pws_buf
15249 : &device_param->d_pws_amp_buf;
15250 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15251 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15252 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15253 device_param->kernel_params[ 4] = &device_param->d_tmps;
15254 device_param->kernel_params[ 5] = &device_param->d_hooks;
15255 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15256 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15257 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15258 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15259 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15260 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15261 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15262 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15263 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15264 device_param->kernel_params[15] = &device_param->d_digests_buf;
15265 device_param->kernel_params[16] = &device_param->d_digests_shown;
15266 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15267 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15268 device_param->kernel_params[19] = &device_param->d_result;
15269 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15270 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15271 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15272 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15273 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15274 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15275 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15276 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15277 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15278 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15279 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15280 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15281
15282 device_param->kernel_params_mp_buf64[3] = 0;
15283 device_param->kernel_params_mp_buf32[4] = 0;
15284 device_param->kernel_params_mp_buf32[5] = 0;
15285 device_param->kernel_params_mp_buf32[6] = 0;
15286 device_param->kernel_params_mp_buf32[7] = 0;
15287 device_param->kernel_params_mp_buf32[8] = 0;
15288
15289 device_param->kernel_params_mp[0] = NULL;
15290 device_param->kernel_params_mp[1] = NULL;
15291 device_param->kernel_params_mp[2] = NULL;
15292 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15293 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15294 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15295 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15296 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15297 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15298
15299 device_param->kernel_params_mp_l_buf64[3] = 0;
15300 device_param->kernel_params_mp_l_buf32[4] = 0;
15301 device_param->kernel_params_mp_l_buf32[5] = 0;
15302 device_param->kernel_params_mp_l_buf32[6] = 0;
15303 device_param->kernel_params_mp_l_buf32[7] = 0;
15304 device_param->kernel_params_mp_l_buf32[8] = 0;
15305 device_param->kernel_params_mp_l_buf32[9] = 0;
15306
15307 device_param->kernel_params_mp_l[0] = NULL;
15308 device_param->kernel_params_mp_l[1] = NULL;
15309 device_param->kernel_params_mp_l[2] = NULL;
15310 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15311 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15312 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15313 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15314 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15315 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15316 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15317
15318 device_param->kernel_params_mp_r_buf64[3] = 0;
15319 device_param->kernel_params_mp_r_buf32[4] = 0;
15320 device_param->kernel_params_mp_r_buf32[5] = 0;
15321 device_param->kernel_params_mp_r_buf32[6] = 0;
15322 device_param->kernel_params_mp_r_buf32[7] = 0;
15323 device_param->kernel_params_mp_r_buf32[8] = 0;
15324
15325 device_param->kernel_params_mp_r[0] = NULL;
15326 device_param->kernel_params_mp_r[1] = NULL;
15327 device_param->kernel_params_mp_r[2] = NULL;
15328 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15329 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15330 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15331 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15332 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15333 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15334
15335 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15336 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15337
15338 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15339 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15340 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15341 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15342 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15343 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15344 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15345
15346 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15347 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15348
15349 device_param->kernel_params_memset_buf32[1] = 0; // value
15350 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15351
15352 device_param->kernel_params_memset[0] = NULL;
15353 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15354 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15355
15356 /**
15357 * kernel name
15358 */
15359
15360 size_t kernel_wgs_tmp;
15361
15362 char kernel_name[64] = { 0 };
15363
15364 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15365 {
15366 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15367 {
15368 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15369
15370 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15371
15372 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15373
15374 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15375
15376 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15377
15378 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15379 }
15380 else
15381 {
15382 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15383
15384 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15385
15386 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15387
15388 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15389
15390 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15391
15392 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15393 }
15394
15395 if (data.attack_mode == ATTACK_MODE_BF)
15396 {
15397 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15398 {
15399 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15400
15401 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15402
15403 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);
15404 }
15405 }
15406 }
15407 else
15408 {
15409 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15410
15411 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15412
15413 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15414
15415 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15416
15417 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15418
15419 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15420
15421 if (opts_type & OPTS_TYPE_HOOK12)
15422 {
15423 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15424
15425 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15426
15427 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);
15428 }
15429
15430 if (opts_type & OPTS_TYPE_HOOK23)
15431 {
15432 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15433
15434 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15435
15436 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);
15437 }
15438 }
15439
15440 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);
15441 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);
15442 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);
15443
15444 for (uint i = 0; i <= 20; i++)
15445 {
15446 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15447 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15448 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15449
15450 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15451 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15452 }
15453
15454 for (uint i = 21; i <= 31; i++)
15455 {
15456 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15457 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15458 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15459
15460 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15461 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15462 }
15463
15464 // GPU memset
15465
15466 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15467
15468 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);
15469
15470 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15471 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15472 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15473
15474 // MP start
15475
15476 if (attack_mode == ATTACK_MODE_BF)
15477 {
15478 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15479 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15480
15481 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);
15482 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);
15483
15484 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15485 {
15486 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15487 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15488 }
15489 }
15490 else if (attack_mode == ATTACK_MODE_HYBRID1)
15491 {
15492 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15493
15494 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);
15495 }
15496 else if (attack_mode == ATTACK_MODE_HYBRID2)
15497 {
15498 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15499
15500 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);
15501 }
15502
15503 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15504 {
15505 // nothing to do
15506 }
15507 else
15508 {
15509 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15510
15511 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);
15512 }
15513
15514 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15515 {
15516 // nothing to do
15517 }
15518 else
15519 {
15520 for (uint i = 0; i < 5; i++)
15521 {
15522 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15523 }
15524
15525 for (uint i = 5; i < 7; i++)
15526 {
15527 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15528 }
15529 }
15530
15531 // maybe this has been updated by clGetKernelWorkGroupInfo()
15532 // value can only be decreased, so we don't need to reallocate buffers
15533
15534 device_param->kernel_threads = kernel_threads;
15535
15536 // zero some data buffers
15537
15538 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15539 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15540 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15541 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15542 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15543 run_kernel_bzero (device_param, device_param->d_result, size_results);
15544
15545 /**
15546 * special buffers
15547 */
15548
15549 if (attack_kern == ATTACK_KERN_STRAIGHT)
15550 {
15551 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15552 }
15553 else if (attack_kern == ATTACK_KERN_COMBI)
15554 {
15555 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15556 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15557 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15558 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15559 }
15560 else if (attack_kern == ATTACK_KERN_BF)
15561 {
15562 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15563 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15564 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15565 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15566 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15567 }
15568
15569 #if defined(HAVE_HWMON)
15570
15571 /**
15572 * Store thermal target temperature so we can send a notice to user
15573 */
15574
15575 if (gpu_temp_disable == 0)
15576 {
15577 const int gpu_temp_threshold_slowdown = hm_get_threshold_slowdown_with_device_id (device_id);
15578 const int gpu_temp_threshold_shutdown = hm_get_threshold_slowdown_with_device_id (device_id);
15579
15580 data.hm_device[device_id].gpu_temp_threshold_slowdown = (gpu_temp_threshold_slowdown > 0) ? gpu_temp_threshold_slowdown : 10000;
15581 data.hm_device[device_id].gpu_temp_threshold_shutdown = (gpu_temp_threshold_shutdown > 0) ? gpu_temp_threshold_shutdown : 10000;
15582
15583 // we could use those numbers for gpu_temp_retain and gpu_temp_abort, too
15584 }
15585
15586 /**
15587 * Store initial fanspeed if gpu_temp_retain is enabled
15588 */
15589
15590 if (gpu_temp_disable == 0)
15591 {
15592 if (gpu_temp_retain != 0)
15593 {
15594 hc_thread_mutex_lock (mux_adl);
15595
15596 if (data.hm_device[device_id].fan_get_supported == 1)
15597 {
15598 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
15599 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
15600
15601 temp_retain_fanspeed_value[device_id] = fanspeed;
15602 temp_retain_fanpolicy_value[device_id] = fanpolicy;
15603
15604 // we also set it to tell the OS we take control over the fan and it's automatic controller
15605 // if it was set to automatic. we do not control user-defined fanspeeds.
15606
15607 if (fanpolicy == 1)
15608 {
15609 data.hm_device[device_id].fan_set_supported = 1;
15610
15611 int rc = -1;
15612
15613 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15614 {
15615 rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed, 1);
15616 }
15617 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15618 {
15619
15620 }
15621
15622 if (rc == 0)
15623 {
15624 data.hm_device[device_id].fan_set_supported = 1;
15625 }
15626 else
15627 {
15628 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
15629
15630 data.hm_device[device_id].fan_set_supported = 0;
15631 }
15632 }
15633 else
15634 {
15635 data.hm_device[device_id].fan_set_supported = 0;
15636 }
15637 }
15638
15639 hc_thread_mutex_unlock (mux_adl);
15640 }
15641 }
15642
15643 /**
15644 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15645 */
15646
15647 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15648 {
15649 hc_thread_mutex_lock (mux_adl);
15650
15651 if (data.hm_device[device_id].od_version == 6)
15652 {
15653 int ADL_rc;
15654
15655 // check powertune capabilities first, if not available then skip device
15656
15657 int powertune_supported = 0;
15658
15659 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15660 {
15661 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15662
15663 return (-1);
15664 }
15665
15666 if (powertune_supported != 0)
15667 {
15668 // powercontrol settings
15669
15670 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15671
15672 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15673 {
15674 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15675 }
15676
15677 if (ADL_rc != ADL_OK)
15678 {
15679 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15680
15681 return (-1);
15682 }
15683
15684 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15685 {
15686 log_error ("ERROR: Failed to set new ADL PowerControl values");
15687
15688 return (-1);
15689 }
15690
15691 // clocks
15692
15693 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15694
15695 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15696
15697 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)
15698 {
15699 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15700
15701 return (-1);
15702 }
15703
15704 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15705
15706 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15707
15708 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15709 {
15710 log_error ("ERROR: Failed to get ADL device capabilities");
15711
15712 return (-1);
15713 }
15714
15715 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15716 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15717
15718 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15719 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15720
15721 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15722 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15723
15724 // warning if profile has too low max values
15725
15726 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15727 {
15728 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15729 }
15730
15731 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15732 {
15733 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15734 }
15735
15736 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15737
15738 performance_state->iNumberOfPerformanceLevels = 2;
15739
15740 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15741 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15742 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15743 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15744
15745 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)
15746 {
15747 log_info ("ERROR: Failed to set ADL performance state");
15748
15749 return (-1);
15750 }
15751
15752 local_free (performance_state);
15753 }
15754 }
15755
15756 hc_thread_mutex_unlock (mux_adl);
15757 }
15758
15759 #endif // HAVE_HWMON
15760 }
15761
15762 data.kernel_power_all = kernel_power_all;
15763
15764 if (data.quiet == 0) log_info_nn ("");
15765
15766 /**
15767 * In benchmark-mode, inform user which algorithm is checked
15768 */
15769
15770 if (benchmark == 1)
15771 {
15772 if (machine_readable == 0)
15773 {
15774 quiet = 0;
15775
15776 data.quiet = quiet;
15777
15778 char *hash_type = strhashtype (data.hash_mode); // not a bug
15779
15780 log_info ("Hashtype: %s", hash_type);
15781 log_info ("");
15782 }
15783 }
15784
15785 /**
15786 * keep track of the progress
15787 */
15788
15789 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15790 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15791 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15792
15793 /**
15794 * open filehandles
15795 */
15796
15797 #if _WIN
15798 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15799 {
15800 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15801
15802 return (-1);
15803 }
15804
15805 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15806 {
15807 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15808
15809 return (-1);
15810 }
15811
15812 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15813 {
15814 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15815
15816 return (-1);
15817 }
15818 #endif
15819
15820 /**
15821 * dictionary pad
15822 */
15823
15824 segment_size *= (1024 * 1024);
15825
15826 data.segment_size = segment_size;
15827
15828 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15829
15830 wl_data->buf = (char *) mymalloc (segment_size);
15831 wl_data->avail = segment_size;
15832 wl_data->incr = segment_size;
15833 wl_data->cnt = 0;
15834 wl_data->pos = 0;
15835
15836 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15837
15838 data.wordlist_mode = wordlist_mode;
15839
15840 cs_t *css_buf = NULL;
15841 uint css_cnt = 0;
15842 uint dictcnt = 0;
15843 uint maskcnt = 1;
15844 char **masks = NULL;
15845 char **dictfiles = NULL;
15846
15847 uint mask_from_file = 0;
15848
15849 if (attack_mode == ATTACK_MODE_STRAIGHT)
15850 {
15851 if (wordlist_mode == WL_MODE_FILE)
15852 {
15853 int wls_left = myargc - (optind + 1);
15854
15855 for (int i = 0; i < wls_left; i++)
15856 {
15857 char *l0_filename = myargv[optind + 1 + i];
15858
15859 struct stat l0_stat;
15860
15861 if (stat (l0_filename, &l0_stat) == -1)
15862 {
15863 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15864
15865 return (-1);
15866 }
15867
15868 uint is_dir = S_ISDIR (l0_stat.st_mode);
15869
15870 if (is_dir == 0)
15871 {
15872 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15873
15874 dictcnt++;
15875
15876 dictfiles[dictcnt - 1] = l0_filename;
15877 }
15878 else
15879 {
15880 // do not allow --keyspace w/ a directory
15881
15882 if (keyspace == 1)
15883 {
15884 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15885
15886 return (-1);
15887 }
15888
15889 char **dictionary_files = NULL;
15890
15891 dictionary_files = scan_directory (l0_filename);
15892
15893 if (dictionary_files != NULL)
15894 {
15895 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15896
15897 for (int d = 0; dictionary_files[d] != NULL; d++)
15898 {
15899 char *l1_filename = dictionary_files[d];
15900
15901 struct stat l1_stat;
15902
15903 if (stat (l1_filename, &l1_stat) == -1)
15904 {
15905 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15906
15907 return (-1);
15908 }
15909
15910 if (S_ISREG (l1_stat.st_mode))
15911 {
15912 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15913
15914 dictcnt++;
15915
15916 dictfiles[dictcnt - 1] = strdup (l1_filename);
15917 }
15918 }
15919 }
15920
15921 local_free (dictionary_files);
15922 }
15923 }
15924
15925 if (dictcnt < 1)
15926 {
15927 log_error ("ERROR: No usable dictionary file found.");
15928
15929 return (-1);
15930 }
15931 }
15932 else if (wordlist_mode == WL_MODE_STDIN)
15933 {
15934 dictcnt = 1;
15935 }
15936 }
15937 else if (attack_mode == ATTACK_MODE_COMBI)
15938 {
15939 // display
15940
15941 char *dictfile1 = myargv[optind + 1 + 0];
15942 char *dictfile2 = myargv[optind + 1 + 1];
15943
15944 // find the bigger dictionary and use as base
15945
15946 FILE *fp1 = NULL;
15947 FILE *fp2 = NULL;
15948
15949 struct stat tmp_stat;
15950
15951 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15952 {
15953 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15954
15955 return (-1);
15956 }
15957
15958 if (stat (dictfile1, &tmp_stat) == -1)
15959 {
15960 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15961
15962 fclose (fp1);
15963
15964 return (-1);
15965 }
15966
15967 if (S_ISDIR (tmp_stat.st_mode))
15968 {
15969 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15970
15971 fclose (fp1);
15972
15973 return (-1);
15974 }
15975
15976 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15977 {
15978 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15979
15980 fclose (fp1);
15981
15982 return (-1);
15983 }
15984
15985 if (stat (dictfile2, &tmp_stat) == -1)
15986 {
15987 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15988
15989 fclose (fp1);
15990 fclose (fp2);
15991
15992 return (-1);
15993 }
15994
15995 if (S_ISDIR (tmp_stat.st_mode))
15996 {
15997 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15998
15999 fclose (fp1);
16000 fclose (fp2);
16001
16002 return (-1);
16003 }
16004
16005 data.combs_cnt = 1;
16006
16007 data.quiet = 1;
16008
16009 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16010
16011 data.quiet = quiet;
16012
16013 if (words1_cnt == 0)
16014 {
16015 log_error ("ERROR: %s: empty file", dictfile1);
16016
16017 fclose (fp1);
16018 fclose (fp2);
16019
16020 return (-1);
16021 }
16022
16023 data.combs_cnt = 1;
16024
16025 data.quiet = 1;
16026
16027 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16028
16029 data.quiet = quiet;
16030
16031 if (words2_cnt == 0)
16032 {
16033 log_error ("ERROR: %s: empty file", dictfile2);
16034
16035 fclose (fp1);
16036 fclose (fp2);
16037
16038 return (-1);
16039 }
16040
16041 fclose (fp1);
16042 fclose (fp2);
16043
16044 data.dictfile = dictfile1;
16045 data.dictfile2 = dictfile2;
16046
16047 if (words1_cnt >= words2_cnt)
16048 {
16049 data.combs_cnt = words2_cnt;
16050 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16051
16052 dictfiles = &data.dictfile;
16053
16054 dictcnt = 1;
16055 }
16056 else
16057 {
16058 data.combs_cnt = words1_cnt;
16059 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16060
16061 dictfiles = &data.dictfile2;
16062
16063 dictcnt = 1;
16064
16065 // we also have to switch wordlist related rules!
16066
16067 char *tmpc = data.rule_buf_l;
16068
16069 data.rule_buf_l = data.rule_buf_r;
16070 data.rule_buf_r = tmpc;
16071
16072 int tmpi = data.rule_len_l;
16073
16074 data.rule_len_l = data.rule_len_r;
16075 data.rule_len_r = tmpi;
16076 }
16077 }
16078 else if (attack_mode == ATTACK_MODE_BF)
16079 {
16080 char *mask = NULL;
16081
16082 maskcnt = 0;
16083
16084 if (benchmark == 0)
16085 {
16086 mask = myargv[optind + 1];
16087
16088 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16089
16090 if ((optind + 2) <= myargc)
16091 {
16092 struct stat file_stat;
16093
16094 if (stat (mask, &file_stat) == -1)
16095 {
16096 maskcnt = 1;
16097
16098 masks[maskcnt - 1] = mystrdup (mask);
16099 }
16100 else
16101 {
16102 int wls_left = myargc - (optind + 1);
16103
16104 uint masks_avail = INCR_MASKS;
16105
16106 for (int i = 0; i < wls_left; i++)
16107 {
16108 if (i != 0)
16109 {
16110 mask = myargv[optind + 1 + i];
16111
16112 if (stat (mask, &file_stat) == -1)
16113 {
16114 log_error ("ERROR: %s: %s", mask, strerror (errno));
16115
16116 return (-1);
16117 }
16118 }
16119
16120 uint is_file = S_ISREG (file_stat.st_mode);
16121
16122 if (is_file == 1)
16123 {
16124 FILE *mask_fp;
16125
16126 if ((mask_fp = fopen (mask, "r")) == NULL)
16127 {
16128 log_error ("ERROR: %s: %s", mask, strerror (errno));
16129
16130 return (-1);
16131 }
16132
16133 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16134
16135 while (!feof (mask_fp))
16136 {
16137 memset (line_buf, 0, HCBUFSIZ);
16138
16139 int line_len = fgetl (mask_fp, line_buf);
16140
16141 if (line_len == 0) continue;
16142
16143 if (line_buf[0] == '#') continue;
16144
16145 if (masks_avail == maskcnt)
16146 {
16147 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16148
16149 masks_avail += INCR_MASKS;
16150 }
16151
16152 masks[maskcnt] = mystrdup (line_buf);
16153
16154 maskcnt++;
16155 }
16156
16157 myfree (line_buf);
16158
16159 fclose (mask_fp);
16160 }
16161 else
16162 {
16163 log_error ("ERROR: %s: unsupported file-type", mask);
16164
16165 return (-1);
16166 }
16167 }
16168
16169 mask_from_file = 1;
16170 }
16171 }
16172 else
16173 {
16174 custom_charset_1 = (char *) "?l?d?u";
16175 custom_charset_2 = (char *) "?l?d";
16176 custom_charset_3 = (char *) "?l?d*!$@_";
16177
16178 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16179 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16180 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16181
16182 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16183
16184 wordlist_mode = WL_MODE_MASK;
16185
16186 data.wordlist_mode = wordlist_mode;
16187
16188 increment = 1;
16189
16190 maskcnt = 1;
16191 }
16192 }
16193 else
16194 {
16195 /**
16196 * generate full masks and charsets
16197 */
16198
16199 masks = (char **) mymalloc (sizeof (char *));
16200
16201 switch (hash_mode)
16202 {
16203 case 1731: pw_min = 5;
16204 pw_max = 5;
16205 mask = mystrdup ("?b?b?b?b?b");
16206 break;
16207 case 12500: pw_min = 5;
16208 pw_max = 5;
16209 mask = mystrdup ("?b?b?b?b?b");
16210 break;
16211 default: pw_min = 7;
16212 pw_max = 7;
16213 mask = mystrdup ("?b?b?b?b?b?b?b");
16214 break;
16215 }
16216
16217 maskcnt = 1;
16218
16219 masks[maskcnt - 1] = mystrdup (mask);
16220
16221 wordlist_mode = WL_MODE_MASK;
16222
16223 data.wordlist_mode = wordlist_mode;
16224
16225 increment = 1;
16226 }
16227
16228 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16229
16230 if (increment)
16231 {
16232 if (increment_min > pw_min) pw_min = increment_min;
16233
16234 if (increment_max < pw_max) pw_max = increment_max;
16235 }
16236 }
16237 else if (attack_mode == ATTACK_MODE_HYBRID1)
16238 {
16239 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16240
16241 // display
16242
16243 char *mask = myargv[myargc - 1];
16244
16245 maskcnt = 0;
16246
16247 masks = (char **) mymalloc (1 * sizeof (char *));
16248
16249 // mod
16250
16251 struct stat file_stat;
16252
16253 if (stat (mask, &file_stat) == -1)
16254 {
16255 maskcnt = 1;
16256
16257 masks[maskcnt - 1] = mystrdup (mask);
16258 }
16259 else
16260 {
16261 uint is_file = S_ISREG (file_stat.st_mode);
16262
16263 if (is_file == 1)
16264 {
16265 FILE *mask_fp;
16266
16267 if ((mask_fp = fopen (mask, "r")) == NULL)
16268 {
16269 log_error ("ERROR: %s: %s", mask, strerror (errno));
16270
16271 return (-1);
16272 }
16273
16274 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16275
16276 uint masks_avail = 1;
16277
16278 while (!feof (mask_fp))
16279 {
16280 memset (line_buf, 0, HCBUFSIZ);
16281
16282 int line_len = fgetl (mask_fp, line_buf);
16283
16284 if (line_len == 0) continue;
16285
16286 if (line_buf[0] == '#') continue;
16287
16288 if (masks_avail == maskcnt)
16289 {
16290 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16291
16292 masks_avail += INCR_MASKS;
16293 }
16294
16295 masks[maskcnt] = mystrdup (line_buf);
16296
16297 maskcnt++;
16298 }
16299
16300 myfree (line_buf);
16301
16302 fclose (mask_fp);
16303
16304 mask_from_file = 1;
16305 }
16306 else
16307 {
16308 maskcnt = 1;
16309
16310 masks[maskcnt - 1] = mystrdup (mask);
16311 }
16312 }
16313
16314 // base
16315
16316 int wls_left = myargc - (optind + 2);
16317
16318 for (int i = 0; i < wls_left; i++)
16319 {
16320 char *filename = myargv[optind + 1 + i];
16321
16322 struct stat file_stat;
16323
16324 if (stat (filename, &file_stat) == -1)
16325 {
16326 log_error ("ERROR: %s: %s", filename, strerror (errno));
16327
16328 return (-1);
16329 }
16330
16331 uint is_dir = S_ISDIR (file_stat.st_mode);
16332
16333 if (is_dir == 0)
16334 {
16335 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16336
16337 dictcnt++;
16338
16339 dictfiles[dictcnt - 1] = filename;
16340 }
16341 else
16342 {
16343 // do not allow --keyspace w/ a directory
16344
16345 if (keyspace == 1)
16346 {
16347 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16348
16349 return (-1);
16350 }
16351
16352 char **dictionary_files = NULL;
16353
16354 dictionary_files = scan_directory (filename);
16355
16356 if (dictionary_files != NULL)
16357 {
16358 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16359
16360 for (int d = 0; dictionary_files[d] != NULL; d++)
16361 {
16362 char *l1_filename = dictionary_files[d];
16363
16364 struct stat l1_stat;
16365
16366 if (stat (l1_filename, &l1_stat) == -1)
16367 {
16368 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16369
16370 return (-1);
16371 }
16372
16373 if (S_ISREG (l1_stat.st_mode))
16374 {
16375 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16376
16377 dictcnt++;
16378
16379 dictfiles[dictcnt - 1] = strdup (l1_filename);
16380 }
16381 }
16382 }
16383
16384 local_free (dictionary_files);
16385 }
16386 }
16387
16388 if (dictcnt < 1)
16389 {
16390 log_error ("ERROR: No usable dictionary file found.");
16391
16392 return (-1);
16393 }
16394
16395 if (increment)
16396 {
16397 maskcnt = 0;
16398
16399 uint mask_min = increment_min; // we can't reject smaller masks here
16400 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16401
16402 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16403 {
16404 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16405
16406 if (cur_mask == NULL) break;
16407
16408 masks[maskcnt] = cur_mask;
16409
16410 maskcnt++;
16411
16412 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16413 }
16414 }
16415 }
16416 else if (attack_mode == ATTACK_MODE_HYBRID2)
16417 {
16418 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16419
16420 // display
16421
16422 char *mask = myargv[optind + 1 + 0];
16423
16424 maskcnt = 0;
16425
16426 masks = (char **) mymalloc (1 * sizeof (char *));
16427
16428 // mod
16429
16430 struct stat file_stat;
16431
16432 if (stat (mask, &file_stat) == -1)
16433 {
16434 maskcnt = 1;
16435
16436 masks[maskcnt - 1] = mystrdup (mask);
16437 }
16438 else
16439 {
16440 uint is_file = S_ISREG (file_stat.st_mode);
16441
16442 if (is_file == 1)
16443 {
16444 FILE *mask_fp;
16445
16446 if ((mask_fp = fopen (mask, "r")) == NULL)
16447 {
16448 log_error ("ERROR: %s: %s", mask, strerror (errno));
16449
16450 return (-1);
16451 }
16452
16453 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16454
16455 uint masks_avail = 1;
16456
16457 while (!feof (mask_fp))
16458 {
16459 memset (line_buf, 0, HCBUFSIZ);
16460
16461 int line_len = fgetl (mask_fp, line_buf);
16462
16463 if (line_len == 0) continue;
16464
16465 if (line_buf[0] == '#') continue;
16466
16467 if (masks_avail == maskcnt)
16468 {
16469 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16470
16471 masks_avail += INCR_MASKS;
16472 }
16473
16474 masks[maskcnt] = mystrdup (line_buf);
16475
16476 maskcnt++;
16477 }
16478
16479 myfree (line_buf);
16480
16481 fclose (mask_fp);
16482
16483 mask_from_file = 1;
16484 }
16485 else
16486 {
16487 maskcnt = 1;
16488
16489 masks[maskcnt - 1] = mystrdup (mask);
16490 }
16491 }
16492
16493 // base
16494
16495 int wls_left = myargc - (optind + 2);
16496
16497 for (int i = 0; i < wls_left; i++)
16498 {
16499 char *filename = myargv[optind + 2 + i];
16500
16501 struct stat file_stat;
16502
16503 if (stat (filename, &file_stat) == -1)
16504 {
16505 log_error ("ERROR: %s: %s", filename, strerror (errno));
16506
16507 return (-1);
16508 }
16509
16510 uint is_dir = S_ISDIR (file_stat.st_mode);
16511
16512 if (is_dir == 0)
16513 {
16514 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16515
16516 dictcnt++;
16517
16518 dictfiles[dictcnt - 1] = filename;
16519 }
16520 else
16521 {
16522 // do not allow --keyspace w/ a directory
16523
16524 if (keyspace == 1)
16525 {
16526 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16527
16528 return (-1);
16529 }
16530
16531 char **dictionary_files = NULL;
16532
16533 dictionary_files = scan_directory (filename);
16534
16535 if (dictionary_files != NULL)
16536 {
16537 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16538
16539 for (int d = 0; dictionary_files[d] != NULL; d++)
16540 {
16541 char *l1_filename = dictionary_files[d];
16542
16543 struct stat l1_stat;
16544
16545 if (stat (l1_filename, &l1_stat) == -1)
16546 {
16547 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16548
16549 return (-1);
16550 }
16551
16552 if (S_ISREG (l1_stat.st_mode))
16553 {
16554 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16555
16556 dictcnt++;
16557
16558 dictfiles[dictcnt - 1] = strdup (l1_filename);
16559 }
16560 }
16561 }
16562
16563 local_free (dictionary_files);
16564 }
16565 }
16566
16567 if (dictcnt < 1)
16568 {
16569 log_error ("ERROR: No usable dictionary file found.");
16570
16571 return (-1);
16572 }
16573
16574 if (increment)
16575 {
16576 maskcnt = 0;
16577
16578 uint mask_min = increment_min; // we can't reject smaller masks here
16579 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16580
16581 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16582 {
16583 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16584
16585 if (cur_mask == NULL) break;
16586
16587 masks[maskcnt] = cur_mask;
16588
16589 maskcnt++;
16590
16591 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16592 }
16593 }
16594 }
16595
16596 data.pw_min = pw_min;
16597 data.pw_max = pw_max;
16598
16599 /**
16600 * weak hash check
16601 */
16602
16603 if (weak_hash_threshold >= salts_cnt)
16604 {
16605 hc_device_param_t *device_param = NULL;
16606
16607 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16608 {
16609 device_param = &data.devices_param[device_id];
16610
16611 if (device_param->skipped) continue;
16612
16613 break;
16614 }
16615
16616 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16617
16618 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16619 {
16620 weak_hash_check (device_param, salt_pos);
16621 }
16622
16623 // Display hack, guarantee that there is at least one \r before real start
16624
16625 //if (data.quiet == 0) log_info ("");
16626 }
16627
16628 /**
16629 * status and monitor threads
16630 */
16631
16632 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16633
16634 hc_thread_t i_thread = 0;
16635
16636 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16637 {
16638 hc_thread_create (i_thread, thread_keypress, &benchmark);
16639 }
16640
16641 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16642
16643 uint ni_threads_cnt = 0;
16644
16645 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16646
16647 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16648
16649 ni_threads_cnt++;
16650
16651 /**
16652 * Outfile remove
16653 */
16654
16655 if (keyspace == 0)
16656 {
16657 if (outfile_check_timer != 0)
16658 {
16659 if (data.outfile_check_directory != NULL)
16660 {
16661 if ((hash_mode != 5200) &&
16662 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16663 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16664 (hash_mode != 9000))
16665 {
16666 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16667
16668 ni_threads_cnt++;
16669 }
16670 else
16671 {
16672 outfile_check_timer = 0;
16673 }
16674 }
16675 else
16676 {
16677 outfile_check_timer = 0;
16678 }
16679 }
16680 }
16681
16682 /**
16683 * Inform the user if we got some hashes remove because of the pot file remove feature
16684 */
16685
16686 if (data.quiet == 0)
16687 {
16688 if (potfile_remove_cracks > 0)
16689 {
16690 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16691 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16692 }
16693 }
16694
16695 data.outfile_check_timer = outfile_check_timer;
16696
16697 /**
16698 * main loop
16699 */
16700
16701 char **induction_dictionaries = NULL;
16702
16703 int induction_dictionaries_cnt = 0;
16704
16705 hcstat_table_t *root_table_buf = NULL;
16706 hcstat_table_t *markov_table_buf = NULL;
16707
16708 uint initial_restore_done = 0;
16709
16710 data.maskcnt = maskcnt;
16711
16712 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16713 {
16714 if (data.devices_status == STATUS_CRACKED) break;
16715
16716 data.devices_status = STATUS_INIT;
16717
16718 if (maskpos > rd->maskpos)
16719 {
16720 rd->dictpos = 0;
16721 }
16722
16723 rd->maskpos = maskpos;
16724 data.maskpos = maskpos;
16725
16726 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16727 {
16728 char *mask = masks[maskpos];
16729
16730 if (mask_from_file == 1)
16731 {
16732 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16733
16734 char *str_ptr;
16735 uint str_pos;
16736
16737 uint mask_offset = 0;
16738
16739 uint separator_cnt;
16740
16741 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16742 {
16743 str_ptr = strstr (mask + mask_offset, ",");
16744
16745 if (str_ptr == NULL) break;
16746
16747 str_pos = str_ptr - mask;
16748
16749 // escaped separator, i.e. "\,"
16750
16751 if (str_pos > 0)
16752 {
16753 if (mask[str_pos - 1] == '\\')
16754 {
16755 separator_cnt --;
16756
16757 mask_offset = str_pos + 1;
16758
16759 continue;
16760 }
16761 }
16762
16763 // reset the offset
16764
16765 mask_offset = 0;
16766
16767 mask[str_pos] = '\0';
16768
16769 switch (separator_cnt)
16770 {
16771 case 0:
16772 mp_reset_usr (mp_usr, 0);
16773
16774 custom_charset_1 = mask;
16775 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16776 break;
16777
16778 case 1:
16779 mp_reset_usr (mp_usr, 1);
16780
16781 custom_charset_2 = mask;
16782 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16783 break;
16784
16785 case 2:
16786 mp_reset_usr (mp_usr, 2);
16787
16788 custom_charset_3 = mask;
16789 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16790 break;
16791
16792 case 3:
16793 mp_reset_usr (mp_usr, 3);
16794
16795 custom_charset_4 = mask;
16796 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16797 break;
16798 }
16799
16800 mask = mask + str_pos + 1;
16801 }
16802 }
16803
16804 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16805 {
16806 if (maskpos > 0)
16807 {
16808 local_free (css_buf);
16809 local_free (data.root_css_buf);
16810 local_free (data.markov_css_buf);
16811
16812 local_free (masks[maskpos - 1]);
16813 }
16814
16815 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16816
16817 data.mask = mask;
16818 data.css_cnt = css_cnt;
16819 data.css_buf = css_buf;
16820
16821 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16822
16823 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16824
16825 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16826 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16827
16828 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16829
16830 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16831
16832 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16833 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16834
16835 data.root_css_buf = root_css_buf;
16836 data.markov_css_buf = markov_css_buf;
16837
16838 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16839
16840 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16841
16842 local_free (root_table_buf);
16843 local_free (markov_table_buf);
16844
16845 // args
16846
16847 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16848 {
16849 hc_device_param_t *device_param = &data.devices_param[device_id];
16850
16851 if (device_param->skipped) continue;
16852
16853 device_param->kernel_params_mp[0] = &device_param->d_combs;
16854 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16855 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16856
16857 device_param->kernel_params_mp_buf64[3] = 0;
16858 device_param->kernel_params_mp_buf32[4] = css_cnt;
16859 device_param->kernel_params_mp_buf32[5] = 0;
16860 device_param->kernel_params_mp_buf32[6] = 0;
16861 device_param->kernel_params_mp_buf32[7] = 0;
16862
16863 if (attack_mode == ATTACK_MODE_HYBRID1)
16864 {
16865 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16866 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16867 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16868 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16869 }
16870 else if (attack_mode == ATTACK_MODE_HYBRID2)
16871 {
16872 device_param->kernel_params_mp_buf32[5] = 0;
16873 device_param->kernel_params_mp_buf32[6] = 0;
16874 device_param->kernel_params_mp_buf32[7] = 0;
16875 }
16876
16877 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]);
16878 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]);
16879 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]);
16880
16881 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);
16882 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);
16883 }
16884 }
16885 else if (attack_mode == ATTACK_MODE_BF)
16886 {
16887 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16888
16889 if (increment)
16890 {
16891 for (uint i = 0; i < dictcnt; i++)
16892 {
16893 local_free (dictfiles[i]);
16894 }
16895
16896 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16897 {
16898 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16899
16900 if (l1_filename == NULL) break;
16901
16902 dictcnt++;
16903
16904 dictfiles[dictcnt - 1] = l1_filename;
16905 }
16906 }
16907 else
16908 {
16909 dictcnt++;
16910
16911 dictfiles[dictcnt - 1] = mask;
16912 }
16913
16914 if (dictcnt == 0)
16915 {
16916 log_error ("ERROR: Mask is too small");
16917
16918 return (-1);
16919 }
16920 }
16921 }
16922
16923 free (induction_dictionaries);
16924
16925 // induction_dictionaries_cnt = 0; // implied
16926
16927 if (attack_mode != ATTACK_MODE_BF)
16928 {
16929 if (keyspace == 0)
16930 {
16931 induction_dictionaries = scan_directory (induction_directory);
16932
16933 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16934 }
16935 }
16936
16937 if (induction_dictionaries_cnt)
16938 {
16939 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16940 }
16941
16942 /**
16943 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16944 */
16945 if (keyspace == 1)
16946 {
16947 if ((maskcnt > 1) || (dictcnt > 1))
16948 {
16949 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16950
16951 return (-1);
16952 }
16953 }
16954
16955 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16956 {
16957 char *subid = logfile_generate_subid ();
16958
16959 data.subid = subid;
16960
16961 logfile_sub_msg ("START");
16962
16963 data.devices_status = STATUS_INIT;
16964
16965 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16966 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16967 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16968
16969 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16970
16971 data.cpt_pos = 0;
16972
16973 data.cpt_start = time (NULL);
16974
16975 data.cpt_total = 0;
16976
16977 if (data.restore == 0)
16978 {
16979 rd->words_cur = skip;
16980
16981 skip = 0;
16982
16983 data.skip = 0;
16984 }
16985
16986 data.ms_paused = 0;
16987
16988 data.words_cur = rd->words_cur;
16989
16990 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16991 {
16992 hc_device_param_t *device_param = &data.devices_param[device_id];
16993
16994 if (device_param->skipped) continue;
16995
16996 device_param->speed_pos = 0;
16997
16998 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16999 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17000
17001 device_param->exec_pos = 0;
17002
17003 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17004
17005 device_param->kernel_power = device_param->kernel_power_user;
17006
17007 device_param->outerloop_pos = 0;
17008 device_param->outerloop_left = 0;
17009 device_param->innerloop_pos = 0;
17010 device_param->innerloop_left = 0;
17011
17012 // some more resets:
17013
17014 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17015
17016 device_param->pws_cnt = 0;
17017
17018 device_param->words_off = 0;
17019 device_param->words_done = 0;
17020 }
17021
17022 data.kernel_power_div = 0;
17023
17024 // figure out some workload
17025
17026 if (attack_mode == ATTACK_MODE_STRAIGHT)
17027 {
17028 if (data.wordlist_mode == WL_MODE_FILE)
17029 {
17030 char *dictfile = NULL;
17031
17032 if (induction_dictionaries_cnt)
17033 {
17034 dictfile = induction_dictionaries[0];
17035 }
17036 else
17037 {
17038 dictfile = dictfiles[dictpos];
17039 }
17040
17041 data.dictfile = dictfile;
17042
17043 logfile_sub_string (dictfile);
17044
17045 for (uint i = 0; i < rp_files_cnt; i++)
17046 {
17047 logfile_sub_var_string ("rulefile", rp_files[i]);
17048 }
17049
17050 FILE *fd2 = fopen (dictfile, "rb");
17051
17052 if (fd2 == NULL)
17053 {
17054 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17055
17056 return (-1);
17057 }
17058
17059 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17060
17061 fclose (fd2);
17062
17063 if (data.words_cnt == 0)
17064 {
17065 if (data.devices_status == STATUS_CRACKED) break;
17066 if (data.devices_status == STATUS_ABORTED) break;
17067
17068 dictpos++;
17069
17070 continue;
17071 }
17072 }
17073 }
17074 else if (attack_mode == ATTACK_MODE_COMBI)
17075 {
17076 char *dictfile = data.dictfile;
17077 char *dictfile2 = data.dictfile2;
17078
17079 logfile_sub_string (dictfile);
17080 logfile_sub_string (dictfile2);
17081
17082 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17083 {
17084 FILE *fd2 = fopen (dictfile, "rb");
17085
17086 if (fd2 == NULL)
17087 {
17088 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17089
17090 return (-1);
17091 }
17092
17093 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17094
17095 fclose (fd2);
17096 }
17097 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17098 {
17099 FILE *fd2 = fopen (dictfile2, "rb");
17100
17101 if (fd2 == NULL)
17102 {
17103 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17104
17105 return (-1);
17106 }
17107
17108 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17109
17110 fclose (fd2);
17111 }
17112
17113 if (data.words_cnt == 0)
17114 {
17115 if (data.devices_status == STATUS_CRACKED) break;
17116 if (data.devices_status == STATUS_ABORTED) break;
17117
17118 dictpos++;
17119
17120 continue;
17121 }
17122 }
17123 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17124 {
17125 char *dictfile = NULL;
17126
17127 if (induction_dictionaries_cnt)
17128 {
17129 dictfile = induction_dictionaries[0];
17130 }
17131 else
17132 {
17133 dictfile = dictfiles[dictpos];
17134 }
17135
17136 data.dictfile = dictfile;
17137
17138 char *mask = data.mask;
17139
17140 logfile_sub_string (dictfile);
17141 logfile_sub_string (mask);
17142
17143 FILE *fd2 = fopen (dictfile, "rb");
17144
17145 if (fd2 == NULL)
17146 {
17147 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17148
17149 return (-1);
17150 }
17151
17152 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17153
17154 fclose (fd2);
17155
17156 if (data.words_cnt == 0)
17157 {
17158 if (data.devices_status == STATUS_CRACKED) break;
17159 if (data.devices_status == STATUS_ABORTED) break;
17160
17161 dictpos++;
17162
17163 continue;
17164 }
17165 }
17166 else if (attack_mode == ATTACK_MODE_BF)
17167 {
17168 local_free (css_buf);
17169 local_free (data.root_css_buf);
17170 local_free (data.markov_css_buf);
17171
17172 char *mask = dictfiles[dictpos];
17173
17174 logfile_sub_string (mask);
17175
17176 // base
17177
17178 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17179
17180 if (opts_type & OPTS_TYPE_PT_UNICODE)
17181 {
17182 uint css_cnt_unicode = css_cnt * 2;
17183
17184 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17185
17186 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17187 {
17188 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17189
17190 css_buf_unicode[j + 1].cs_buf[0] = 0;
17191 css_buf_unicode[j + 1].cs_len = 1;
17192 }
17193
17194 free (css_buf);
17195
17196 css_buf = css_buf_unicode;
17197 css_cnt = css_cnt_unicode;
17198 }
17199
17200 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17201
17202 uint mask_min = pw_min;
17203 uint mask_max = pw_max;
17204
17205 if (opts_type & OPTS_TYPE_PT_UNICODE)
17206 {
17207 mask_min *= 2;
17208 mask_max *= 2;
17209 }
17210
17211 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17212 {
17213 if (css_cnt < mask_min)
17214 {
17215 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17216 }
17217
17218 if (css_cnt > mask_max)
17219 {
17220 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17221 }
17222
17223 // skip to next mask
17224
17225 dictpos++;
17226
17227 rd->dictpos = dictpos;
17228
17229 logfile_sub_msg ("STOP");
17230
17231 continue;
17232 }
17233
17234 uint save_css_cnt = css_cnt;
17235
17236 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17237 {
17238 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17239 {
17240 uint salt_len = (uint) data.salts_buf[0].salt_len;
17241 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17242
17243 uint css_cnt_salt = css_cnt + salt_len;
17244
17245 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17246
17247 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17248
17249 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17250 {
17251 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17252 css_buf_salt[j].cs_len = 1;
17253 }
17254
17255 free (css_buf);
17256
17257 css_buf = css_buf_salt;
17258 css_cnt = css_cnt_salt;
17259 }
17260 }
17261
17262 data.mask = mask;
17263 data.css_cnt = css_cnt;
17264 data.css_buf = css_buf;
17265
17266 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17267
17268 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17269
17270 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17271
17272 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17273 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17274
17275 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17276
17277 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17278
17279 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17280 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17281
17282 data.root_css_buf = root_css_buf;
17283 data.markov_css_buf = markov_css_buf;
17284
17285 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17286
17287 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17288
17289 local_free (root_table_buf);
17290 local_free (markov_table_buf);
17291
17292 // copy + args
17293
17294 uint css_cnt_l = css_cnt;
17295 uint css_cnt_r;
17296
17297 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17298 {
17299 if (save_css_cnt < 6)
17300 {
17301 css_cnt_r = 1;
17302 }
17303 else if (save_css_cnt == 6)
17304 {
17305 css_cnt_r = 2;
17306 }
17307 else
17308 {
17309 if (opts_type & OPTS_TYPE_PT_UNICODE)
17310 {
17311 if (save_css_cnt == 8 || save_css_cnt == 10)
17312 {
17313 css_cnt_r = 2;
17314 }
17315 else
17316 {
17317 css_cnt_r = 4;
17318 }
17319 }
17320 else
17321 {
17322 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17323 {
17324 css_cnt_r = 3;
17325 }
17326 else
17327 {
17328 css_cnt_r = 4;
17329 }
17330 }
17331 }
17332 }
17333 else
17334 {
17335 css_cnt_r = 1;
17336
17337 /* unfinished code?
17338 int sum = css_buf[css_cnt_r - 1].cs_len;
17339
17340 for (uint i = 1; i < 4 && i < css_cnt; i++)
17341 {
17342 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17343
17344 css_cnt_r++;
17345
17346 sum *= css_buf[css_cnt_r - 1].cs_len;
17347 }
17348 */
17349 }
17350
17351 css_cnt_l -= css_cnt_r;
17352
17353 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17354
17355 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17356 {
17357 hc_device_param_t *device_param = &data.devices_param[device_id];
17358
17359 if (device_param->skipped) continue;
17360
17361 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17362 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17363 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17364
17365 device_param->kernel_params_mp_l_buf64[3] = 0;
17366 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17367 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17368 device_param->kernel_params_mp_l_buf32[6] = 0;
17369 device_param->kernel_params_mp_l_buf32[7] = 0;
17370 device_param->kernel_params_mp_l_buf32[8] = 0;
17371
17372 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17373 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17374 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17375 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17376
17377 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17378 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17379 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17380
17381 device_param->kernel_params_mp_r_buf64[3] = 0;
17382 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17383 device_param->kernel_params_mp_r_buf32[5] = 0;
17384 device_param->kernel_params_mp_r_buf32[6] = 0;
17385 device_param->kernel_params_mp_r_buf32[7] = 0;
17386
17387 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]);
17388 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]);
17389 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]);
17390
17391 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]);
17392 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]);
17393 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]);
17394
17395 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);
17396 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);
17397 }
17398 }
17399
17400 u64 words_base = data.words_cnt;
17401
17402 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17403 {
17404 if (data.kernel_rules_cnt)
17405 {
17406 words_base /= data.kernel_rules_cnt;
17407 }
17408 }
17409 else if (data.attack_kern == ATTACK_KERN_COMBI)
17410 {
17411 if (data.combs_cnt)
17412 {
17413 words_base /= data.combs_cnt;
17414 }
17415 }
17416 else if (data.attack_kern == ATTACK_KERN_BF)
17417 {
17418 if (data.bfs_cnt)
17419 {
17420 words_base /= data.bfs_cnt;
17421 }
17422 }
17423
17424 data.words_base = words_base;
17425
17426 if (keyspace == 1)
17427 {
17428 log_info ("%llu", (unsigned long long int) words_base);
17429
17430 return (0);
17431 }
17432
17433 if (data.words_cur > data.words_base)
17434 {
17435 log_error ("ERROR: restore value greater keyspace");
17436
17437 return (-1);
17438 }
17439
17440 if (data.words_cur)
17441 {
17442 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17443 {
17444 for (uint i = 0; i < data.salts_cnt; i++)
17445 {
17446 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17447 }
17448 }
17449 else if (data.attack_kern == ATTACK_KERN_COMBI)
17450 {
17451 for (uint i = 0; i < data.salts_cnt; i++)
17452 {
17453 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17454 }
17455 }
17456 else if (data.attack_kern == ATTACK_KERN_BF)
17457 {
17458 for (uint i = 0; i < data.salts_cnt; i++)
17459 {
17460 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17461 }
17462 }
17463 }
17464
17465 /*
17466 * Inform user about possible slow speeds
17467 */
17468
17469 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17470 {
17471 if (data.words_base < kernel_power_all)
17472 {
17473 if (quiet == 0)
17474 {
17475 log_info ("ATTENTION!");
17476 log_info (" The wordlist or mask you are using is too small.");
17477 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17478 log_info (" The cracking speed will drop.");
17479 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17480 log_info ("");
17481 }
17482 }
17483 }
17484
17485 /*
17486 * Update loopback file
17487 */
17488
17489 if (loopback == 1)
17490 {
17491 time_t now;
17492
17493 time (&now);
17494
17495 uint random_num = get_random_num (0, 9999);
17496
17497 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17498
17499 data.loopback_file = loopback_file;
17500 }
17501
17502 /*
17503 * Update dictionary statistic
17504 */
17505
17506 if (keyspace == 0)
17507 {
17508 dictstat_fp = fopen (dictstat, "wb");
17509
17510 if (dictstat_fp)
17511 {
17512 lock_file (dictstat_fp);
17513
17514 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17515
17516 fclose (dictstat_fp);
17517 }
17518 }
17519
17520 data.devices_status = STATUS_RUNNING;
17521
17522 if (initial_restore_done == 0)
17523 {
17524 if (data.restore_disable == 0) cycle_restore ();
17525
17526 initial_restore_done = 1;
17527 }
17528
17529 hc_timer_set (&data.timer_running);
17530
17531 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17532 {
17533 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17534 {
17535 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17536 if (quiet == 0) fflush (stdout);
17537 }
17538 }
17539 else if (wordlist_mode == WL_MODE_STDIN)
17540 {
17541 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17542 if (data.quiet == 0) log_info ("");
17543 }
17544
17545 time_t runtime_start;
17546
17547 time (&runtime_start);
17548
17549 data.runtime_start = runtime_start;
17550
17551 /**
17552 * create cracker threads
17553 */
17554
17555 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17556
17557 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17558 {
17559 hc_device_param_t *device_param = &devices_param[device_id];
17560
17561 if (wordlist_mode == WL_MODE_STDIN)
17562 {
17563 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17564 }
17565 else
17566 {
17567 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17568 }
17569 }
17570
17571 // wait for crack threads to exit
17572
17573 hc_thread_wait (data.devices_cnt, c_threads);
17574
17575 local_free (c_threads);
17576
17577 data.restore = 0;
17578
17579 // finalize task
17580
17581 logfile_sub_var_uint ("status-after-work", data.devices_status);
17582
17583 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17584
17585 if (data.devices_status == STATUS_CRACKED) break;
17586 if (data.devices_status == STATUS_ABORTED) break;
17587
17588 if (data.devices_status == STATUS_BYPASS)
17589 {
17590 data.devices_status = STATUS_RUNNING;
17591 }
17592
17593 if (induction_dictionaries_cnt)
17594 {
17595 unlink (induction_dictionaries[0]);
17596 }
17597
17598 free (induction_dictionaries);
17599
17600 if (attack_mode != ATTACK_MODE_BF)
17601 {
17602 induction_dictionaries = scan_directory (induction_directory);
17603
17604 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17605 }
17606
17607 if (benchmark == 0)
17608 {
17609 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17610 {
17611 if (quiet == 0) clear_prompt ();
17612
17613 if (quiet == 0) log_info ("");
17614
17615 if (status == 1)
17616 {
17617 status_display ();
17618 }
17619 else
17620 {
17621 if (quiet == 0) status_display ();
17622 }
17623
17624 if (quiet == 0) log_info ("");
17625 }
17626 }
17627
17628 if (attack_mode == ATTACK_MODE_BF)
17629 {
17630 dictpos++;
17631
17632 rd->dictpos = dictpos;
17633 }
17634 else
17635 {
17636 if (induction_dictionaries_cnt)
17637 {
17638 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17639 }
17640 else
17641 {
17642 dictpos++;
17643
17644 rd->dictpos = dictpos;
17645 }
17646 }
17647
17648 time_t runtime_stop;
17649
17650 time (&runtime_stop);
17651
17652 data.runtime_stop = runtime_stop;
17653
17654 logfile_sub_uint (runtime_start);
17655 logfile_sub_uint (runtime_stop);
17656
17657 logfile_sub_msg ("STOP");
17658
17659 global_free (subid);
17660 }
17661
17662 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17663
17664 if (data.devices_status == STATUS_CRACKED) break;
17665 if (data.devices_status == STATUS_ABORTED) break;
17666 if (data.devices_status == STATUS_QUIT) break;
17667
17668 if (data.devices_status == STATUS_BYPASS)
17669 {
17670 data.devices_status = STATUS_RUNNING;
17671 }
17672 }
17673
17674 // 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
17675
17676 if (attack_mode == ATTACK_MODE_STRAIGHT)
17677 {
17678 if (data.wordlist_mode == WL_MODE_FILE)
17679 {
17680 if (data.dictfile == NULL)
17681 {
17682 if (dictfiles != NULL)
17683 {
17684 data.dictfile = dictfiles[0];
17685
17686 hc_timer_set (&data.timer_running);
17687 }
17688 }
17689 }
17690 }
17691 // NOTE: combi is okay because it is already set beforehand
17692 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17693 {
17694 if (data.dictfile == NULL)
17695 {
17696 if (dictfiles != NULL)
17697 {
17698 hc_timer_set (&data.timer_running);
17699
17700 data.dictfile = dictfiles[0];
17701 }
17702 }
17703 }
17704 else if (attack_mode == ATTACK_MODE_BF)
17705 {
17706 if (data.mask == NULL)
17707 {
17708 hc_timer_set (&data.timer_running);
17709
17710 data.mask = masks[0];
17711 }
17712 }
17713
17714 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17715 {
17716 data.devices_status = STATUS_EXHAUSTED;
17717 }
17718
17719 // if cracked / aborted remove last induction dictionary
17720
17721 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17722 {
17723 struct stat induct_stat;
17724
17725 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17726 {
17727 unlink (induction_dictionaries[file_pos]);
17728 }
17729 }
17730
17731 // wait for non-interactive threads
17732
17733 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17734 {
17735 hc_thread_wait (1, &ni_threads[thread_idx]);
17736 }
17737
17738 local_free (ni_threads);
17739
17740 // wait for interactive threads
17741
17742 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17743 {
17744 hc_thread_wait (1, &i_thread);
17745 }
17746
17747 // we dont need restore file anymore
17748 if (data.restore_disable == 0)
17749 {
17750 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17751 {
17752 unlink (eff_restore_file);
17753 unlink (new_restore_file);
17754 }
17755 else
17756 {
17757 cycle_restore ();
17758 }
17759 }
17760
17761 // finally save left hashes
17762
17763 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17764 {
17765 save_hash ();
17766 }
17767
17768 /**
17769 * Clean up
17770 */
17771
17772 if (benchmark == 1)
17773 {
17774 status_benchmark ();
17775
17776 if (machine_readable == 0)
17777 {
17778 log_info ("");
17779 }
17780 }
17781 else
17782 {
17783 if (quiet == 0) clear_prompt ();
17784
17785 if (quiet == 0) log_info ("");
17786
17787 if (status == 1)
17788 {
17789 status_display ();
17790 }
17791 else
17792 {
17793 if (quiet == 0) status_display ();
17794 }
17795
17796 if (quiet == 0) log_info ("");
17797 }
17798
17799 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17800 {
17801 hc_device_param_t *device_param = &data.devices_param[device_id];
17802
17803 if (device_param->skipped) continue;
17804
17805 local_free (device_param->combs_buf);
17806
17807 local_free (device_param->hooks_buf);
17808
17809 local_free (device_param->device_name);
17810
17811 local_free (device_param->device_name_chksum);
17812
17813 local_free (device_param->device_version);
17814
17815 local_free (device_param->driver_version);
17816
17817 if (device_param->pws_buf) myfree (device_param->pws_buf);
17818 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17819 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17820 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17821 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17822 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17823 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17824 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17825 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17826 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17827 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17828 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17829 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17830 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17831 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17832 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17833 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17834 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17835 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17836 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17837 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17838 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17839 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17840 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17841 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17842 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17843 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17844 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17845 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17846
17847 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17848 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17849 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17850 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17851 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17852 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17853 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17854 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17855 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17856 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17857 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17858
17859 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17860 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17861 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17862
17863 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17864 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17865 }
17866
17867 // reset default fan speed
17868
17869 #ifdef HAVE_HWMON
17870 if (gpu_temp_disable == 0)
17871 {
17872 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17873 {
17874 hc_thread_mutex_lock (mux_adl);
17875
17876 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17877 {
17878 hc_device_param_t *device_param = &data.devices_param[device_id];
17879
17880 if (device_param->skipped) continue;
17881
17882 if (data.hm_device[device_id].fan_set_supported == 1)
17883 {
17884 int fanspeed = temp_retain_fanspeed_value[device_id];
17885 int fanpolicy = temp_retain_fanpolicy_value[device_id];
17886
17887 if (fanpolicy == 1)
17888 {
17889 int rc = -1;
17890
17891 if (device_param->device_vendor_id == VENDOR_ID_AMD)
17892 {
17893 rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed, 0);
17894 }
17895 else if (device_param->device_vendor_id == VENDOR_ID_NV)
17896 {
17897
17898 }
17899
17900 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
17901 }
17902 }
17903 }
17904
17905 hc_thread_mutex_unlock (mux_adl);
17906 }
17907 }
17908
17909 // reset power tuning
17910
17911 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17912 {
17913 hc_thread_mutex_lock (mux_adl);
17914
17915 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17916 {
17917 hc_device_param_t *device_param = &data.devices_param[device_id];
17918
17919 if (device_param->skipped) continue;
17920
17921 if (data.hm_device[device_id].od_version == 6)
17922 {
17923 // check powertune capabilities first, if not available then skip device
17924
17925 int powertune_supported = 0;
17926
17927 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17928 {
17929 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17930
17931 return (-1);
17932 }
17933
17934 if (powertune_supported != 0)
17935 {
17936 // powercontrol settings
17937
17938 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)
17939 {
17940 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17941
17942 return (-1);
17943 }
17944
17945 // clocks
17946
17947 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17948
17949 performance_state->iNumberOfPerformanceLevels = 2;
17950
17951 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17952 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17953 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17954 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17955
17956 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)
17957 {
17958 log_info ("ERROR: Failed to restore ADL performance state");
17959
17960 return (-1);
17961 }
17962
17963 local_free (performance_state);
17964 }
17965 }
17966 }
17967
17968 hc_thread_mutex_unlock (mux_adl);
17969 }
17970
17971 if (gpu_temp_disable == 0)
17972 {
17973 if (data.hm_nv)
17974 {
17975 hm_NVML_nvmlShutdown (data.hm_nv);
17976
17977 nvml_close (data.hm_nv);
17978
17979 data.hm_nv = NULL;
17980 }
17981
17982 if (data.hm_amd)
17983 {
17984 hm_ADL_Main_Control_Destroy (data.hm_amd);
17985
17986 adl_close (data.hm_amd);
17987
17988 data.hm_amd = NULL;
17989 }
17990 }
17991 #endif // HAVE_HWMON
17992
17993 // free memory
17994
17995 local_free (masks);
17996
17997 local_free (dictstat_base);
17998
17999 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18000 {
18001 pot_t *pot_ptr = &pot[pot_pos];
18002
18003 hash_t *hash = &pot_ptr->hash;
18004
18005 local_free (hash->digest);
18006
18007 if (isSalted)
18008 {
18009 local_free (hash->salt);
18010 }
18011 }
18012
18013 local_free (pot);
18014
18015 local_free (all_kernel_rules_cnt);
18016 local_free (all_kernel_rules_buf);
18017
18018 local_free (wl_data->buf);
18019 local_free (wl_data);
18020
18021 local_free (bitmap_s1_a);
18022 local_free (bitmap_s1_b);
18023 local_free (bitmap_s1_c);
18024 local_free (bitmap_s1_d);
18025 local_free (bitmap_s2_a);
18026 local_free (bitmap_s2_b);
18027 local_free (bitmap_s2_c);
18028 local_free (bitmap_s2_d);
18029
18030 #ifdef HAVE_HWMON
18031 local_free (temp_retain_fanspeed_value);
18032 local_free (od_clock_mem_status);
18033 local_free (od_power_control_status);
18034 #endif
18035
18036 global_free (devices_param);
18037
18038 global_free (kernel_rules_buf);
18039
18040 global_free (root_css_buf);
18041 global_free (markov_css_buf);
18042
18043 global_free (digests_buf);
18044 global_free (digests_shown);
18045 global_free (digests_shown_tmp);
18046
18047 global_free (salts_buf);
18048 global_free (salts_shown);
18049
18050 global_free (esalts_buf);
18051
18052 global_free (words_progress_done);
18053 global_free (words_progress_rejected);
18054 global_free (words_progress_restored);
18055
18056 if (pot_fp) fclose (pot_fp);
18057
18058 if (data.devices_status == STATUS_QUIT) break;
18059 }
18060
18061 // destroy others mutex
18062
18063 hc_thread_mutex_delete (mux_dispatcher);
18064 hc_thread_mutex_delete (mux_counter);
18065 hc_thread_mutex_delete (mux_display);
18066 hc_thread_mutex_delete (mux_adl);
18067
18068 // free memory
18069
18070 local_free (eff_restore_file);
18071 local_free (new_restore_file);
18072
18073 local_free (rd);
18074
18075 // tuning db
18076
18077 tuning_db_destroy (tuning_db);
18078
18079 // loopback
18080
18081 local_free (loopback_file);
18082
18083 if (loopback == 1) unlink (loopback_file);
18084
18085 // induction directory
18086
18087 if (induction_dir == NULL)
18088 {
18089 if (attack_mode != ATTACK_MODE_BF)
18090 {
18091 if (rmdir (induction_directory) == -1)
18092 {
18093 if (errno == ENOENT)
18094 {
18095 // good, we can ignore
18096 }
18097 else if (errno == ENOTEMPTY)
18098 {
18099 // good, we can ignore
18100 }
18101 else
18102 {
18103 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18104
18105 return (-1);
18106 }
18107 }
18108
18109 local_free (induction_directory);
18110 }
18111 }
18112
18113 // outfile-check directory
18114
18115 if (outfile_check_dir == NULL)
18116 {
18117 if (rmdir (outfile_check_directory) == -1)
18118 {
18119 if (errno == ENOENT)
18120 {
18121 // good, we can ignore
18122 }
18123 else if (errno == ENOTEMPTY)
18124 {
18125 // good, we can ignore
18126 }
18127 else
18128 {
18129 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18130
18131 return (-1);
18132 }
18133 }
18134
18135 local_free (outfile_check_directory);
18136 }
18137
18138 time_t proc_stop;
18139
18140 time (&proc_stop);
18141
18142 logfile_top_uint (proc_start);
18143 logfile_top_uint (proc_stop);
18144
18145 logfile_top_msg ("STOP");
18146
18147 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18148 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18149
18150 if (data.ocl) ocl_close (data.ocl);
18151
18152 if (data.devices_status == STATUS_ABORTED) return 2;
18153 if (data.devices_status == STATUS_QUIT) return 2;
18154 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18155 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18156 if (data.devices_status == STATUS_CRACKED) return 0;
18157
18158 return -1;
18159 }
Hashcat additions to support pwdhash