projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Added support for --gpu-temp-retain for nvidia devices on windows
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define MACHINE_READABLE 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 0
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 13711,
283 13721,
284 13731,
285 13741,
286 13751,
287 13761,
288 8800,
289 12900,
290 12200,
291 9700,
292 9710,
293 9800,
294 9810,
295 9400,
296 9500,
297 9600,
298 10400,
299 10410,
300 10500,
301 10600,
302 10700,
303 9000,
304 5200,
305 6800,
306 6600,
307 8200,
308 11300,
309 12700,
310 13400,
311 125
312 };
313
314 /**
315 * types
316 */
317
318 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
319
320 /**
321 * globals
322 */
323
324 static unsigned int full01 = 0x01010101;
325 static unsigned int full80 = 0x80808080;
326
327 int SUPPRESS_OUTPUT = 0;
328
329 hc_thread_mutex_t mux_adl;
330 hc_thread_mutex_t mux_counter;
331 hc_thread_mutex_t mux_dispatcher;
332 hc_thread_mutex_t mux_display;
333
334 hc_global_data_t data;
335
336 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
337
338 const char *USAGE_MINI[] =
339 {
340 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
341 "",
342 "Try --help for more help.",
343 NULL
344 };
345
346 const char *USAGE_BIG[] =
347 {
348 "%s, advanced password recovery",
349 "",
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "- [ Options ] -",
353 "",
354 " Options Short / Long | Type | Description | Example",
355 "===============================|======|======================================================|=======================",
356 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
357 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
358 " -V, --version | | Print version |",
359 " -h, --help | | Print help |",
360 " --quiet | | Suppress output |",
361 " --hex-charset | | Assume charset is given in hex |",
362 " --hex-salt | | Assume salt is given in hex |",
363 " --hex-wordlist | | Assume words in wordlist is given in hex |",
364 " --force | | Ignore warnings |",
365 " --status | | Enable automatic update of the status-screen |",
366 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
367 " --machine-readable | | Display the status view in a machine readable format |",
368 " --loopback | | Add new plains to induct directory |",
369 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
370 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
371 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
372 " --markov-classic | | Enables classic markov-chains, no per-position |",
373 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
374 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
375 " --session | Str | Define specific session name | --session=mysession",
376 " --restore | | Restore session from --session |",
377 " --restore-disable | | Do not write restore file |",
378 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
379 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
380 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
381 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
382 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
383 " --show | | Show cracked passwords only |",
384 " --left | | Show un-cracked passwords only |",
385 " --username | | Enable ignoring of usernames in hashfile |",
386 " --remove | | Enable remove of hash once it is cracked |",
387 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
388 " --potfile-disable | | Do not write potfile |",
389 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
390 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
391 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
392 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
393 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
394 " --logfile-disable | | Disable the logfile |",
395 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
396 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
397 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
398 " -b, --benchmark | | Run benchmark |",
399 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
400 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
401 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
402 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
403 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
404 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
405 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
406 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
407 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
408 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
409 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
410 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
411 #ifdef HAVE_HWMON
412 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
413 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
414 " --powertune-enable | | Enable automatic power tuning (AMD OverDrive 6 only) |",
415 #endif
416 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
417 " -s, --skip | Num | Skip X words from the start | -s 1000000",
418 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
419 " --keyspace | | Show keyspace base:mod values and quit |",
420 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
421 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
422 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
423 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
424 " --generate-rules-func-min | Num | Force min X funcs per rule |",
425 " --generate-rules-func-max | Num | Force max X funcs per rule |",
426 " --generate-rules-seed | Num | Force RNG seed set to X |",
427 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
428 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
429 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
430 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
431 " -i, --increment | | Enable mask increment mode |",
432 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
433 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
434 "",
435 "- [ Hash modes ] -",
436 "",
437 " # | Name | Category",
438 " ======+==================================================+======================================",
439 " 900 | MD4 | Raw Hash",
440 " 0 | MD5 | Raw Hash",
441 " 5100 | Half MD5 | Raw Hash",
442 " 100 | SHA1 | Raw Hash",
443 " 10800 | SHA-384 | Raw Hash",
444 " 1400 | SHA-256 | Raw Hash",
445 " 1700 | SHA-512 | Raw Hash",
446 " 5000 | SHA-3(Keccak) | Raw Hash",
447 " 10100 | SipHash | Raw Hash",
448 " 6000 | RipeMD160 | Raw Hash",
449 " 6100 | Whirlpool | Raw Hash",
450 " 6900 | GOST R 34.11-94 | Raw Hash",
451 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
452 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
453 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
454 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
455 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
456 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
457 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
458 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
459 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
460 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
461 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
462 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
463 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
464 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
465 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
466 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
467 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
468 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
469 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
470 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
471 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
472 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
473 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
474 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
475 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
476 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
477 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
478 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
479 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
480 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
481 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
482 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
483 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
484 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
485 " 400 | phpass | Generic KDF",
486 " 8900 | scrypt | Generic KDF",
487 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
488 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
489 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
490 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
491 " 23 | Skype | Network protocols",
492 " 2500 | WPA/WPA2 | Network protocols",
493 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
494 " 5300 | IKE-PSK MD5 | Network protocols",
495 " 5400 | IKE-PSK SHA1 | Network protocols",
496 " 5500 | NetNTLMv1 | Network protocols",
497 " 5500 | NetNTLMv1 + ESS | Network protocols",
498 " 5600 | NetNTLMv2 | Network protocols",
499 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
500 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
501 " 8300 | DNSSEC (NSEC3) | Network protocols",
502 " 10200 | Cram MD5 | Network protocols",
503 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
504 " 11200 | MySQL CRAM (SHA1) | Network protocols",
505 " 11400 | SIP digest authentication (MD5) | Network protocols",
506 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
507 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
508 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
509 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
510 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
511 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
512 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
513 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
514 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
515 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
516 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
517 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
518 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
519 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
520 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
521 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
522 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
523 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
524 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
525 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
526 " 12 | PostgreSQL | Database Server",
527 " 131 | MSSQL(2000) | Database Server",
528 " 132 | MSSQL(2005) | Database Server",
529 " 1731 | MSSQL(2012) | Database Server",
530 " 1731 | MSSQL(2014) | Database Server",
531 " 200 | MySQL323 | Database Server",
532 " 300 | MySQL4.1/MySQL5 | Database Server",
533 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
534 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
535 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
536 " 8000 | Sybase ASE | Database Server",
537 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
538 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
539 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
540 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
541 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
542 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
543 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
544 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
545 " 11500 | CRC32 | Checksums",
546 " 3000 | LM | Operating-Systems",
547 " 1000 | NTLM | Operating-Systems",
548 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
549 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
550 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
551 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
552 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
553 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
554 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
555 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
556 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
557 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
558 " 1722 | OSX v10.7 | Operating-Systems",
559 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
560 " 6300 | AIX {smd5} | Operating-Systems",
561 " 6700 | AIX {ssha1} | Operating-Systems",
562 " 6400 | AIX {ssha256} | Operating-Systems",
563 " 6500 | AIX {ssha512} | Operating-Systems",
564 " 2400 | Cisco-PIX | Operating-Systems",
565 " 2410 | Cisco-ASA | Operating-Systems",
566 " 500 | Cisco-IOS $1$ | Operating-Systems",
567 " 5700 | Cisco-IOS $4$ | Operating-Systems",
568 " 9200 | Cisco-IOS $8$ | Operating-Systems",
569 " 9300 | Cisco-IOS $9$ | Operating-Systems",
570 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
571 " 501 | Juniper IVE | Operating-Systems",
572 " 5800 | Android PIN | Operating-Systems",
573 " 8100 | Citrix Netscaler | Operating-Systems",
574 " 8500 | RACF | Operating-Systems",
575 " 7200 | GRUB 2 | Operating-Systems",
576 " 9900 | Radmin2 | Operating-Systems",
577 " 125 | ArubaOS | Operating-Systems",
578 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
579 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
580 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
581 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
582 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
583 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
584 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
585 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
586 " 11600 | 7-Zip | Archives",
587 " 12500 | RAR3-hp | Archives",
588 " 13000 | RAR5 | Archives",
589 " 13200 | AxCrypt | Archives",
590 " 13300 | AxCrypt in memory SHA1 | Archives",
591 " 13600 | WinZip | Archives",
592 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
593 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
594 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
595 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
596 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
597 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
598 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
599 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
600 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
601 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
602 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
603 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
604 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
605 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
606 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
607 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
608 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
609 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
610 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
611 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
612 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
613 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
614 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
615 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
616 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
617 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
618 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
619 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
620 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
621 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
622 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
623 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
624 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
625 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
626 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
627 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
628 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
629 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
630 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
631 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
632 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
633 " 9400 | MS Office 2007 | Documents",
634 " 9500 | MS Office 2010 | Documents",
635 " 9600 | MS Office 2013 | Documents",
636 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
637 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
638 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
639 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
640 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
641 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
642 " 9000 | Password Safe v2 | Password Managers",
643 " 5200 | Password Safe v3 | Password Managers",
644 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
645 " 6600 | 1Password, agilekeychain | Password Managers",
646 " 8200 | 1Password, cloudkeychain | Password Managers",
647 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
648 " 12700 | Blockchain, My Wallet | Password Managers",
649 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
650 "",
651 "- [ Outfile Formats ] -",
652 "",
653 " # | Format",
654 " ===+========",
655 " 1 | hash[:salt]",
656 " 2 | plain",
657 " 3 | hash[:salt]:plain",
658 " 4 | hex_plain",
659 " 5 | hash[:salt]:hex_plain",
660 " 6 | plain:hex_plain",
661 " 7 | hash[:salt]:plain:hex_plain",
662 " 8 | crackpos",
663 " 9 | hash[:salt]:crack_pos",
664 " 10 | plain:crack_pos",
665 " 11 | hash[:salt]:plain:crack_pos",
666 " 12 | hex_plain:crack_pos",
667 " 13 | hash[:salt]:hex_plain:crack_pos",
668 " 14 | plain:hex_plain:crack_pos",
669 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
670 "",
671 "- [ Rule Debugging Modes ] -",
672 "",
673 " # | Format",
674 " ===+========",
675 " 1 | Finding-Rule",
676 " 2 | Original-Word",
677 " 3 | Original-Word:Finding-Rule",
678 " 4 | Original-Word:Finding-Rule:Processed-Word",
679 "",
680 "- [ Attack Modes ] -",
681 "",
682 " # | Mode",
683 " ===+======",
684 " 0 | Straight",
685 " 1 | Combination",
686 " 3 | Brute-force",
687 " 6 | Hybrid Wordlist + Mask",
688 " 7 | Hybrid Mask + Wordlist",
689 "",
690 "- [ Built-in Charsets ] -",
691 "",
692 " ? | Charset",
693 " ===+=========",
694 " l | abcdefghijklmnopqrstuvwxyz",
695 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
696 " d | 0123456789",
697 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
698 " a | ?l?u?d?s",
699 " b | 0x00 - 0xff",
700 "",
701 "- [ OpenCL Device Types ] -",
702 "",
703 " # | Device Type",
704 " ===+=============",
705 " 1 | CPU",
706 " 2 | GPU",
707 " 3 | FPGA, DSP, Co-Processor",
708 "",
709 "- [ Workload Profiles ] -",
710 "",
711 " # | Performance | Runtime | Power Consumption | Desktop Impact",
712 " ===+=============+=========+===================+=================",
713 " 1 | Low | 2 ms | Low | Minimal",
714 " 2 | Default | 12 ms | Economic | Noticeable",
715 " 3 | High | 96 ms | High | Unresponsive",
716 " 4 | Nightmare | 480 ms | Insane | Headless",
717 "",
718 "If you have no idea what just happened then visit the following pages:",
719 "",
720 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
721 "* https://hashcat.net/wiki/#frequently_asked_questions",
722 "",
723 NULL
724 };
725
726 /**
727 * hashcat specific functions
728 */
729
730 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
731 {
732 int exec_pos = (int) device_param->exec_pos - last_num_entries;
733
734 if (exec_pos < 0) exec_pos += EXEC_CACHE;
735
736 double exec_ms_sum = 0;
737
738 int exec_ms_cnt = 0;
739
740 for (int i = 0; i < last_num_entries; i++)
741 {
742 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
743
744 if (exec_ms)
745 {
746 exec_ms_sum += exec_ms;
747
748 exec_ms_cnt++;
749 }
750 }
751
752 if (exec_ms_cnt == 0) return 0;
753
754 return exec_ms_sum / exec_ms_cnt;
755 }
756
757 void status_display_machine_readable ()
758 {
759 FILE *out = stdout;
760
761 fprintf (out, "STATUS\t%u\t", data.devices_status);
762
763 /**
764 * speed new
765 */
766
767 fprintf (out, "SPEED\t");
768
769 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
770 {
771 hc_device_param_t *device_param = &data.devices_param[device_id];
772
773 if (device_param->skipped) continue;
774
775 u64 speed_cnt = 0;
776 double speed_ms = 0;
777
778 for (int i = 0; i < SPEED_CACHE; i++)
779 {
780 speed_cnt += device_param->speed_cnt[i];
781 speed_ms += device_param->speed_ms[i];
782 }
783
784 speed_cnt /= SPEED_CACHE;
785 speed_ms /= SPEED_CACHE;
786
787 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
788 }
789
790 /**
791 * exec time
792 */
793
794 fprintf (out, "EXEC_RUNTIME\t");
795
796 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
797 {
798 hc_device_param_t *device_param = &data.devices_param[device_id];
799
800 if (device_param->skipped) continue;
801
802 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
803
804 fprintf (out, "%f\t", exec_ms_avg);
805 }
806
807 /**
808 * words_cur
809 */
810
811 u64 words_cur = get_lowest_words_done ();
812
813 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
814
815 /**
816 * counter
817 */
818
819 u64 progress_total = data.words_cnt * data.salts_cnt;
820
821 u64 all_done = 0;
822 u64 all_rejected = 0;
823 u64 all_restored = 0;
824
825 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
826 {
827 all_done += data.words_progress_done[salt_pos];
828 all_rejected += data.words_progress_rejected[salt_pos];
829 all_restored += data.words_progress_restored[salt_pos];
830 }
831
832 u64 progress_cur = all_restored + all_done + all_rejected;
833 u64 progress_end = progress_total;
834
835 u64 progress_skip = 0;
836
837 if (data.skip)
838 {
839 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
840
841 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
842 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
843 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
844 }
845
846 if (data.limit)
847 {
848 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
849
850 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
851 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
852 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
853 }
854
855 u64 progress_cur_relative_skip = progress_cur - progress_skip;
856 u64 progress_end_relative_skip = progress_end - progress_skip;
857
858 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
859
860 /**
861 * cracks
862 */
863
864 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
865 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
866
867 /**
868 * temperature
869 */
870
871 #ifdef HAVE_HWMON
872 if (data.gpu_temp_disable == 0)
873 {
874 fprintf (out, "TEMP\t");
875
876 hc_thread_mutex_lock (mux_adl);
877
878 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
879 {
880 hc_device_param_t *device_param = &data.devices_param[device_id];
881
882 if (device_param->skipped) continue;
883
884 int temp = hm_get_temperature_with_device_id (device_id);
885
886 fprintf (out, "%d\t", temp);
887 }
888
889 hc_thread_mutex_unlock (mux_adl);
890 }
891 #endif // HAVE_HWMON
892
893 /**
894 * flush
895 */
896
897 #ifdef _WIN
898 fputc ('\r', out);
899 fputc ('\n', out);
900 #endif
901
902 #ifdef _POSIX
903 fputc ('\n', out);
904 #endif
905
906 fflush (out);
907 }
908
909 void status_display ()
910 {
911 if (data.devices_status == STATUS_INIT) return;
912 if (data.devices_status == STATUS_STARTING) return;
913 if (data.devices_status == STATUS_BYPASS) return;
914
915 if (data.machine_readable == 1)
916 {
917 status_display_machine_readable ();
918
919 return;
920 }
921
922 char tmp_buf[1000] = { 0 };
923
924 uint tmp_len = 0;
925
926 log_info ("Session.Name...: %s", data.session);
927
928 char *status_type = strstatus (data.devices_status);
929
930 uint hash_mode = data.hash_mode;
931
932 char *hash_type = strhashtype (hash_mode); // not a bug
933
934 log_info ("Status.........: %s", status_type);
935
936 /**
937 * show rules
938 */
939
940 if (data.rp_files_cnt)
941 {
942 uint i;
943
944 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
945 {
946 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
947 }
948
949 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
950
951 log_info ("Rules.Type.....: %s", tmp_buf);
952
953 tmp_len = 0;
954 }
955
956 if (data.rp_gen)
957 {
958 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
959
960 if (data.rp_gen_seed)
961 {
962 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
963 }
964 }
965
966 /**
967 * show input
968 */
969
970 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
971 {
972 if (data.wordlist_mode == WL_MODE_FILE)
973 {
974 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
975 }
976 else if (data.wordlist_mode == WL_MODE_STDIN)
977 {
978 log_info ("Input.Mode.....: Pipe");
979 }
980 }
981 else if (data.attack_mode == ATTACK_MODE_COMBI)
982 {
983 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
984 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
985 }
986 else if (data.attack_mode == ATTACK_MODE_BF)
987 {
988 char *mask = data.mask;
989
990 if (mask != NULL)
991 {
992 uint mask_len = data.css_cnt;
993
994 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
995
996 if (mask_len > 0)
997 {
998 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
999 {
1000 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1001 {
1002 mask_len -= data.salts_buf[0].salt_len;
1003 }
1004 }
1005
1006 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1007
1008 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1009 }
1010
1011 if (data.maskcnt > 1)
1012 {
1013 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1014
1015 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1016 }
1017
1018 log_info ("Input.Mode.....: %s", tmp_buf);
1019 }
1020
1021 tmp_len = 0;
1022 }
1023 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1024 {
1025 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1026 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1027 }
1028 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1029 {
1030 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1031 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1032 }
1033
1034 if (data.digests_cnt == 1)
1035 {
1036 if (data.hash_mode == 2500)
1037 {
1038 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1039
1040 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1041 (char *) data.salts_buf[0].salt_buf,
1042 wpa->orig_mac1[0],
1043 wpa->orig_mac1[1],
1044 wpa->orig_mac1[2],
1045 wpa->orig_mac1[3],
1046 wpa->orig_mac1[4],
1047 wpa->orig_mac1[5],
1048 wpa->orig_mac2[0],
1049 wpa->orig_mac2[1],
1050 wpa->orig_mac2[2],
1051 wpa->orig_mac2[3],
1052 wpa->orig_mac2[4],
1053 wpa->orig_mac2[5]);
1054 }
1055 else if (data.hash_mode == 5200)
1056 {
1057 log_info ("Hash.Target....: File (%s)", data.hashfile);
1058 }
1059 else if (data.hash_mode == 9000)
1060 {
1061 log_info ("Hash.Target....: File (%s)", data.hashfile);
1062 }
1063 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1064 {
1065 log_info ("Hash.Target....: File (%s)", data.hashfile);
1066 }
1067 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1068 {
1069 log_info ("Hash.Target....: File (%s)", data.hashfile);
1070 }
1071 else
1072 {
1073 char out_buf[HCBUFSIZ] = { 0 };
1074
1075 ascii_digest (out_buf, 0, 0);
1076
1077 // limit length
1078 if (strlen (out_buf) > 40)
1079 {
1080 out_buf[41] = '.';
1081 out_buf[42] = '.';
1082 out_buf[43] = '.';
1083 out_buf[44] = 0;
1084 }
1085
1086 log_info ("Hash.Target....: %s", out_buf);
1087 }
1088 }
1089 else
1090 {
1091 if (data.hash_mode == 3000)
1092 {
1093 char out_buf1[32] = { 0 };
1094 char out_buf2[32] = { 0 };
1095
1096 ascii_digest (out_buf1, 0, 0);
1097 ascii_digest (out_buf2, 0, 1);
1098
1099 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1100 }
1101 else
1102 {
1103 log_info ("Hash.Target....: File (%s)", data.hashfile);
1104 }
1105 }
1106
1107 log_info ("Hash.Type......: %s", hash_type);
1108
1109 /**
1110 * speed new
1111 */
1112
1113 u64 speed_cnt[DEVICES_MAX] = { 0 };
1114 double speed_ms[DEVICES_MAX] = { 0 };
1115
1116 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1117 {
1118 hc_device_param_t *device_param = &data.devices_param[device_id];
1119
1120 if (device_param->skipped) continue;
1121
1122 speed_cnt[device_id] = 0;
1123 speed_ms[device_id] = 0;
1124
1125 for (int i = 0; i < SPEED_CACHE; i++)
1126 {
1127 speed_cnt[device_id] += device_param->speed_cnt[i];
1128 speed_ms[device_id] += device_param->speed_ms[i];
1129 }
1130
1131 speed_cnt[device_id] /= SPEED_CACHE;
1132 speed_ms[device_id] /= SPEED_CACHE;
1133 }
1134
1135 double hashes_all_ms = 0;
1136
1137 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1138
1139 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1140 {
1141 hc_device_param_t *device_param = &data.devices_param[device_id];
1142
1143 if (device_param->skipped) continue;
1144
1145 hashes_dev_ms[device_id] = 0;
1146
1147 if (speed_ms[device_id])
1148 {
1149 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1150
1151 hashes_all_ms += hashes_dev_ms[device_id];
1152 }
1153 }
1154
1155 /**
1156 * exec time
1157 */
1158
1159 double exec_all_ms[DEVICES_MAX] = { 0 };
1160
1161 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1162 {
1163 hc_device_param_t *device_param = &data.devices_param[device_id];
1164
1165 if (device_param->skipped) continue;
1166
1167 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1168
1169 exec_all_ms[device_id] = exec_ms_avg;
1170 }
1171
1172 /**
1173 * timers
1174 */
1175
1176 double ms_running = 0;
1177
1178 hc_timer_get (data.timer_running, ms_running);
1179
1180 double ms_paused = data.ms_paused;
1181
1182 if (data.devices_status == STATUS_PAUSED)
1183 {
1184 double ms_paused_tmp = 0;
1185
1186 hc_timer_get (data.timer_paused, ms_paused_tmp);
1187
1188 ms_paused += ms_paused_tmp;
1189 }
1190
1191 #ifdef WIN
1192
1193 __time64_t sec_run = ms_running / 1000;
1194
1195 #else
1196
1197 time_t sec_run = ms_running / 1000;
1198
1199 #endif
1200
1201 if (sec_run)
1202 {
1203 char display_run[32] = { 0 };
1204
1205 struct tm tm_run;
1206
1207 struct tm *tmp = NULL;
1208
1209 #ifdef WIN
1210
1211 tmp = _gmtime64 (&sec_run);
1212
1213 #else
1214
1215 tmp = gmtime (&sec_run);
1216
1217 #endif
1218
1219 if (tmp != NULL)
1220 {
1221 memset (&tm_run, 0, sizeof (tm_run));
1222
1223 memcpy (&tm_run, tmp, sizeof (tm_run));
1224
1225 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1226
1227 char *start = ctime (&data.proc_start);
1228
1229 size_t start_len = strlen (start);
1230
1231 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1232 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1233
1234 log_info ("Time.Started...: %s (%s)", start, display_run);
1235 }
1236 }
1237 else
1238 {
1239 log_info ("Time.Started...: 0 secs");
1240 }
1241
1242 /**
1243 * counters
1244 */
1245
1246 u64 progress_total = data.words_cnt * data.salts_cnt;
1247
1248 u64 all_done = 0;
1249 u64 all_rejected = 0;
1250 u64 all_restored = 0;
1251
1252 u64 progress_noneed = 0;
1253
1254 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1255 {
1256 all_done += data.words_progress_done[salt_pos];
1257 all_rejected += data.words_progress_rejected[salt_pos];
1258 all_restored += data.words_progress_restored[salt_pos];
1259
1260 // Important for ETA only
1261
1262 if (data.salts_shown[salt_pos] == 1)
1263 {
1264 const u64 all = data.words_progress_done[salt_pos]
1265 + data.words_progress_rejected[salt_pos]
1266 + data.words_progress_restored[salt_pos];
1267
1268 const u64 left = data.words_cnt - all;
1269
1270 progress_noneed += left;
1271 }
1272 }
1273
1274 u64 progress_cur = all_restored + all_done + all_rejected;
1275 u64 progress_end = progress_total;
1276
1277 u64 progress_skip = 0;
1278
1279 if (data.skip)
1280 {
1281 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1282
1283 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1284 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1285 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1286 }
1287
1288 if (data.limit)
1289 {
1290 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1291
1292 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1293 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1294 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1295 }
1296
1297 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1298 u64 progress_end_relative_skip = progress_end - progress_skip;
1299
1300 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1301 {
1302 if (data.devices_status != STATUS_CRACKED)
1303 {
1304 #ifdef WIN
1305 __time64_t sec_etc = 0;
1306 #else
1307 time_t sec_etc = 0;
1308 #endif
1309
1310 if (hashes_all_ms)
1311 {
1312 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1313
1314 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1315
1316 sec_etc = ms_left / 1000;
1317 }
1318
1319 if (sec_etc == 0)
1320 {
1321 //log_info ("Time.Estimated.: 0 secs");
1322 }
1323 else if ((u64) sec_etc > ETC_MAX)
1324 {
1325 log_info ("Time.Estimated.: > 10 Years");
1326 }
1327 else
1328 {
1329 char display_etc[32] = { 0 };
1330
1331 struct tm tm_etc;
1332
1333 struct tm *tmp = NULL;
1334
1335 #ifdef WIN
1336
1337 tmp = _gmtime64 (&sec_etc);
1338
1339 #else
1340
1341 tmp = gmtime (&sec_etc);
1342
1343 #endif
1344
1345 if (tmp != NULL)
1346 {
1347 memset (&tm_etc, 0, sizeof (tm_etc));
1348
1349 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1350
1351 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1352
1353 time_t now;
1354
1355 time (&now);
1356
1357 now += sec_etc;
1358
1359 char *etc = ctime (&now);
1360
1361 size_t etc_len = strlen (etc);
1362
1363 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1364 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1365
1366 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1367 }
1368 }
1369 }
1370 }
1371
1372 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1373 {
1374 hc_device_param_t *device_param = &data.devices_param[device_id];
1375
1376 if (device_param->skipped) continue;
1377
1378 char display_dev_cur[16] = { 0 };
1379
1380 strncpy (display_dev_cur, "0.00", 4);
1381
1382 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1383
1384 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1385 }
1386
1387 char display_all_cur[16] = { 0 };
1388
1389 strncpy (display_all_cur, "0.00", 4);
1390
1391 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1392
1393 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1394
1395 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1396 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1397
1398 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1399
1400 // crack-per-time
1401
1402 if (data.digests_cnt > 100)
1403 {
1404 time_t now = time (NULL);
1405
1406 int cpt_cur_min = 0;
1407 int cpt_cur_hour = 0;
1408 int cpt_cur_day = 0;
1409
1410 for (int i = 0; i < CPT_BUF; i++)
1411 {
1412 const uint cracked = data.cpt_buf[i].cracked;
1413 const time_t timestamp = data.cpt_buf[i].timestamp;
1414
1415 if ((timestamp + 60) > now)
1416 {
1417 cpt_cur_min += cracked;
1418 }
1419
1420 if ((timestamp + 3600) > now)
1421 {
1422 cpt_cur_hour += cracked;
1423 }
1424
1425 if ((timestamp + 86400) > now)
1426 {
1427 cpt_cur_day += cracked;
1428 }
1429 }
1430
1431 double ms_real = ms_running - ms_paused;
1432
1433 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1434 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1435 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1436
1437 if ((data.cpt_start + 86400) < now)
1438 {
1439 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1440 cpt_cur_min,
1441 cpt_cur_hour,
1442 cpt_cur_day,
1443 cpt_avg_min,
1444 cpt_avg_hour,
1445 cpt_avg_day);
1446 }
1447 else if ((data.cpt_start + 3600) < now)
1448 {
1449 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1450 cpt_cur_min,
1451 cpt_cur_hour,
1452 cpt_avg_min,
1453 cpt_avg_hour,
1454 cpt_avg_day);
1455 }
1456 else if ((data.cpt_start + 60) < now)
1457 {
1458 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1459 cpt_cur_min,
1460 cpt_avg_min,
1461 cpt_avg_hour,
1462 cpt_avg_day);
1463 }
1464 else
1465 {
1466 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1467 cpt_avg_min,
1468 cpt_avg_hour,
1469 cpt_avg_day);
1470 }
1471 }
1472
1473 // Restore point
1474
1475 u64 restore_point = get_lowest_words_done ();
1476
1477 u64 restore_total = data.words_base;
1478
1479 float percent_restore = 0;
1480
1481 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1482
1483 if (progress_end_relative_skip)
1484 {
1485 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1486 {
1487 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1488 float percent_rejected = 0.0;
1489
1490 if (progress_cur)
1491 {
1492 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1493 }
1494
1495 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1496 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1497
1498 if (data.restore_disable == 0)
1499 {
1500 if (percent_finished != 1)
1501 {
1502 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1503 }
1504 }
1505 }
1506 }
1507 else
1508 {
1509 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1510 {
1511 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1512 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1513
1514 if (data.restore_disable == 0)
1515 {
1516 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1517 }
1518 }
1519 else
1520 {
1521 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1522 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1523
1524 // --restore not allowed if stdin is used -- really? why?
1525
1526 //if (data.restore_disable == 0)
1527 //{
1528 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1529 //}
1530 }
1531 }
1532
1533 #ifdef HAVE_HWMON
1534 if (data.gpu_temp_disable == 0)
1535 {
1536 hc_thread_mutex_lock (mux_adl);
1537
1538 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1539 {
1540 hc_device_param_t *device_param = &data.devices_param[device_id];
1541
1542 if (device_param->skipped) continue;
1543
1544 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1545 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1546 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1547 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1548 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1549 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1550 // not working
1551 //const int num_throttle = hm_get_throttle_with_device_id (device_id);
1552
1553 char output_buf[256] = { 0 };
1554
1555 int output_len = 0;
1556
1557 if (num_temperature >= 0)
1558 {
1559 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1560
1561 output_len = strlen (output_buf);
1562 }
1563
1564 if (num_fanspeed >= 0)
1565 {
1566 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1567
1568 output_len = strlen (output_buf);
1569 }
1570
1571 if (num_utilization >= 0)
1572 {
1573 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1574
1575 output_len = strlen (output_buf);
1576 }
1577
1578 if (num_corespeed >= 0)
1579 {
1580 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1581
1582 output_len = strlen (output_buf);
1583 }
1584
1585 if (num_memoryspeed >= 0)
1586 {
1587 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1588
1589 output_len = strlen (output_buf);
1590 }
1591
1592 if (num_buslanes >= 0)
1593 {
1594 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1595
1596 output_len = strlen (output_buf);
1597 }
1598
1599 /*
1600 if (num_throttle >= 0)
1601 {
1602 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Throttle:%u", num_throttle);
1603
1604 output_len = strlen (output_buf);
1605 }
1606 */
1607
1608 if (output_len == 0)
1609 {
1610 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1611
1612 output_len = strlen (output_buf);
1613 }
1614
1615 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1616 }
1617
1618 hc_thread_mutex_unlock (mux_adl);
1619 }
1620 #endif // HAVE_HWMON
1621 }
1622
1623 static void status_benchmark_automate ()
1624 {
1625 u64 speed_cnt[DEVICES_MAX] = { 0 };
1626 double speed_ms[DEVICES_MAX] = { 0 };
1627
1628 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1629 {
1630 hc_device_param_t *device_param = &data.devices_param[device_id];
1631
1632 if (device_param->skipped) continue;
1633
1634 speed_cnt[device_id] = device_param->speed_cnt[0];
1635 speed_ms[device_id] = device_param->speed_ms[0];
1636 }
1637
1638 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1639
1640 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1641 {
1642 hc_device_param_t *device_param = &data.devices_param[device_id];
1643
1644 if (device_param->skipped) continue;
1645
1646 hashes_dev_ms[device_id] = 0;
1647
1648 if (speed_ms[device_id])
1649 {
1650 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1651 }
1652 }
1653
1654 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1655 {
1656 hc_device_param_t *device_param = &data.devices_param[device_id];
1657
1658 if (device_param->skipped) continue;
1659
1660 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1661 }
1662 }
1663
1664 static void status_benchmark ()
1665 {
1666 if (data.devices_status == STATUS_INIT) return;
1667 if (data.devices_status == STATUS_STARTING) return;
1668 if (data.devices_status == STATUS_BYPASS) return;
1669
1670 if (data.machine_readable == 1)
1671 {
1672 status_benchmark_automate ();
1673
1674 return;
1675 }
1676
1677 u64 speed_cnt[DEVICES_MAX] = { 0 };
1678 double speed_ms[DEVICES_MAX] = { 0 };
1679
1680 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1681 {
1682 hc_device_param_t *device_param = &data.devices_param[device_id];
1683
1684 if (device_param->skipped) continue;
1685
1686 speed_cnt[device_id] = device_param->speed_cnt[0];
1687 speed_ms[device_id] = device_param->speed_ms[0];
1688 }
1689
1690 double hashes_all_ms = 0;
1691
1692 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1693
1694 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1695 {
1696 hc_device_param_t *device_param = &data.devices_param[device_id];
1697
1698 if (device_param->skipped) continue;
1699
1700 hashes_dev_ms[device_id] = 0;
1701
1702 if (speed_ms[device_id])
1703 {
1704 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1705
1706 hashes_all_ms += hashes_dev_ms[device_id];
1707 }
1708 }
1709
1710 /**
1711 * exec time
1712 */
1713
1714 double exec_all_ms[DEVICES_MAX] = { 0 };
1715
1716 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1717 {
1718 hc_device_param_t *device_param = &data.devices_param[device_id];
1719
1720 if (device_param->skipped) continue;
1721
1722 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1723
1724 exec_all_ms[device_id] = exec_ms_avg;
1725 }
1726
1727 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1728 {
1729 hc_device_param_t *device_param = &data.devices_param[device_id];
1730
1731 if (device_param->skipped) continue;
1732
1733 char display_dev_cur[16] = { 0 };
1734
1735 strncpy (display_dev_cur, "0.00", 4);
1736
1737 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1738
1739 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1740 }
1741
1742 char display_all_cur[16] = { 0 };
1743
1744 strncpy (display_all_cur, "0.00", 4);
1745
1746 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1747
1748 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1749 }
1750
1751 /**
1752 * hashcat -only- functions
1753 */
1754
1755 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1756 {
1757 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1758 {
1759 if (attack_kern == ATTACK_KERN_STRAIGHT)
1760 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1761 else if (attack_kern == ATTACK_KERN_COMBI)
1762 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1763 else if (attack_kern == ATTACK_KERN_BF)
1764 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1765 }
1766 else
1767 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1768 }
1769
1770 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1771 {
1772 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1773 {
1774 if (attack_kern == ATTACK_KERN_STRAIGHT)
1775 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1776 else if (attack_kern == ATTACK_KERN_COMBI)
1777 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1778 else if (attack_kern == ATTACK_KERN_BF)
1779 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1780 }
1781 else
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1784 }
1785 }
1786
1787 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1788 {
1789 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1790 {
1791 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1792 }
1793 else
1794 {
1795 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1796 }
1797 }
1798
1799 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1800 {
1801 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1802 {
1803 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1804 }
1805 else
1806 {
1807 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1808 }
1809 }
1810
1811 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1812 {
1813 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1814 }
1815
1816 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1817 {
1818 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1819 }
1820
1821 static uint convert_from_hex (char *line_buf, const uint line_len)
1822 {
1823 if (line_len & 1) return (line_len); // not in hex
1824
1825 if (data.hex_wordlist == 1)
1826 {
1827 uint i;
1828 uint j;
1829
1830 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1831 {
1832 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1833 }
1834
1835 memset (line_buf + i, 0, line_len - i);
1836
1837 return (i);
1838 }
1839 else if (line_len >= 6) // $HEX[] = 6
1840 {
1841 if (line_buf[0] != '$') return (line_len);
1842 if (line_buf[1] != 'H') return (line_len);
1843 if (line_buf[2] != 'E') return (line_len);
1844 if (line_buf[3] != 'X') return (line_len);
1845 if (line_buf[4] != '[') return (line_len);
1846 if (line_buf[line_len - 1] != ']') return (line_len);
1847
1848 uint i;
1849 uint j;
1850
1851 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1852 {
1853 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1854 }
1855
1856 memset (line_buf + i, 0, line_len - i);
1857
1858 return (i);
1859 }
1860
1861 return (line_len);
1862 }
1863
1864 static void clear_prompt ()
1865 {
1866 fputc ('\r', stdout);
1867
1868 for (size_t i = 0; i < strlen (PROMPT); i++)
1869 {
1870 fputc (' ', stdout);
1871 }
1872
1873 fputc ('\r', stdout);
1874
1875 fflush (stdout);
1876 }
1877
1878 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1879 {
1880 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1881 }
1882
1883 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1884 {
1885 char *outfile = data.outfile;
1886 uint quiet = data.quiet;
1887 FILE *pot_fp = data.pot_fp;
1888 uint loopback = data.loopback;
1889 uint debug_mode = data.debug_mode;
1890 char *debug_file = data.debug_file;
1891
1892 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1893 int debug_rule_len = 0; // -1 error
1894 uint debug_plain_len = 0;
1895
1896 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1897
1898 // hash
1899
1900 char out_buf[HCBUFSIZ] = { 0 };
1901
1902 const u32 salt_pos = plain->salt_pos;
1903 const u32 digest_pos = plain->digest_pos; // relative
1904 const u32 gidvid = plain->gidvid;
1905 const u32 il_pos = plain->il_pos;
1906
1907 ascii_digest (out_buf, salt_pos, digest_pos);
1908
1909 // plain
1910
1911 u64 crackpos = device_param->words_off;
1912
1913 uint plain_buf[16] = { 0 };
1914
1915 u8 *plain_ptr = (u8 *) plain_buf;
1916
1917 unsigned int plain_len = 0;
1918
1919 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1920 {
1921 pw_t pw;
1922
1923 gidd_to_pw_t (device_param, gidvid, &pw);
1924
1925 for (int i = 0; i < 16; i++)
1926 {
1927 plain_buf[i] = pw.i[i];
1928 }
1929
1930 plain_len = pw.pw_len;
1931
1932 const uint off = device_param->innerloop_pos + il_pos;
1933
1934 if (debug_mode > 0)
1935 {
1936 debug_rule_len = 0;
1937
1938 // save rule
1939 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1940 {
1941 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1942
1943 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1944 }
1945
1946 // save plain
1947 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1948 {
1949 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1950
1951 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1952
1953 debug_plain_len = plain_len;
1954 }
1955 }
1956
1957 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1958
1959 crackpos += gidvid;
1960 crackpos *= data.kernel_rules_cnt;
1961 crackpos += device_param->innerloop_pos + il_pos;
1962
1963 if (plain_len > data.pw_max) plain_len = data.pw_max;
1964 }
1965 else if (data.attack_mode == ATTACK_MODE_COMBI)
1966 {
1967 pw_t pw;
1968
1969 gidd_to_pw_t (device_param, gidvid, &pw);
1970
1971 for (int i = 0; i < 16; i++)
1972 {
1973 plain_buf[i] = pw.i[i];
1974 }
1975
1976 plain_len = pw.pw_len;
1977
1978 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1979 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1980
1981 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1982 {
1983 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1984 }
1985 else
1986 {
1987 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1988
1989 memcpy (plain_ptr, comb_buf, comb_len);
1990 }
1991
1992 plain_len += comb_len;
1993
1994 crackpos += gidvid;
1995 crackpos *= data.combs_cnt;
1996 crackpos += device_param->innerloop_pos + il_pos;
1997
1998 if (data.pw_max != PW_DICTMAX1)
1999 {
2000 if (plain_len > data.pw_max) plain_len = data.pw_max;
2001 }
2002 }
2003 else if (data.attack_mode == ATTACK_MODE_BF)
2004 {
2005 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2006 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2007
2008 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2009 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2010
2011 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2012 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2013
2014 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2015 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2016
2017 plain_len = data.css_cnt;
2018
2019 crackpos += gidvid;
2020 crackpos *= data.bfs_cnt;
2021 crackpos += device_param->innerloop_pos + il_pos;
2022 }
2023 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2024 {
2025 pw_t pw;
2026
2027 gidd_to_pw_t (device_param, gidvid, &pw);
2028
2029 for (int i = 0; i < 16; i++)
2030 {
2031 plain_buf[i] = pw.i[i];
2032 }
2033
2034 plain_len = pw.pw_len;
2035
2036 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2037
2038 uint start = 0;
2039 uint stop = device_param->kernel_params_mp_buf32[4];
2040
2041 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2042
2043 plain_len += start + stop;
2044
2045 crackpos += gidvid;
2046 crackpos *= data.combs_cnt;
2047 crackpos += device_param->innerloop_pos + il_pos;
2048
2049 if (data.pw_max != PW_DICTMAX1)
2050 {
2051 if (plain_len > data.pw_max) plain_len = data.pw_max;
2052 }
2053 }
2054 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2055 {
2056 pw_t pw;
2057
2058 gidd_to_pw_t (device_param, gidvid, &pw);
2059
2060 for (int i = 0; i < 16; i++)
2061 {
2062 plain_buf[i] = pw.i[i];
2063 }
2064
2065 plain_len = pw.pw_len;
2066
2067 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2068
2069 uint start = 0;
2070 uint stop = device_param->kernel_params_mp_buf32[4];
2071
2072 memmove (plain_ptr + stop, plain_ptr, plain_len);
2073
2074 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2075
2076 plain_len += start + stop;
2077
2078 crackpos += gidvid;
2079 crackpos *= data.combs_cnt;
2080 crackpos += device_param->innerloop_pos + il_pos;
2081
2082 if (data.pw_max != PW_DICTMAX1)
2083 {
2084 if (plain_len > data.pw_max) plain_len = data.pw_max;
2085 }
2086 }
2087
2088 if (data.attack_mode == ATTACK_MODE_BF)
2089 {
2090 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2091 {
2092 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2093 {
2094 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2095 {
2096 plain_len = plain_len - data.salts_buf[0].salt_len;
2097 }
2098 }
2099
2100 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2101 {
2102 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2103 {
2104 plain_ptr[j] = plain_ptr[i];
2105 }
2106
2107 plain_len = plain_len / 2;
2108 }
2109 }
2110 }
2111
2112 // if enabled, update also the potfile
2113
2114 if (pot_fp)
2115 {
2116 lock_file (pot_fp);
2117
2118 fprintf (pot_fp, "%s:", out_buf);
2119
2120 format_plain (pot_fp, plain_ptr, plain_len, 1);
2121
2122 fputc ('\n', pot_fp);
2123
2124 fflush (pot_fp);
2125
2126 unlock_file (pot_fp);
2127 }
2128
2129 // outfile
2130
2131 FILE *out_fp = NULL;
2132
2133 if (outfile != NULL)
2134 {
2135 if ((out_fp = fopen (outfile, "ab")) == NULL)
2136 {
2137 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2138
2139 out_fp = stdout;
2140 }
2141
2142 lock_file (out_fp);
2143 }
2144 else
2145 {
2146 out_fp = stdout;
2147
2148 if (quiet == 0) clear_prompt ();
2149 }
2150
2151 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2152
2153 if (outfile != NULL)
2154 {
2155 if (out_fp != stdout)
2156 {
2157 fclose (out_fp);
2158 }
2159 }
2160 else
2161 {
2162 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2163 {
2164 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2165 {
2166 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2167 if (quiet == 0) fflush (stdout);
2168 }
2169 }
2170 }
2171
2172 // loopback
2173
2174 if (loopback)
2175 {
2176 char *loopback_file = data.loopback_file;
2177
2178 FILE *fb_fp = NULL;
2179
2180 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2181 {
2182 lock_file (fb_fp);
2183
2184 format_plain (fb_fp, plain_ptr, plain_len, 1);
2185
2186 fputc ('\n', fb_fp);
2187
2188 fclose (fb_fp);
2189 }
2190 }
2191
2192 // (rule) debug mode
2193
2194 // the next check implies that:
2195 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2196 // - debug_mode > 0
2197
2198 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2199 {
2200 if (debug_rule_len < 0) debug_rule_len = 0;
2201
2202 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2203
2204 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2205
2206 if ((quiet == 0) && (debug_file == NULL))
2207 {
2208 fprintf (stdout, "%s", PROMPT);
2209
2210 fflush (stdout);
2211 }
2212 }
2213 }
2214
2215 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2216 {
2217 salt_t *salt_buf = &data.salts_buf[salt_pos];
2218
2219 u32 num_cracked;
2220
2221 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2222
2223 if (num_cracked)
2224 {
2225 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2226
2227 log_info_nn ("");
2228
2229 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2230
2231 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, 0, num_cracked * sizeof (plain_t), cracked, 0, NULL, NULL);
2232
2233 uint cpt_cracked = 0;
2234
2235 for (uint i = 0; i < num_cracked; i++)
2236 {
2237 const uint hash_pos = cracked[i].hash_pos;
2238
2239 if (data.digests_shown[hash_pos] == 1) continue;
2240
2241 hc_thread_mutex_lock (mux_display);
2242
2243 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2244 {
2245 data.digests_shown[hash_pos] = 1;
2246
2247 data.digests_done++;
2248
2249 cpt_cracked++;
2250
2251 salt_buf->digests_done++;
2252
2253 if (salt_buf->digests_done == salt_buf->digests_cnt)
2254 {
2255 data.salts_shown[salt_pos] = 1;
2256
2257 data.salts_done++;
2258 }
2259 }
2260
2261 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2262
2263 hc_thread_mutex_unlock (mux_display);
2264
2265 check_hash (device_param, &cracked[i]);
2266 }
2267
2268 myfree (cracked);
2269
2270 if (cpt_cracked > 0)
2271 {
2272 hc_thread_mutex_lock (mux_display);
2273
2274 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2275 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2276
2277 data.cpt_pos++;
2278
2279 data.cpt_total += cpt_cracked;
2280
2281 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2282
2283 hc_thread_mutex_unlock (mux_display);
2284 }
2285
2286 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2287 {
2288 // we need to reset cracked state on the device
2289 // otherwise host thinks again and again the hash was cracked
2290 // and returns invalid password each time
2291
2292 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2293
2294 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2295 }
2296
2297 num_cracked = 0;
2298
2299 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2300 }
2301 }
2302
2303 static void save_hash ()
2304 {
2305 char *hashfile = data.hashfile;
2306
2307 char new_hashfile[256] = { 0 };
2308 char old_hashfile[256] = { 0 };
2309
2310 snprintf (new_hashfile, 255, "%s.new", hashfile);
2311 snprintf (old_hashfile, 255, "%s.old", hashfile);
2312
2313 unlink (new_hashfile);
2314
2315 char separator = data.separator;
2316
2317 FILE *fp = fopen (new_hashfile, "wb");
2318
2319 if (fp == NULL)
2320 {
2321 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2322
2323 exit (-1);
2324 }
2325
2326 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2327 {
2328 if (data.salts_shown[salt_pos] == 1) continue;
2329
2330 salt_t *salt_buf = &data.salts_buf[salt_pos];
2331
2332 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2333 {
2334 uint idx = salt_buf->digests_offset + digest_pos;
2335
2336 if (data.digests_shown[idx] == 1) continue;
2337
2338 if (data.hash_mode != 2500)
2339 {
2340 char out_buf[HCBUFSIZ] = { 0 };
2341
2342 if (data.username == 1)
2343 {
2344 user_t *user = data.hash_info[idx]->user;
2345
2346 uint i;
2347
2348 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2349
2350 fputc (separator, fp);
2351 }
2352
2353 ascii_digest (out_buf, salt_pos, digest_pos);
2354
2355 fputs (out_buf, fp);
2356
2357 log_out (fp, "");
2358 }
2359 else
2360 {
2361 hccap_t hccap;
2362
2363 to_hccap_t (&hccap, salt_pos, digest_pos);
2364
2365 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2366 }
2367 }
2368 }
2369
2370 fflush (fp);
2371
2372 fclose (fp);
2373
2374 unlink (old_hashfile);
2375
2376 if (rename (hashfile, old_hashfile) != 0)
2377 {
2378 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2379
2380 exit (-1);
2381 }
2382
2383 unlink (hashfile);
2384
2385 if (rename (new_hashfile, hashfile) != 0)
2386 {
2387 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2388
2389 exit (-1);
2390 }
2391
2392 unlink (old_hashfile);
2393 }
2394
2395 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2396 {
2397 // function called only in case kernel_power_all > words_left
2398
2399 float kernel_power_div = (float) (total_left) / kernel_power_all;
2400
2401 kernel_power_div += kernel_power_div / 100;
2402
2403 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2404
2405 while (kernel_power_new < total_left)
2406 {
2407 kernel_power_div += kernel_power_div / 100;
2408
2409 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2410 }
2411
2412 if (data.quiet == 0)
2413 {
2414 clear_prompt ();
2415
2416 //log_info ("");
2417
2418 log_info ("INFO: approaching final keyspace, workload adjusted");
2419 log_info ("");
2420
2421 fprintf (stdout, "%s", PROMPT);
2422
2423 fflush (stdout);
2424 }
2425
2426 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2427
2428 return kernel_power_div;
2429 }
2430
2431 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2432 {
2433 uint num_elements = num;
2434
2435 device_param->kernel_params_buf32[30] = data.combs_mode;
2436 device_param->kernel_params_buf32[31] = num;
2437
2438 uint kernel_threads = device_param->kernel_threads;
2439
2440 while (num_elements % kernel_threads) num_elements++;
2441
2442 cl_kernel kernel = NULL;
2443
2444 switch (kern_run)
2445 {
2446 case KERN_RUN_1: kernel = device_param->kernel1; break;
2447 case KERN_RUN_12: kernel = device_param->kernel12; break;
2448 case KERN_RUN_2: kernel = device_param->kernel2; break;
2449 case KERN_RUN_23: kernel = device_param->kernel23; break;
2450 case KERN_RUN_3: kernel = device_param->kernel3; break;
2451 }
2452
2453 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2454 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2455 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2456 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2457 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2458 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2459 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2460 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2461 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2462 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2463 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2464
2465 cl_event event;
2466
2467 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2468 {
2469 const size_t global_work_size[3] = { num_elements, 32, 1 };
2470 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2471
2472 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2473 }
2474 else
2475 {
2476 if (kern_run == KERN_RUN_2)
2477 {
2478 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2479 {
2480 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2481 }
2482 }
2483
2484 while (num_elements % kernel_threads) num_elements++;
2485
2486 const size_t global_work_size[3] = { num_elements, 1, 1 };
2487 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2488
2489 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2490 }
2491
2492 hc_clFlush (data.ocl, device_param->command_queue);
2493
2494 hc_clWaitForEvents (data.ocl, 1, &event);
2495
2496 if (event_update)
2497 {
2498 cl_ulong time_start;
2499 cl_ulong time_end;
2500
2501 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2502 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2503
2504 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2505
2506 uint exec_pos = device_param->exec_pos;
2507
2508 device_param->exec_ms[exec_pos] = exec_time;
2509
2510 exec_pos++;
2511
2512 if (exec_pos == EXEC_CACHE)
2513 {
2514 exec_pos = 0;
2515 }
2516
2517 device_param->exec_pos = exec_pos;
2518 }
2519
2520 hc_clReleaseEvent (data.ocl, event);
2521
2522 hc_clFinish (data.ocl, device_param->command_queue);
2523 }
2524
2525 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2526 {
2527 uint num_elements = num;
2528
2529 switch (kern_run)
2530 {
2531 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2532 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2533 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2534 }
2535
2536 // causes problems with special threads like in bcrypt
2537 // const uint kernel_threads = device_param->kernel_threads;
2538
2539 uint kernel_threads = device_param->kernel_threads;
2540
2541 while (num_elements % kernel_threads) num_elements++;
2542
2543 cl_kernel kernel = NULL;
2544
2545 switch (kern_run)
2546 {
2547 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2548 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2549 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2550 }
2551
2552 switch (kern_run)
2553 {
2554 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2555 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2556 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2557 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2558 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2559 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2560 break;
2561 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2562 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2563 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2564 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2565 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2566 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2567 break;
2568 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2569 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2570 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2571 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2572 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2573 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2574 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2575 break;
2576 }
2577
2578 const size_t global_work_size[3] = { num_elements, 1, 1 };
2579 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2580
2581 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2582
2583 hc_clFlush (data.ocl, device_param->command_queue);
2584
2585 hc_clFinish (data.ocl, device_param->command_queue);
2586 }
2587
2588 static void run_kernel_tm (hc_device_param_t *device_param)
2589 {
2590 const uint num_elements = 1024; // fixed
2591
2592 uint kernel_threads = 32;
2593
2594 cl_kernel kernel = device_param->kernel_tm;
2595
2596 const size_t global_work_size[3] = { num_elements, 1, 1 };
2597 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2598
2599 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2600
2601 hc_clFlush (data.ocl, device_param->command_queue);
2602
2603 hc_clFinish (data.ocl, device_param->command_queue);
2604 }
2605
2606 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2607 {
2608 uint num_elements = num;
2609
2610 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2611 device_param->kernel_params_amp_buf32[6] = num_elements;
2612
2613 // causes problems with special threads like in bcrypt
2614 // const uint kernel_threads = device_param->kernel_threads;
2615
2616 uint kernel_threads = device_param->kernel_threads;
2617
2618 while (num_elements % kernel_threads) num_elements++;
2619
2620 cl_kernel kernel = device_param->kernel_amp;
2621
2622 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2623 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2624
2625 const size_t global_work_size[3] = { num_elements, 1, 1 };
2626 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2627
2628 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2629
2630 hc_clFlush (data.ocl, device_param->command_queue);
2631
2632 hc_clFinish (data.ocl, device_param->command_queue);
2633 }
2634
2635 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2636 {
2637 const u32 num16d = num / 16;
2638 const u32 num16m = num % 16;
2639
2640 if (num16d)
2641 {
2642 device_param->kernel_params_memset_buf32[1] = value;
2643 device_param->kernel_params_memset_buf32[2] = num16d;
2644
2645 uint kernel_threads = device_param->kernel_threads;
2646
2647 uint num_elements = num16d;
2648
2649 while (num_elements % kernel_threads) num_elements++;
2650
2651 cl_kernel kernel = device_param->kernel_memset;
2652
2653 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2654 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2655 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2656
2657 const size_t global_work_size[3] = { num_elements, 1, 1 };
2658 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2659
2660 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2661
2662 hc_clFlush (data.ocl, device_param->command_queue);
2663
2664 hc_clFinish (data.ocl, device_param->command_queue);
2665 }
2666
2667 if (num16m)
2668 {
2669 u32 tmp[4];
2670
2671 tmp[0] = value;
2672 tmp[1] = value;
2673 tmp[2] = value;
2674 tmp[3] = value;
2675
2676 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2677 }
2678 }
2679
2680 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2681 {
2682 run_kernel_memset (device_param, buf, 0, size);
2683
2684 /*
2685 int rc = -1;
2686
2687 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2688 {
2689 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2690
2691 const cl_uchar zero = 0;
2692
2693 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2694 }
2695
2696 if (rc != 0)
2697 {
2698 // NOTE: clEnqueueFillBuffer () always fails with -59
2699 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2700 // How's that possible, OpenCL 1.2 support is advertised??
2701 // We need to workaround...
2702
2703 #define FILLSZ 0x100000
2704
2705 char *tmp = (char *) mymalloc (FILLSZ);
2706
2707 for (size_t i = 0; i < size; i += FILLSZ)
2708 {
2709 const size_t left = size - i;
2710
2711 const size_t fillsz = MIN (FILLSZ, left);
2712
2713 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2714 }
2715
2716 myfree (tmp);
2717 }
2718 */
2719 }
2720
2721 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2722 {
2723 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2724 {
2725 if (attack_mode == ATTACK_MODE_BF)
2726 {
2727 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2728 {
2729 const uint size_tm = 32 * sizeof (bs_word_t);
2730
2731 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2732
2733 run_kernel_tm (device_param);
2734
2735 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2736 }
2737 }
2738
2739 if (highest_pw_len < 16)
2740 {
2741 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2742 }
2743 else if (highest_pw_len < 32)
2744 {
2745 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2746 }
2747 else
2748 {
2749 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2750 }
2751 }
2752 else
2753 {
2754 run_kernel_amp (device_param, pws_cnt);
2755
2756 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2757
2758 if (opts_type & OPTS_TYPE_HOOK12)
2759 {
2760 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2761 }
2762
2763 uint iter = salt_buf->salt_iter;
2764
2765 uint loop_step = device_param->kernel_loops;
2766
2767 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2768 {
2769 uint loop_left = iter - loop_pos;
2770
2771 loop_left = MIN (loop_left, loop_step);
2772
2773 device_param->kernel_params_buf32[25] = loop_pos;
2774 device_param->kernel_params_buf32[26] = loop_left;
2775
2776 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2777
2778 if (data.devices_status == STATUS_CRACKED) break;
2779 if (data.devices_status == STATUS_ABORTED) break;
2780 if (data.devices_status == STATUS_QUIT) break;
2781
2782 /**
2783 * speed
2784 */
2785
2786 const float iter_part = (float) (loop_pos + loop_left) / iter;
2787
2788 const u64 perf_sum_all = pws_cnt * iter_part;
2789
2790 double speed_ms;
2791
2792 hc_timer_get (device_param->timer_speed, speed_ms);
2793
2794 const u32 speed_pos = device_param->speed_pos;
2795
2796 device_param->speed_cnt[speed_pos] = perf_sum_all;
2797
2798 device_param->speed_ms[speed_pos] = speed_ms;
2799
2800 if (data.benchmark == 1)
2801 {
2802 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2803 }
2804 }
2805
2806 if (opts_type & OPTS_TYPE_HOOK23)
2807 {
2808 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2809
2810 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2811
2812 // do something with data
2813
2814 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2815 }
2816
2817 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2818 }
2819 }
2820
2821 static int run_rule_engine (const int rule_len, const char *rule_buf)
2822 {
2823 if (rule_len == 0)
2824 {
2825 return 0;
2826 }
2827 else if (rule_len == 1)
2828 {
2829 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2830 }
2831
2832 return 1;
2833 }
2834
2835 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2836 {
2837 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2838 {
2839 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2840 }
2841 else if (data.attack_kern == ATTACK_KERN_COMBI)
2842 {
2843 if (data.attack_mode == ATTACK_MODE_COMBI)
2844 {
2845 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2846 {
2847 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2848 {
2849 for (u32 i = 0; i < pws_cnt; i++)
2850 {
2851 const u32 pw_len = device_param->pws_buf[i].pw_len;
2852
2853 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2854
2855 ptr[pw_len] = 0x01;
2856 }
2857 }
2858 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2859 {
2860 for (u32 i = 0; i < pws_cnt; i++)
2861 {
2862 const u32 pw_len = device_param->pws_buf[i].pw_len;
2863
2864 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2865
2866 ptr[pw_len] = 0x80;
2867 }
2868 }
2869 }
2870 }
2871 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2872 {
2873 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2874 {
2875 for (u32 i = 0; i < pws_cnt; i++)
2876 {
2877 const u32 pw_len = device_param->pws_buf[i].pw_len;
2878
2879 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2880
2881 ptr[pw_len] = 0x01;
2882 }
2883 }
2884 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2885 {
2886 for (u32 i = 0; i < pws_cnt; i++)
2887 {
2888 const u32 pw_len = device_param->pws_buf[i].pw_len;
2889
2890 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2891
2892 ptr[pw_len] = 0x80;
2893 }
2894 }
2895 }
2896
2897 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2898 }
2899 else if (data.attack_kern == ATTACK_KERN_BF)
2900 {
2901 const u64 off = device_param->words_off;
2902
2903 device_param->kernel_params_mp_l_buf64[3] = off;
2904
2905 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2906 }
2907 }
2908
2909 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2910 {
2911 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2912
2913 device_param->kernel_params_buf32[25] = 0;
2914 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2915 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2916
2917 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2918 {
2919 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2920 }
2921 else
2922 {
2923 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2924 }
2925
2926 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2927
2928 return exec_ms_prev;
2929 }
2930
2931 static void autotune (hc_device_param_t *device_param)
2932 {
2933 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2934
2935 const u32 kernel_accel_min = device_param->kernel_accel_min;
2936 const u32 kernel_accel_max = device_param->kernel_accel_max;
2937
2938 const u32 kernel_loops_min = device_param->kernel_loops_min;
2939 const u32 kernel_loops_max = device_param->kernel_loops_max;
2940
2941 u32 kernel_accel = kernel_accel_min;
2942 u32 kernel_loops = kernel_loops_min;
2943
2944 // in this case the user specified a fixed -u and -n on the commandline
2945 // no way to tune anything
2946 // but we need to run a few caching rounds
2947
2948 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2949 {
2950 try_run (device_param, kernel_accel, kernel_loops);
2951 try_run (device_param, kernel_accel, kernel_loops);
2952 try_run (device_param, kernel_accel, kernel_loops);
2953 try_run (device_param, kernel_accel, kernel_loops);
2954
2955 device_param->kernel_accel = kernel_accel;
2956 device_param->kernel_loops = kernel_loops;
2957
2958 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2959
2960 device_param->kernel_power = kernel_power;
2961
2962 return;
2963 }
2964
2965 // from here it's clear we are allowed to autotune
2966 // so let's init some fake words
2967
2968 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2969
2970 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2971
2972 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2973 {
2974 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 7, kernel_power_max * sizeof (pw_t));
2975 }
2976
2977 /*
2978 for (u32 i = 0; i < kernel_power_max; i++)
2979 {
2980 device_param->pws_buf[i].i[0] = i;
2981 device_param->pws_buf[i].i[1] = 0x01234567;
2982 device_param->pws_buf[i].pw_len = 7;
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 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2988 {
2989 run_kernel_amp (device_param, kernel_power_max);
2990 }
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 #ifdef _WIN
4011 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4012 #endif
4013 }
4014
4015 fan_speed_chgd[device_id] = 1;
4016 }
4017
4018 temp_diff_old[device_id] = temp_diff_new;
4019 }
4020 }
4021 }
4022 }
4023 }
4024
4025 hc_thread_mutex_unlock (mux_adl);
4026 }
4027 #endif // HAVE_HWMON
4028
4029 if (restore_check == 1)
4030 {
4031 restore_left--;
4032
4033 if (restore_left == 0)
4034 {
4035 if (data.restore_disable == 0) cycle_restore ();
4036
4037 restore_left = data.restore_timer;
4038 }
4039 }
4040
4041 if ((runtime_check == 1) && (data.runtime_start > 0))
4042 {
4043 time_t runtime_cur;
4044
4045 time (&runtime_cur);
4046
4047 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4048
4049 if (runtime_left <= 0)
4050 {
4051 if (data.benchmark == 0)
4052 {
4053 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4054 }
4055
4056 if (data.devices_status != STATUS_QUIT) myabort ();
4057 }
4058 }
4059
4060 if (remove_check == 1)
4061 {
4062 remove_left--;
4063
4064 if (remove_left == 0)
4065 {
4066 if (data.digests_saved != data.digests_done)
4067 {
4068 data.digests_saved = data.digests_done;
4069
4070 save_hash ();
4071 }
4072
4073 remove_left = data.remove_timer;
4074 }
4075 }
4076
4077 if (status_check == 1)
4078 {
4079 status_left--;
4080
4081 if (status_left == 0)
4082 {
4083 //hc_thread_mutex_lock (mux_display);
4084
4085 if (data.quiet == 0) clear_prompt ();
4086
4087 if (data.quiet == 0) log_info ("");
4088
4089 status_display ();
4090
4091 if (data.quiet == 0) log_info ("");
4092
4093 //hc_thread_mutex_unlock (mux_display);
4094
4095 status_left = data.status_timer;
4096 }
4097 }
4098 }
4099
4100 #ifdef HAVE_HWMON
4101 myfree (fan_speed_chgd);
4102
4103 myfree (temp_diff_old);
4104 myfree (temp_diff_sum);
4105 #endif
4106
4107 p = NULL;
4108
4109 return (p);
4110 }
4111
4112 static void *thread_outfile_remove (void *p)
4113 {
4114 // some hash-dependent constants
4115 char *outfile_dir = data.outfile_check_directory;
4116 uint dgst_size = data.dgst_size;
4117 uint isSalted = data.isSalted;
4118 uint esalt_size = data.esalt_size;
4119 uint hash_mode = data.hash_mode;
4120
4121 uint outfile_check_timer = data.outfile_check_timer;
4122
4123 char separator = data.separator;
4124
4125 // some hash-dependent functions
4126 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4127 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4128
4129 // buffers
4130 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4131
4132 hash_buf.digest = mymalloc (dgst_size);
4133
4134 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4135
4136 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4137
4138 uint digest_buf[64] = { 0 };
4139
4140 outfile_data_t *out_info = NULL;
4141
4142 char **out_files = NULL;
4143
4144 time_t folder_mtime = 0;
4145
4146 int out_cnt = 0;
4147
4148 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4149
4150 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4151 {
4152 hc_sleep (1);
4153
4154 if (data.devices_status != STATUS_RUNNING) continue;
4155
4156 check_left--;
4157
4158 if (check_left == 0)
4159 {
4160 struct stat outfile_check_stat;
4161
4162 if (stat (outfile_dir, &outfile_check_stat) == 0)
4163 {
4164 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4165
4166 if (is_dir == 1)
4167 {
4168 if (outfile_check_stat.st_mtime > folder_mtime)
4169 {
4170 char **out_files_new = scan_directory (outfile_dir);
4171
4172 int out_cnt_new = count_dictionaries (out_files_new);
4173
4174 outfile_data_t *out_info_new = NULL;
4175
4176 if (out_cnt_new > 0)
4177 {
4178 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4179
4180 for (int i = 0; i < out_cnt_new; i++)
4181 {
4182 out_info_new[i].file_name = out_files_new[i];
4183
4184 // check if there are files that we have seen/checked before (and not changed)
4185
4186 for (int j = 0; j < out_cnt; j++)
4187 {
4188 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4189 {
4190 struct stat outfile_stat;
4191
4192 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4193 {
4194 if (outfile_stat.st_ctime == out_info[j].ctime)
4195 {
4196 out_info_new[i].ctime = out_info[j].ctime;
4197 out_info_new[i].seek = out_info[j].seek;
4198 }
4199 }
4200 }
4201 }
4202 }
4203 }
4204
4205 local_free (out_info);
4206 local_free (out_files);
4207
4208 out_files = out_files_new;
4209 out_cnt = out_cnt_new;
4210 out_info = out_info_new;
4211
4212 folder_mtime = outfile_check_stat.st_mtime;
4213 }
4214
4215 for (int j = 0; j < out_cnt; j++)
4216 {
4217 FILE *fp = fopen (out_info[j].file_name, "rb");
4218
4219 if (fp != NULL)
4220 {
4221 //hc_thread_mutex_lock (mux_display);
4222
4223 #ifdef _POSIX
4224 struct stat outfile_stat;
4225
4226 fstat (fileno (fp), &outfile_stat);
4227 #endif
4228
4229 #ifdef _WIN
4230 struct stat64 outfile_stat;
4231
4232 _fstat64 (fileno (fp), &outfile_stat);
4233 #endif
4234
4235 if (outfile_stat.st_ctime > out_info[j].ctime)
4236 {
4237 out_info[j].ctime = outfile_stat.st_ctime;
4238 out_info[j].seek = 0;
4239 }
4240
4241 fseek (fp, out_info[j].seek, SEEK_SET);
4242
4243 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4244
4245 while (!feof (fp))
4246 {
4247 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4248
4249 if (ptr == NULL) break;
4250
4251 int line_len = strlen (line_buf);
4252
4253 if (line_len <= 0) continue;
4254
4255 int iter = MAX_CUT_TRIES;
4256
4257 for (uint i = line_len - 1; i && iter; i--, line_len--)
4258 {
4259 if (line_buf[i] != separator) continue;
4260
4261 int parser_status = PARSER_OK;
4262
4263 if ((hash_mode != 2500) && (hash_mode != 6800))
4264 {
4265 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4266 }
4267
4268 uint found = 0;
4269
4270 if (parser_status == PARSER_OK)
4271 {
4272 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4273 {
4274 if (data.salts_shown[salt_pos] == 1) continue;
4275
4276 salt_t *salt_buf = &data.salts_buf[salt_pos];
4277
4278 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4279 {
4280 uint idx = salt_buf->digests_offset + digest_pos;
4281
4282 if (data.digests_shown[idx] == 1) continue;
4283
4284 uint cracked = 0;
4285
4286 if (hash_mode == 6800)
4287 {
4288 if (i == salt_buf->salt_len)
4289 {
4290 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4291 }
4292 }
4293 else if (hash_mode == 2500)
4294 {
4295 // BSSID : MAC1 : MAC2 (:plain)
4296 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4297 {
4298 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4299
4300 if (!cracked) continue;
4301
4302 // now compare MAC1 and MAC2 too, since we have this additional info
4303 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4304 char *mac2_pos = mac1_pos + 12 + 1;
4305
4306 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4307 wpa_t *wpa = &wpas[salt_pos];
4308
4309 // compare hex string(s) vs binary MAC address(es)
4310
4311 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4312 {
4313 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4314 {
4315 cracked = 0;
4316
4317 break;
4318 }
4319 }
4320
4321 // early skip ;)
4322 if (!cracked) continue;
4323
4324 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4325 {
4326 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4327 {
4328 cracked = 0;
4329
4330 break;
4331 }
4332 }
4333 }
4334 }
4335 else
4336 {
4337 char *digests_buf_ptr = (char *) data.digests_buf;
4338
4339 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4340
4341 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4342 }
4343
4344 if (cracked == 1)
4345 {
4346 found = 1;
4347
4348 data.digests_shown[idx] = 1;
4349
4350 data.digests_done++;
4351
4352 salt_buf->digests_done++;
4353
4354 if (salt_buf->digests_done == salt_buf->digests_cnt)
4355 {
4356 data.salts_shown[salt_pos] = 1;
4357
4358 data.salts_done++;
4359
4360 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4361 }
4362 }
4363 }
4364
4365 if (data.devices_status == STATUS_CRACKED) break;
4366 }
4367 }
4368
4369 if (found) break;
4370
4371 if (data.devices_status == STATUS_CRACKED) break;
4372
4373 iter--;
4374 }
4375
4376 if (data.devices_status == STATUS_CRACKED) break;
4377 }
4378
4379 myfree (line_buf);
4380
4381 out_info[j].seek = ftell (fp);
4382
4383 //hc_thread_mutex_unlock (mux_display);
4384
4385 fclose (fp);
4386 }
4387 }
4388 }
4389 }
4390
4391 check_left = outfile_check_timer;
4392 }
4393 }
4394
4395 if (esalt_size) local_free (hash_buf.esalt);
4396
4397 if (isSalted) local_free (hash_buf.salt);
4398
4399 local_free (hash_buf.digest);
4400
4401 local_free (out_info);
4402
4403 local_free (out_files);
4404
4405 p = NULL;
4406
4407 return (p);
4408 }
4409
4410 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4411 {
4412 if (device_param->pws_cnt < device_param->kernel_power)
4413 {
4414 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4415
4416 u8 *ptr = (u8 *) pw->i;
4417
4418 memcpy (ptr, pw_buf, pw_len);
4419
4420 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4421
4422 pw->pw_len = pw_len;
4423
4424 device_param->pws_cnt++;
4425 }
4426 else
4427 {
4428 fprintf (stderr, "BUG pw_add()!!\n");
4429
4430 return;
4431 }
4432 }
4433
4434 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4435 {
4436 hc_thread_mutex_lock (mux_dispatcher);
4437
4438 const u64 words_cur = data.words_cur;
4439 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4440
4441 device_param->words_off = words_cur;
4442
4443 const u64 words_left = words_base - words_cur;
4444
4445 if (allow_div)
4446 {
4447 if (data.kernel_power_all > words_left)
4448 {
4449 if (data.kernel_power_div == 0)
4450 {
4451 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4452 }
4453 }
4454
4455 if (data.kernel_power_div)
4456 {
4457 if (device_param->kernel_power == device_param->kernel_power_user)
4458 {
4459 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4460
4461 if (kernel_power_new < device_param->kernel_power)
4462 {
4463 device_param->kernel_power = kernel_power_new;
4464 }
4465 }
4466 }
4467 }
4468
4469 const uint kernel_power = device_param->kernel_power;
4470
4471 uint work = MIN (words_left, kernel_power);
4472
4473 work = MIN (work, max);
4474
4475 data.words_cur += work;
4476
4477 hc_thread_mutex_unlock (mux_dispatcher);
4478
4479 return work;
4480 }
4481
4482 static void *thread_calc_stdin (void *p)
4483 {
4484 hc_device_param_t *device_param = (hc_device_param_t *) p;
4485
4486 if (device_param->skipped) return NULL;
4487
4488 autotune (device_param);
4489
4490 char *buf = (char *) mymalloc (HCBUFSIZ);
4491
4492 const uint attack_kern = data.attack_kern;
4493
4494 const uint kernel_power = device_param->kernel_power;
4495
4496 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4497 {
4498 hc_thread_mutex_lock (mux_dispatcher);
4499
4500 if (feof (stdin) != 0)
4501 {
4502 hc_thread_mutex_unlock (mux_dispatcher);
4503
4504 break;
4505 }
4506
4507 uint words_cur = 0;
4508
4509 while (words_cur < kernel_power)
4510 {
4511 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4512
4513 if (line_buf == NULL) break;
4514
4515 uint line_len = in_superchop (line_buf);
4516
4517 line_len = convert_from_hex (line_buf, line_len);
4518
4519 // post-process rule engine
4520
4521 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4522 {
4523 char rule_buf_out[BLOCK_SIZE] = { 0 };
4524
4525 int rule_len_out = -1;
4526
4527 if (line_len < BLOCK_SIZE)
4528 {
4529 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4530 }
4531
4532 if (rule_len_out < 0) continue;
4533
4534 line_buf = rule_buf_out;
4535 line_len = rule_len_out;
4536 }
4537
4538 if (line_len > PW_MAX)
4539 {
4540 continue;
4541 }
4542
4543 if (attack_kern == ATTACK_KERN_STRAIGHT)
4544 {
4545 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4546 {
4547 hc_thread_mutex_lock (mux_counter);
4548
4549 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4550 {
4551 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4552 }
4553
4554 hc_thread_mutex_unlock (mux_counter);
4555
4556 continue;
4557 }
4558 }
4559 else if (attack_kern == ATTACK_KERN_COMBI)
4560 {
4561 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4562 // since we still need to combine the plains
4563
4564 if (line_len > data.pw_max)
4565 {
4566 hc_thread_mutex_lock (mux_counter);
4567
4568 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4569 {
4570 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4571 }
4572
4573 hc_thread_mutex_unlock (mux_counter);
4574
4575 continue;
4576 }
4577 }
4578
4579 pw_add (device_param, (u8 *) line_buf, line_len);
4580
4581 words_cur++;
4582
4583 if (data.devices_status == STATUS_CRACKED) break;
4584 if (data.devices_status == STATUS_ABORTED) break;
4585 if (data.devices_status == STATUS_QUIT) break;
4586 if (data.devices_status == STATUS_BYPASS) break;
4587 }
4588
4589 hc_thread_mutex_unlock (mux_dispatcher);
4590
4591 if (data.devices_status == STATUS_CRACKED) break;
4592 if (data.devices_status == STATUS_ABORTED) break;
4593 if (data.devices_status == STATUS_QUIT) break;
4594 if (data.devices_status == STATUS_BYPASS) break;
4595
4596 // flush
4597
4598 const uint pws_cnt = device_param->pws_cnt;
4599
4600 if (pws_cnt)
4601 {
4602 run_copy (device_param, pws_cnt);
4603
4604 run_cracker (device_param, pws_cnt);
4605
4606 device_param->pws_cnt = 0;
4607
4608 /*
4609 still required?
4610 if (attack_kern == ATTACK_KERN_STRAIGHT)
4611 {
4612 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4613 }
4614 else if (attack_kern == ATTACK_KERN_COMBI)
4615 {
4616 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4617 }
4618 */
4619 }
4620 }
4621
4622 device_param->kernel_accel = 0;
4623 device_param->kernel_loops = 0;
4624
4625 myfree (buf);
4626
4627 return NULL;
4628 }
4629
4630 static void *thread_calc (void *p)
4631 {
4632 hc_device_param_t *device_param = (hc_device_param_t *) p;
4633
4634 if (device_param->skipped) return NULL;
4635
4636 autotune (device_param);
4637
4638 const uint attack_mode = data.attack_mode;
4639 const uint attack_kern = data.attack_kern;
4640
4641 if (attack_mode == ATTACK_MODE_BF)
4642 {
4643 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4644 {
4645 const uint work = get_work (device_param, -1, true);
4646
4647 if (work == 0) break;
4648
4649 const u64 words_off = device_param->words_off;
4650 const u64 words_fin = words_off + work;
4651
4652 const uint pws_cnt = work;
4653
4654 device_param->pws_cnt = pws_cnt;
4655
4656 if (pws_cnt)
4657 {
4658 run_copy (device_param, pws_cnt);
4659
4660 run_cracker (device_param, pws_cnt);
4661
4662 device_param->pws_cnt = 0;
4663
4664 /*
4665 still required?
4666 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4667 */
4668 }
4669
4670 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4671
4672 if (data.devices_status == STATUS_CRACKED) break;
4673 if (data.devices_status == STATUS_ABORTED) break;
4674 if (data.devices_status == STATUS_QUIT) break;
4675 if (data.devices_status == STATUS_BYPASS) break;
4676
4677 if (data.benchmark == 1) break;
4678
4679 device_param->words_done = words_fin;
4680 }
4681 }
4682 else
4683 {
4684 const uint segment_size = data.segment_size;
4685
4686 char *dictfile = data.dictfile;
4687
4688 if (attack_mode == ATTACK_MODE_COMBI)
4689 {
4690 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4691 {
4692 dictfile = data.dictfile2;
4693 }
4694 }
4695
4696 FILE *fd = fopen (dictfile, "rb");
4697
4698 if (fd == NULL)
4699 {
4700 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4701
4702 return NULL;
4703 }
4704
4705 if (attack_mode == ATTACK_MODE_COMBI)
4706 {
4707 const uint combs_mode = data.combs_mode;
4708
4709 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4710 {
4711 const char *dictfilec = data.dictfile2;
4712
4713 FILE *combs_fp = fopen (dictfilec, "rb");
4714
4715 if (combs_fp == NULL)
4716 {
4717 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4718
4719 fclose (fd);
4720
4721 return NULL;
4722 }
4723
4724 device_param->combs_fp = combs_fp;
4725 }
4726 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4727 {
4728 const char *dictfilec = data.dictfile;
4729
4730 FILE *combs_fp = fopen (dictfilec, "rb");
4731
4732 if (combs_fp == NULL)
4733 {
4734 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4735
4736 fclose (fd);
4737
4738 return NULL;
4739 }
4740
4741 device_param->combs_fp = combs_fp;
4742 }
4743 }
4744
4745 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4746
4747 wl_data->buf = (char *) mymalloc (segment_size);
4748 wl_data->avail = segment_size;
4749 wl_data->incr = segment_size;
4750 wl_data->cnt = 0;
4751 wl_data->pos = 0;
4752
4753 u64 words_cur = 0;
4754
4755 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4756 {
4757 u64 words_off = 0;
4758 u64 words_fin = 0;
4759
4760 bool allow_div = true;
4761
4762 u64 max = -1;
4763
4764 while (max)
4765 {
4766 const uint work = get_work (device_param, max, allow_div);
4767
4768 allow_div = false;
4769
4770 if (work == 0) break;
4771
4772 words_off = device_param->words_off;
4773 words_fin = words_off + work;
4774
4775 char *line_buf;
4776 uint line_len;
4777
4778 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4779
4780 max = 0;
4781
4782 for ( ; words_cur < words_fin; words_cur++)
4783 {
4784 get_next_word (wl_data, fd, &line_buf, &line_len);
4785
4786 line_len = convert_from_hex (line_buf, line_len);
4787
4788 // post-process rule engine
4789
4790 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4791 {
4792 char rule_buf_out[BLOCK_SIZE] = { 0 };
4793
4794 int rule_len_out = -1;
4795
4796 if (line_len < BLOCK_SIZE)
4797 {
4798 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4799 }
4800
4801 if (rule_len_out < 0) continue;
4802
4803 line_buf = rule_buf_out;
4804 line_len = rule_len_out;
4805 }
4806
4807 if (attack_kern == ATTACK_KERN_STRAIGHT)
4808 {
4809 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4810 {
4811 max++;
4812
4813 hc_thread_mutex_lock (mux_counter);
4814
4815 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4816 {
4817 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4818 }
4819
4820 hc_thread_mutex_unlock (mux_counter);
4821
4822 continue;
4823 }
4824 }
4825 else if (attack_kern == ATTACK_KERN_COMBI)
4826 {
4827 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4828 // since we still need to combine the plains
4829
4830 if (line_len > data.pw_max)
4831 {
4832 max++;
4833
4834 hc_thread_mutex_lock (mux_counter);
4835
4836 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4837 {
4838 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4839 }
4840
4841 hc_thread_mutex_unlock (mux_counter);
4842
4843 continue;
4844 }
4845 }
4846
4847 pw_add (device_param, (u8 *) line_buf, line_len);
4848
4849 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4850
4851 if (data.devices_status == STATUS_CRACKED) break;
4852 if (data.devices_status == STATUS_ABORTED) break;
4853 if (data.devices_status == STATUS_QUIT) break;
4854 if (data.devices_status == STATUS_BYPASS) break;
4855 }
4856
4857 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4858
4859 if (data.devices_status == STATUS_CRACKED) break;
4860 if (data.devices_status == STATUS_ABORTED) break;
4861 if (data.devices_status == STATUS_QUIT) break;
4862 if (data.devices_status == STATUS_BYPASS) break;
4863 }
4864
4865 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4866
4867 if (data.devices_status == STATUS_CRACKED) break;
4868 if (data.devices_status == STATUS_ABORTED) break;
4869 if (data.devices_status == STATUS_QUIT) break;
4870 if (data.devices_status == STATUS_BYPASS) break;
4871
4872 //
4873 // flush
4874 //
4875
4876 const uint pws_cnt = device_param->pws_cnt;
4877
4878 if (pws_cnt)
4879 {
4880 run_copy (device_param, pws_cnt);
4881
4882 run_cracker (device_param, pws_cnt);
4883
4884 device_param->pws_cnt = 0;
4885
4886 /*
4887 still required?
4888 if (attack_kern == ATTACK_KERN_STRAIGHT)
4889 {
4890 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4891 }
4892 else if (attack_kern == ATTACK_KERN_COMBI)
4893 {
4894 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4895 }
4896 */
4897 }
4898
4899 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4900
4901 if (data.devices_status == STATUS_CRACKED) break;
4902 if (data.devices_status == STATUS_ABORTED) break;
4903 if (data.devices_status == STATUS_QUIT) break;
4904 if (data.devices_status == STATUS_BYPASS) break;
4905
4906 if (words_fin == 0) break;
4907
4908 device_param->words_done = words_fin;
4909 }
4910
4911 if (attack_mode == ATTACK_MODE_COMBI)
4912 {
4913 fclose (device_param->combs_fp);
4914 }
4915
4916 free (wl_data->buf);
4917 free (wl_data);
4918
4919 fclose (fd);
4920 }
4921
4922 device_param->kernel_accel = 0;
4923 device_param->kernel_loops = 0;
4924
4925 return NULL;
4926 }
4927
4928 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4929 {
4930 if (!device_param)
4931 {
4932 log_error ("ERROR: %s : Invalid argument", __func__);
4933
4934 exit (-1);
4935 }
4936
4937 salt_t *salt_buf = &data.salts_buf[salt_pos];
4938
4939 device_param->kernel_params_buf32[24] = salt_pos;
4940 device_param->kernel_params_buf32[27] = 1;
4941 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4942 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4943 device_param->kernel_params_buf32[30] = 0;
4944 device_param->kernel_params_buf32[31] = 1;
4945
4946 char *dictfile_old = data.dictfile;
4947
4948 const char *weak_hash_check = "weak-hash-check";
4949
4950 data.dictfile = (char *) weak_hash_check;
4951
4952 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4953
4954 data.kernel_rules_buf[0].cmds[0] = 0;
4955
4956 /**
4957 * run the kernel
4958 */
4959
4960 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4961 {
4962 run_kernel (KERN_RUN_1, device_param, 1, false);
4963 }
4964 else
4965 {
4966 run_kernel (KERN_RUN_1, device_param, 1, false);
4967
4968 uint loop_step = 16;
4969
4970 const uint iter = salt_buf->salt_iter;
4971
4972 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4973 {
4974 uint loop_left = iter - loop_pos;
4975
4976 loop_left = MIN (loop_left, loop_step);
4977
4978 device_param->kernel_params_buf32[25] = loop_pos;
4979 device_param->kernel_params_buf32[26] = loop_left;
4980
4981 run_kernel (KERN_RUN_2, device_param, 1, false);
4982 }
4983
4984 run_kernel (KERN_RUN_3, device_param, 1, false);
4985 }
4986
4987 /**
4988 * result
4989 */
4990
4991 check_cracked (device_param, salt_pos);
4992
4993 /**
4994 * cleanup
4995 */
4996
4997 device_param->kernel_params_buf32[24] = 0;
4998 device_param->kernel_params_buf32[25] = 0;
4999 device_param->kernel_params_buf32[26] = 0;
5000 device_param->kernel_params_buf32[27] = 0;
5001 device_param->kernel_params_buf32[28] = 0;
5002 device_param->kernel_params_buf32[29] = 0;
5003 device_param->kernel_params_buf32[30] = 0;
5004 device_param->kernel_params_buf32[31] = 0;
5005
5006 data.dictfile = dictfile_old;
5007
5008 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5009 }
5010
5011 // hlfmt hashcat
5012
5013 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5014 {
5015 if (data.username == 0)
5016 {
5017 *hashbuf_pos = line_buf;
5018 *hashbuf_len = line_len;
5019 }
5020 else
5021 {
5022 char *pos = line_buf;
5023 int len = line_len;
5024
5025 for (int i = 0; i < line_len; i++, pos++, len--)
5026 {
5027 if (line_buf[i] == data.separator)
5028 {
5029 pos++;
5030
5031 len--;
5032
5033 break;
5034 }
5035 }
5036
5037 *hashbuf_pos = pos;
5038 *hashbuf_len = len;
5039 }
5040 }
5041
5042 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5043 {
5044 char *pos = NULL;
5045 int len = 0;
5046
5047 int sep_cnt = 0;
5048
5049 for (int i = 0; i < line_len; i++)
5050 {
5051 if (line_buf[i] == data.separator)
5052 {
5053 sep_cnt++;
5054
5055 continue;
5056 }
5057
5058 if (sep_cnt == 0)
5059 {
5060 if (pos == NULL) pos = line_buf + i;
5061
5062 len++;
5063 }
5064 }
5065
5066 *userbuf_pos = pos;
5067 *userbuf_len = len;
5068 }
5069
5070 // hlfmt pwdump
5071
5072 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5073 {
5074 int sep_cnt = 0;
5075
5076 int sep2_len = 0;
5077 int sep3_len = 0;
5078
5079 for (int i = 0; i < line_len; i++)
5080 {
5081 if (line_buf[i] == ':')
5082 {
5083 sep_cnt++;
5084
5085 continue;
5086 }
5087
5088 if (sep_cnt == 2) sep2_len++;
5089 if (sep_cnt == 3) sep3_len++;
5090 }
5091
5092 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5093
5094 return 0;
5095 }
5096
5097 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5098 {
5099 char *pos = NULL;
5100 int len = 0;
5101
5102 int sep_cnt = 0;
5103
5104 for (int i = 0; i < line_len; i++)
5105 {
5106 if (line_buf[i] == ':')
5107 {
5108 sep_cnt++;
5109
5110 continue;
5111 }
5112
5113 if (data.hash_mode == 1000)
5114 {
5115 if (sep_cnt == 3)
5116 {
5117 if (pos == NULL) pos = line_buf + i;
5118
5119 len++;
5120 }
5121 }
5122 else if (data.hash_mode == 3000)
5123 {
5124 if (sep_cnt == 2)
5125 {
5126 if (pos == NULL) pos = line_buf + i;
5127
5128 len++;
5129 }
5130 }
5131 }
5132
5133 *hashbuf_pos = pos;
5134 *hashbuf_len = len;
5135 }
5136
5137 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5138 {
5139 char *pos = NULL;
5140 int len = 0;
5141
5142 int sep_cnt = 0;
5143
5144 for (int i = 0; i < line_len; i++)
5145 {
5146 if (line_buf[i] == ':')
5147 {
5148 sep_cnt++;
5149
5150 continue;
5151 }
5152
5153 if (sep_cnt == 0)
5154 {
5155 if (pos == NULL) pos = line_buf + i;
5156
5157 len++;
5158 }
5159 }
5160
5161 *userbuf_pos = pos;
5162 *userbuf_len = len;
5163 }
5164
5165 // hlfmt passwd
5166
5167 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5168 {
5169 int sep_cnt = 0;
5170
5171 char sep5_first = 0;
5172 char sep6_first = 0;
5173
5174 for (int i = 0; i < line_len; i++)
5175 {
5176 if (line_buf[i] == ':')
5177 {
5178 sep_cnt++;
5179
5180 continue;
5181 }
5182
5183 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5184 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5185 }
5186
5187 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5188
5189 return 0;
5190 }
5191
5192 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5193 {
5194 char *pos = NULL;
5195 int len = 0;
5196
5197 int sep_cnt = 0;
5198
5199 for (int i = 0; i < line_len; i++)
5200 {
5201 if (line_buf[i] == ':')
5202 {
5203 sep_cnt++;
5204
5205 continue;
5206 }
5207
5208 if (sep_cnt == 1)
5209 {
5210 if (pos == NULL) pos = line_buf + i;
5211
5212 len++;
5213 }
5214 }
5215
5216 *hashbuf_pos = pos;
5217 *hashbuf_len = len;
5218 }
5219
5220 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5221 {
5222 char *pos = NULL;
5223 int len = 0;
5224
5225 int sep_cnt = 0;
5226
5227 for (int i = 0; i < line_len; i++)
5228 {
5229 if (line_buf[i] == ':')
5230 {
5231 sep_cnt++;
5232
5233 continue;
5234 }
5235
5236 if (sep_cnt == 0)
5237 {
5238 if (pos == NULL) pos = line_buf + i;
5239
5240 len++;
5241 }
5242 }
5243
5244 *userbuf_pos = pos;
5245 *userbuf_len = len;
5246 }
5247
5248 // hlfmt shadow
5249
5250 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5251 {
5252 int sep_cnt = 0;
5253
5254 for (int i = 0; i < line_len; i++)
5255 {
5256 if (line_buf[i] == ':') sep_cnt++;
5257 }
5258
5259 if (sep_cnt == 8) return 1;
5260
5261 return 0;
5262 }
5263
5264 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5265 {
5266 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5267 }
5268
5269 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5270 {
5271 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5272 }
5273
5274 // hlfmt main
5275
5276 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5277 {
5278 switch (hashfile_format)
5279 {
5280 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5281 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5282 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5283 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5284 }
5285 }
5286
5287 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5288 {
5289 switch (hashfile_format)
5290 {
5291 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5292 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5293 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5294 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5295 }
5296 }
5297
5298 char *strhlfmt (const uint hashfile_format)
5299 {
5300 switch (hashfile_format)
5301 {
5302 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5303 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5304 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5305 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5306 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5307 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5308 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5309 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5310 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5311 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5312 }
5313
5314 return ((char *) "Unknown");
5315 }
5316
5317 static uint hlfmt_detect (FILE *fp, uint max_check)
5318 {
5319 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5320
5321 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5322 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5323
5324 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5325
5326 uint num_check = 0;
5327
5328 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5329
5330 while (!feof (fp))
5331 {
5332 int line_len = fgetl (fp, line_buf);
5333
5334 if (line_len == 0) continue;
5335
5336 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5337 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5338 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5339
5340 if (num_check == max_check) break;
5341
5342 num_check++;
5343 }
5344
5345 myfree (line_buf);
5346
5347 uint hashlist_format = HLFMT_HASHCAT;
5348
5349 for (int i = 1; i < HLFMTS_CNT; i++)
5350 {
5351 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5352
5353 hashlist_format = i;
5354 }
5355
5356 free (formats_cnt);
5357
5358 return hashlist_format;
5359 }
5360
5361 /**
5362 * some further helper function
5363 */
5364
5365 // wrapper around mymalloc for ADL
5366
5367 #if defined(HAVE_HWMON)
5368 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5369 {
5370 return mymalloc (iSize);
5371 }
5372 #endif
5373
5374 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)
5375 {
5376 u64 collisions = 0;
5377
5378 const uint dgst_pos0 = data.dgst_pos0;
5379 const uint dgst_pos1 = data.dgst_pos1;
5380 const uint dgst_pos2 = data.dgst_pos2;
5381 const uint dgst_pos3 = data.dgst_pos3;
5382
5383 memset (bitmap_a, 0, bitmap_size);
5384 memset (bitmap_b, 0, bitmap_size);
5385 memset (bitmap_c, 0, bitmap_size);
5386 memset (bitmap_d, 0, bitmap_size);
5387
5388 for (uint i = 0; i < digests_cnt; i++)
5389 {
5390 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5391
5392 uint *digest_ptr = (uint *) digests_buf_ptr;
5393
5394 digests_buf_ptr += dgst_size;
5395
5396 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5397 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5398 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5399 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5400
5401 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5402 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5403 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5404 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5405
5406 if (bitmap_a[idx0] & val0) collisions++;
5407 if (bitmap_b[idx1] & val1) collisions++;
5408 if (bitmap_c[idx2] & val2) collisions++;
5409 if (bitmap_d[idx3] & val3) collisions++;
5410
5411 bitmap_a[idx0] |= val0;
5412 bitmap_b[idx1] |= val1;
5413 bitmap_c[idx2] |= val2;
5414 bitmap_d[idx3] |= val3;
5415
5416 if (collisions >= collisions_max) return 0x7fffffff;
5417 }
5418
5419 return collisions;
5420 }
5421
5422 /**
5423 * main
5424 */
5425
5426 #ifdef _WIN
5427 void SetConsoleWindowSize (const int x)
5428 {
5429 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5430
5431 if (h == INVALID_HANDLE_VALUE) return;
5432
5433 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5434
5435 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5436
5437 SMALL_RECT *sr = &bufferInfo.srWindow;
5438
5439 sr->Right = MAX (sr->Right, x - 1);
5440
5441 COORD co;
5442
5443 co.X = sr->Right + 1;
5444 co.Y = sr->Bottom + 1;
5445
5446 if (!SetConsoleScreenBufferSize (h, co)) return;
5447
5448 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5449 }
5450 #endif
5451
5452 int main (int argc, char **argv)
5453 {
5454 #ifdef _WIN
5455 SetConsoleWindowSize (132);
5456 #endif
5457
5458 /**
5459 * To help users a bit
5460 */
5461
5462 char *compute = getenv ("COMPUTE");
5463
5464 if (compute)
5465 {
5466 static char display[100];
5467
5468 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5469
5470 putenv (display);
5471 }
5472 else
5473 {
5474 if (getenv ("DISPLAY") == NULL)
5475 putenv ((char *) "DISPLAY=:0");
5476 }
5477
5478 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5479 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5480
5481 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5482 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5483
5484 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5485 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5486
5487 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5488 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5489
5490 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5491 putenv ((char *) "POCL_KERNEL_CACHE=0");
5492
5493 umask (077);
5494
5495 /**
5496 * Real init
5497 */
5498
5499 memset (&data, 0, sizeof (hc_global_data_t));
5500
5501 time_t proc_start;
5502
5503 time (&proc_start);
5504
5505 data.proc_start = proc_start;
5506
5507 int myargc = argc;
5508 char **myargv = argv;
5509
5510 hc_thread_mutex_init (mux_dispatcher);
5511 hc_thread_mutex_init (mux_counter);
5512 hc_thread_mutex_init (mux_display);
5513 hc_thread_mutex_init (mux_adl);
5514
5515 /**
5516 * commandline parameters
5517 */
5518
5519 uint usage = USAGE;
5520 uint version = VERSION;
5521 uint quiet = QUIET;
5522 uint benchmark = BENCHMARK;
5523 uint show = SHOW;
5524 uint left = LEFT;
5525 uint username = USERNAME;
5526 uint remove = REMOVE;
5527 uint remove_timer = REMOVE_TIMER;
5528 u64 skip = SKIP;
5529 u64 limit = LIMIT;
5530 uint keyspace = KEYSPACE;
5531 uint potfile_disable = POTFILE_DISABLE;
5532 char *potfile_path = NULL;
5533 uint debug_mode = DEBUG_MODE;
5534 char *debug_file = NULL;
5535 char *induction_dir = NULL;
5536 char *outfile_check_dir = NULL;
5537 uint force = FORCE;
5538 uint runtime = RUNTIME;
5539 uint hash_mode = HASH_MODE;
5540 uint attack_mode = ATTACK_MODE;
5541 uint markov_disable = MARKOV_DISABLE;
5542 uint markov_classic = MARKOV_CLASSIC;
5543 uint markov_threshold = MARKOV_THRESHOLD;
5544 char *markov_hcstat = NULL;
5545 char *outfile = NULL;
5546 uint outfile_format = OUTFILE_FORMAT;
5547 uint outfile_autohex = OUTFILE_AUTOHEX;
5548 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5549 uint restore = RESTORE;
5550 uint restore_timer = RESTORE_TIMER;
5551 uint restore_disable = RESTORE_DISABLE;
5552 uint status = STATUS;
5553 uint status_timer = STATUS_TIMER;
5554 uint machine_readable = MACHINE_READABLE;
5555 uint loopback = LOOPBACK;
5556 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5557 char *session = NULL;
5558 uint hex_charset = HEX_CHARSET;
5559 uint hex_salt = HEX_SALT;
5560 uint hex_wordlist = HEX_WORDLIST;
5561 uint rp_gen = RP_GEN;
5562 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5563 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5564 uint rp_gen_seed = RP_GEN_SEED;
5565 char *rule_buf_l = (char *) RULE_BUF_L;
5566 char *rule_buf_r = (char *) RULE_BUF_R;
5567 uint increment = INCREMENT;
5568 uint increment_min = INCREMENT_MIN;
5569 uint increment_max = INCREMENT_MAX;
5570 char *cpu_affinity = NULL;
5571 OCL_PTR *ocl = NULL;
5572 char *opencl_devices = NULL;
5573 char *opencl_platforms = NULL;
5574 char *opencl_device_types = NULL;
5575 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5576 char *truecrypt_keyfiles = NULL;
5577 char *veracrypt_keyfiles = NULL;
5578 uint veracrypt_pim = 0;
5579 uint workload_profile = WORKLOAD_PROFILE;
5580 uint kernel_accel = KERNEL_ACCEL;
5581 uint kernel_loops = KERNEL_LOOPS;
5582 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5583 #ifdef HAVE_HWMON
5584 uint gpu_temp_abort = GPU_TEMP_ABORT;
5585 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5586 uint powertune_enable = POWERTUNE_ENABLE;
5587 #endif
5588 uint logfile_disable = LOGFILE_DISABLE;
5589 uint segment_size = SEGMENT_SIZE;
5590 uint scrypt_tmto = SCRYPT_TMTO;
5591 char separator = SEPARATOR;
5592 uint bitmap_min = BITMAP_MIN;
5593 uint bitmap_max = BITMAP_MAX;
5594 char *custom_charset_1 = NULL;
5595 char *custom_charset_2 = NULL;
5596 char *custom_charset_3 = NULL;
5597 char *custom_charset_4 = NULL;
5598
5599 #define IDX_HELP 'h'
5600 #define IDX_VERSION 'V'
5601 #define IDX_VERSION_LOWER 'v'
5602 #define IDX_QUIET 0xff02
5603 #define IDX_SHOW 0xff03
5604 #define IDX_LEFT 0xff04
5605 #define IDX_REMOVE 0xff05
5606 #define IDX_REMOVE_TIMER 0xff37
5607 #define IDX_SKIP 's'
5608 #define IDX_LIMIT 'l'
5609 #define IDX_KEYSPACE 0xff35
5610 #define IDX_POTFILE_DISABLE 0xff06
5611 #define IDX_POTFILE_PATH 0xffe0
5612 #define IDX_DEBUG_MODE 0xff43
5613 #define IDX_DEBUG_FILE 0xff44
5614 #define IDX_INDUCTION_DIR 0xff46
5615 #define IDX_OUTFILE_CHECK_DIR 0xff47
5616 #define IDX_USERNAME 0xff07
5617 #define IDX_FORCE 0xff08
5618 #define IDX_RUNTIME 0xff09
5619 #define IDX_BENCHMARK 'b'
5620 #define IDX_HASH_MODE 'm'
5621 #define IDX_ATTACK_MODE 'a'
5622 #define IDX_RP_FILE 'r'
5623 #define IDX_RP_GEN 'g'
5624 #define IDX_RP_GEN_FUNC_MIN 0xff10
5625 #define IDX_RP_GEN_FUNC_MAX 0xff11
5626 #define IDX_RP_GEN_SEED 0xff34
5627 #define IDX_RULE_BUF_L 'j'
5628 #define IDX_RULE_BUF_R 'k'
5629 #define IDX_INCREMENT 'i'
5630 #define IDX_INCREMENT_MIN 0xff12
5631 #define IDX_INCREMENT_MAX 0xff13
5632 #define IDX_OUTFILE 'o'
5633 #define IDX_OUTFILE_FORMAT 0xff14
5634 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5635 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5636 #define IDX_RESTORE 0xff15
5637 #define IDX_RESTORE_DISABLE 0xff27
5638 #define IDX_STATUS 0xff17
5639 #define IDX_STATUS_TIMER 0xff18
5640 #define IDX_MACHINE_READABLE 0xff50
5641 #define IDX_LOOPBACK 0xff38
5642 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5643 #define IDX_SESSION 0xff19
5644 #define IDX_HEX_CHARSET 0xff20
5645 #define IDX_HEX_SALT 0xff21
5646 #define IDX_HEX_WORDLIST 0xff40
5647 #define IDX_MARKOV_DISABLE 0xff22
5648 #define IDX_MARKOV_CLASSIC 0xff23
5649 #define IDX_MARKOV_THRESHOLD 't'
5650 #define IDX_MARKOV_HCSTAT 0xff24
5651 #define IDX_CPU_AFFINITY 0xff25
5652 #define IDX_OPENCL_DEVICES 'd'
5653 #define IDX_OPENCL_PLATFORMS 0xff72
5654 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5655 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5656 #define IDX_WORKLOAD_PROFILE 'w'
5657 #define IDX_KERNEL_ACCEL 'n'
5658 #define IDX_KERNEL_LOOPS 'u'
5659 #define IDX_GPU_TEMP_DISABLE 0xff29
5660 #define IDX_GPU_TEMP_ABORT 0xff30
5661 #define IDX_GPU_TEMP_RETAIN 0xff31
5662 #define IDX_POWERTUNE_ENABLE 0xff41
5663 #define IDX_LOGFILE_DISABLE 0xff51
5664 #define IDX_TRUECRYPT_KEYFILES 0xff52
5665 #define IDX_VERACRYPT_KEYFILES 0xff53
5666 #define IDX_VERACRYPT_PIM 0xff54
5667 #define IDX_SCRYPT_TMTO 0xff61
5668 #define IDX_SEGMENT_SIZE 'c'
5669 #define IDX_SEPARATOR 'p'
5670 #define IDX_BITMAP_MIN 0xff70
5671 #define IDX_BITMAP_MAX 0xff71
5672 #define IDX_CUSTOM_CHARSET_1 '1'
5673 #define IDX_CUSTOM_CHARSET_2 '2'
5674 #define IDX_CUSTOM_CHARSET_3 '3'
5675 #define IDX_CUSTOM_CHARSET_4 '4'
5676
5677 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5678
5679 struct option long_options[] =
5680 {
5681 {"help", no_argument, 0, IDX_HELP},
5682 {"version", no_argument, 0, IDX_VERSION},
5683 {"quiet", no_argument, 0, IDX_QUIET},
5684 {"show", no_argument, 0, IDX_SHOW},
5685 {"left", no_argument, 0, IDX_LEFT},
5686 {"username", no_argument, 0, IDX_USERNAME},
5687 {"remove", no_argument, 0, IDX_REMOVE},
5688 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5689 {"skip", required_argument, 0, IDX_SKIP},
5690 {"limit", required_argument, 0, IDX_LIMIT},
5691 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5692 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5693 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5694 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5695 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5696 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5697 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5698 {"force", no_argument, 0, IDX_FORCE},
5699 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5700 {"restore", no_argument, 0, IDX_RESTORE},
5701 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5702 {"status", no_argument, 0, IDX_STATUS},
5703 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5704 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5705 {"loopback", no_argument, 0, IDX_LOOPBACK},
5706 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5707 {"session", required_argument, 0, IDX_SESSION},
5708 {"runtime", required_argument, 0, IDX_RUNTIME},
5709 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5710 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5711 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5712 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5713 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5714 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5715 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5716 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5717 {"rules-file", required_argument, 0, IDX_RP_FILE},
5718 {"outfile", required_argument, 0, IDX_OUTFILE},
5719 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5720 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5721 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5722 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5723 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5724 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5725 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5726 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5727 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5728 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5729 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5730 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5731 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5732 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5733 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5734 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5735 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5736 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5737 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5738 #ifdef HAVE_HWMON
5739 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5740 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5741 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5742 #endif // HAVE_HWMON
5743 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5744 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5745 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5746 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5747 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5748 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5749 {"seperator", required_argument, 0, IDX_SEPARATOR},
5750 {"separator", required_argument, 0, IDX_SEPARATOR},
5751 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5752 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5753 {"increment", no_argument, 0, IDX_INCREMENT},
5754 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5755 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5756 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5757 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5758 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5759 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5760 {0, 0, 0, 0}
5761 };
5762
5763 uint rp_files_cnt = 0;
5764
5765 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5766
5767 int option_index = 0;
5768 int c = -1;
5769
5770 optind = 1;
5771 optopt = 0;
5772
5773 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5774 {
5775 switch (c)
5776 {
5777 case IDX_HELP: usage = 1; break;
5778 case IDX_VERSION:
5779 case IDX_VERSION_LOWER: version = 1; break;
5780 case IDX_RESTORE: restore = 1; break;
5781 case IDX_SESSION: session = optarg; break;
5782 case IDX_SHOW: show = 1; break;
5783 case IDX_LEFT: left = 1; break;
5784 case '?': return (-1);
5785 }
5786 }
5787
5788 if (optopt != 0)
5789 {
5790 log_error ("ERROR: Invalid argument specified");
5791
5792 return (-1);
5793 }
5794
5795 /**
5796 * exit functions
5797 */
5798
5799 if (version)
5800 {
5801 log_info ("%s", VERSION_TAG);
5802
5803 return (0);
5804 }
5805
5806 if (usage)
5807 {
5808 usage_big_print (PROGNAME);
5809
5810 return (0);
5811 }
5812
5813 /**
5814 * session needs to be set, always!
5815 */
5816
5817 if (session == NULL) session = (char *) PROGNAME;
5818
5819 /**
5820 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5821 */
5822
5823 char *exec_path = get_exec_path ();
5824
5825 #ifdef LINUX
5826
5827 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5828 char *resolved_exec_path = realpath (exec_path, NULL);
5829
5830 char *install_dir = get_install_dir (resolved_exec_path);
5831 char *profile_dir = NULL;
5832 char *session_dir = NULL;
5833 char *shared_dir = NULL;
5834
5835 if (strcmp (install_dir, resolved_install_folder) == 0)
5836 {
5837 struct passwd *pw = getpwuid (getuid ());
5838
5839 const char *homedir = pw->pw_dir;
5840
5841 profile_dir = get_profile_dir (homedir);
5842 session_dir = get_session_dir (profile_dir);
5843 shared_dir = strdup (SHARED_FOLDER);
5844
5845 mkdir (profile_dir, 0700);
5846 mkdir (session_dir, 0700);
5847 }
5848 else
5849 {
5850 profile_dir = install_dir;
5851 session_dir = install_dir;
5852 shared_dir = install_dir;
5853 }
5854
5855 myfree (resolved_install_folder);
5856 myfree (resolved_exec_path);
5857
5858 #else
5859
5860 char *install_dir = get_install_dir (exec_path);
5861 char *profile_dir = install_dir;
5862 char *session_dir = install_dir;
5863 char *shared_dir = install_dir;
5864
5865 #endif
5866
5867 data.install_dir = install_dir;
5868 data.profile_dir = profile_dir;
5869 data.session_dir = session_dir;
5870 data.shared_dir = shared_dir;
5871
5872 myfree (exec_path);
5873
5874 /**
5875 * kernel cache, we need to make sure folder exist
5876 */
5877
5878 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5879
5880 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5881
5882 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5883
5884 mkdir (kernels_folder, 0700);
5885
5886 myfree (kernels_folder);
5887
5888 /**
5889 * session
5890 */
5891
5892 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5893
5894 data.session = session;
5895
5896 char *eff_restore_file = (char *) mymalloc (session_size);
5897 char *new_restore_file = (char *) mymalloc (session_size);
5898
5899 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5900 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5901
5902 data.eff_restore_file = eff_restore_file;
5903 data.new_restore_file = new_restore_file;
5904
5905 if (((show == 1) || (left == 1)) && (restore == 1))
5906 {
5907 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5908 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5909
5910 return (-1);
5911 }
5912
5913 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5914 if ((show == 1) || (left == 1))
5915 {
5916 restore_disable = 1;
5917
5918 restore = 0;
5919 }
5920
5921 data.restore_disable = restore_disable;
5922
5923 restore_data_t *rd = init_restore (argc, argv);
5924
5925 data.rd = rd;
5926
5927 /**
5928 * restore file
5929 */
5930
5931 if (restore == 1)
5932 {
5933 read_restore (eff_restore_file, rd);
5934
5935 if (rd->version_bin < RESTORE_MIN)
5936 {
5937 log_error ("ERROR: Incompatible restore-file version");
5938
5939 return (-1);
5940 }
5941
5942 myargc = rd->argc;
5943 myargv = rd->argv;
5944
5945 #ifdef _POSIX
5946 rd->pid = getpid ();
5947 #elif _WIN
5948 rd->pid = GetCurrentProcessId ();
5949 #endif
5950 }
5951
5952 uint hash_mode_chgd = 0;
5953 uint runtime_chgd = 0;
5954 uint kernel_loops_chgd = 0;
5955 uint kernel_accel_chgd = 0;
5956 uint attack_mode_chgd = 0;
5957 uint outfile_format_chgd = 0;
5958 uint rp_gen_seed_chgd = 0;
5959 uint remove_timer_chgd = 0;
5960 uint increment_min_chgd = 0;
5961 uint increment_max_chgd = 0;
5962 uint workload_profile_chgd = 0;
5963 uint opencl_vector_width_chgd = 0;
5964
5965 optind = 1;
5966 optopt = 0;
5967 option_index = 0;
5968
5969 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5970 {
5971 switch (c)
5972 {
5973 //case IDX_HELP: usage = 1; break;
5974 //case IDX_VERSION: version = 1; break;
5975 //case IDX_RESTORE: restore = 1; break;
5976 case IDX_QUIET: quiet = 1; break;
5977 //case IDX_SHOW: show = 1; break;
5978 case IDX_SHOW: break;
5979 //case IDX_LEFT: left = 1; break;
5980 case IDX_LEFT: break;
5981 case IDX_USERNAME: username = 1; break;
5982 case IDX_REMOVE: remove = 1; break;
5983 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5984 remove_timer_chgd = 1; break;
5985 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5986 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5987 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5988 case IDX_DEBUG_FILE: debug_file = optarg; break;
5989 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5990 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5991 case IDX_FORCE: force = 1; break;
5992 case IDX_SKIP: skip = atoll (optarg); break;
5993 case IDX_LIMIT: limit = atoll (optarg); break;
5994 case IDX_KEYSPACE: keyspace = 1; break;
5995 case IDX_BENCHMARK: benchmark = 1; break;
5996 case IDX_RESTORE: break;
5997 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5998 case IDX_STATUS: status = 1; break;
5999 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6000 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6001 case IDX_LOOPBACK: loopback = 1; break;
6002 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6003 //case IDX_SESSION: session = optarg; break;
6004 case IDX_SESSION: break;
6005 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6006 hash_mode_chgd = 1; break;
6007 case IDX_RUNTIME: runtime = atoi (optarg);
6008 runtime_chgd = 1; break;
6009 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6010 attack_mode_chgd = 1; break;
6011 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6012 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6013 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6014 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6015 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6016 rp_gen_seed_chgd = 1; break;
6017 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6018 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6019 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6020 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6021 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6022 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6023 case IDX_OUTFILE: outfile = optarg; break;
6024 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6025 outfile_format_chgd = 1; break;
6026 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6027 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6028 case IDX_HEX_CHARSET: hex_charset = 1; break;
6029 case IDX_HEX_SALT: hex_salt = 1; break;
6030 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6031 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6032 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6033 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6034 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6035 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6036 opencl_vector_width_chgd = 1; break;
6037 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6038 workload_profile_chgd = 1; break;
6039 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6040 kernel_accel_chgd = 1; break;
6041 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6042 kernel_loops_chgd = 1; break;
6043 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6044 #ifdef HAVE_HWMON
6045 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6046 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6047 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6048 #endif // HAVE_HWMON
6049 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6050 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6051 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6052 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6053 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6054 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6055 case IDX_SEPARATOR: separator = optarg[0]; break;
6056 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6057 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6058 case IDX_INCREMENT: increment = 1; break;
6059 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6060 increment_min_chgd = 1; break;
6061 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6062 increment_max_chgd = 1; break;
6063 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6064 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6065 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6066 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6067
6068 default:
6069 log_error ("ERROR: Invalid argument specified");
6070 return (-1);
6071 }
6072 }
6073
6074 if (optopt != 0)
6075 {
6076 log_error ("ERROR: Invalid argument specified");
6077
6078 return (-1);
6079 }
6080
6081 /**
6082 * Inform user things getting started,
6083 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6084 * - we do not need to check algorithm_pos
6085 */
6086
6087 if (quiet == 0)
6088 {
6089 if (benchmark == 1)
6090 {
6091 if (machine_readable == 0)
6092 {
6093 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6094 log_info ("");
6095 }
6096 else
6097 {
6098 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6099 }
6100 }
6101 else if (restore == 1)
6102 {
6103 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6104 log_info ("");
6105 }
6106 else
6107 {
6108 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6109 log_info ("");
6110 }
6111 }
6112
6113 /**
6114 * sanity check
6115 */
6116
6117 if (attack_mode > 7)
6118 {
6119 log_error ("ERROR: Invalid attack-mode specified");
6120
6121 return (-1);
6122 }
6123
6124 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6125 {
6126 log_error ("ERROR: Invalid runtime specified");
6127
6128 return (-1);
6129 }
6130
6131 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
6132 {
6133 log_error ("ERROR: Invalid hash-type specified");
6134
6135 return (-1);
6136 }
6137
6138 // renamed hash modes
6139
6140 if (hash_mode_chgd)
6141 {
6142 int n = -1;
6143
6144 switch (hash_mode)
6145 {
6146 case 123: n = 124;
6147 break;
6148 }
6149
6150 if (n >= 0)
6151 {
6152 log_error ("Old -m specified, use -m %d instead", n);
6153
6154 return (-1);
6155 }
6156 }
6157
6158 if (username == 1)
6159 {
6160 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6161 {
6162 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6163
6164 return (-1);
6165 }
6166 }
6167
6168 if (outfile_format > 16)
6169 {
6170 log_error ("ERROR: Invalid outfile-format specified");
6171
6172 return (-1);
6173 }
6174
6175 if (left == 1)
6176 {
6177 if (outfile_format_chgd == 1)
6178 {
6179 if (outfile_format > 1)
6180 {
6181 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6182
6183 return (-1);
6184 }
6185 }
6186 else
6187 {
6188 outfile_format = OUTFILE_FMT_HASH;
6189 }
6190 }
6191
6192 if (show == 1)
6193 {
6194 if (outfile_format_chgd == 1)
6195 {
6196 if ((outfile_format > 7) && (outfile_format < 16))
6197 {
6198 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6199
6200 return (-1);
6201 }
6202 }
6203 }
6204
6205 if (increment_min < INCREMENT_MIN)
6206 {
6207 log_error ("ERROR: Invalid increment-min specified");
6208
6209 return (-1);
6210 }
6211
6212 if (increment_max > INCREMENT_MAX)
6213 {
6214 log_error ("ERROR: Invalid increment-max specified");
6215
6216 return (-1);
6217 }
6218
6219 if (increment_min > increment_max)
6220 {
6221 log_error ("ERROR: Invalid increment-min specified");
6222
6223 return (-1);
6224 }
6225
6226 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6227 {
6228 log_error ("ERROR: increment is not allowed in attack-mode 0");
6229
6230 return (-1);
6231 }
6232
6233 if ((increment == 0) && (increment_min_chgd == 1))
6234 {
6235 log_error ("ERROR: increment-min is only supported together with increment switch");
6236
6237 return (-1);
6238 }
6239
6240 if ((increment == 0) && (increment_max_chgd == 1))
6241 {
6242 log_error ("ERROR: increment-max is only supported together with increment switch");
6243
6244 return (-1);
6245 }
6246
6247 if (rp_files_cnt && rp_gen)
6248 {
6249 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6250
6251 return (-1);
6252 }
6253
6254 if (rp_files_cnt || rp_gen)
6255 {
6256 if (attack_mode != ATTACK_MODE_STRAIGHT)
6257 {
6258 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6259
6260 return (-1);
6261 }
6262 }
6263
6264 if (rp_gen_func_min > rp_gen_func_max)
6265 {
6266 log_error ("ERROR: Invalid rp-gen-func-min specified");
6267
6268 return (-1);
6269 }
6270
6271 if (kernel_accel_chgd == 1)
6272 {
6273 if (force == 0)
6274 {
6275 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6276 log_info ("Please consider using the option -w instead");
6277 log_info ("You can use --force to override this but do not post error reports if you do so");
6278 log_info ("");
6279
6280 return (-1);
6281 }
6282
6283 if (kernel_accel < 1)
6284 {
6285 log_error ("ERROR: Invalid kernel-accel specified");
6286
6287 return (-1);
6288 }
6289
6290 if (kernel_accel > 1024)
6291 {
6292 log_error ("ERROR: Invalid kernel-accel specified");
6293
6294 return (-1);
6295 }
6296 }
6297
6298 if (kernel_loops_chgd == 1)
6299 {
6300 if (force == 0)
6301 {
6302 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6303 log_info ("Please consider using the option -w instead");
6304 log_info ("You can use --force to override this but do not post error reports if you do so");
6305 log_info ("");
6306
6307 return (-1);
6308 }
6309
6310 if (kernel_loops < 1)
6311 {
6312 log_error ("ERROR: Invalid kernel-loops specified");
6313
6314 return (-1);
6315 }
6316
6317 if (kernel_loops > 1024)
6318 {
6319 log_error ("ERROR: Invalid kernel-loops specified");
6320
6321 return (-1);
6322 }
6323 }
6324
6325 if ((workload_profile < 1) || (workload_profile > 4))
6326 {
6327 log_error ("ERROR: workload-profile %i not available", workload_profile);
6328
6329 return (-1);
6330 }
6331
6332 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6333 {
6334 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6335
6336 return (-1);
6337 }
6338
6339 if (show == 1 || left == 1)
6340 {
6341 attack_mode = ATTACK_MODE_NONE;
6342
6343 if (remove == 1)
6344 {
6345 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6346
6347 return (-1);
6348 }
6349
6350 if (potfile_disable == 1)
6351 {
6352 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6353
6354 return (-1);
6355 }
6356 }
6357
6358 uint attack_kern = ATTACK_KERN_NONE;
6359
6360 switch (attack_mode)
6361 {
6362 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6363 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6364 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6365 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6366 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6367 }
6368
6369 if (benchmark == 0)
6370 {
6371 if (keyspace == 1)
6372 {
6373 int num_additional_params = 1;
6374
6375 if (attack_kern == ATTACK_KERN_COMBI)
6376 {
6377 num_additional_params = 2;
6378 }
6379
6380 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6381
6382 if (keyspace_wordlist_specified == 0) optind--;
6383 }
6384
6385 if (attack_kern == ATTACK_KERN_NONE)
6386 {
6387 if ((optind + 1) != myargc)
6388 {
6389 usage_mini_print (myargv[0]);
6390
6391 return (-1);
6392 }
6393 }
6394 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6395 {
6396 if ((optind + 1) > myargc)
6397 {
6398 usage_mini_print (myargv[0]);
6399
6400 return (-1);
6401 }
6402 }
6403 else if (attack_kern == ATTACK_KERN_COMBI)
6404 {
6405 if ((optind + 3) != myargc)
6406 {
6407 usage_mini_print (myargv[0]);
6408
6409 return (-1);
6410 }
6411 }
6412 else if (attack_kern == ATTACK_KERN_BF)
6413 {
6414 if ((optind + 1) > myargc)
6415 {
6416 usage_mini_print (myargv[0]);
6417
6418 return (-1);
6419 }
6420 }
6421 else
6422 {
6423 usage_mini_print (myargv[0]);
6424
6425 return (-1);
6426 }
6427 }
6428 else
6429 {
6430 if (myargv[optind] != 0)
6431 {
6432 log_error ("ERROR: Invalid argument for benchmark mode specified");
6433
6434 return (-1);
6435 }
6436
6437 if (attack_mode_chgd == 1)
6438 {
6439 if (attack_mode != ATTACK_MODE_BF)
6440 {
6441 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6442
6443 return (-1);
6444 }
6445 }
6446 }
6447
6448 if (skip != 0 && limit != 0)
6449 {
6450 limit += skip;
6451 }
6452
6453 if (keyspace == 1)
6454 {
6455 if (show == 1)
6456 {
6457 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6458
6459 return (-1);
6460 }
6461 else if (left == 1)
6462 {
6463 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6464
6465 return (-1);
6466 }
6467
6468 potfile_disable = 1;
6469
6470 restore_disable = 1;
6471
6472 restore = 0;
6473
6474 weak_hash_threshold = 0;
6475
6476 quiet = 1;
6477 }
6478
6479 if (remove_timer_chgd == 1)
6480 {
6481 if (remove == 0)
6482 {
6483 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6484
6485 return (-1);
6486 }
6487
6488 if (remove_timer < 1)
6489 {
6490 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6491
6492 return (-1);
6493 }
6494 }
6495
6496 if (loopback == 1)
6497 {
6498 if (attack_mode == ATTACK_MODE_STRAIGHT)
6499 {
6500 if ((rp_files_cnt == 0) && (rp_gen == 0))
6501 {
6502 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6503
6504 return (-1);
6505 }
6506 }
6507 else
6508 {
6509 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6510
6511 return (-1);
6512 }
6513 }
6514
6515 if (debug_mode > 0)
6516 {
6517 if (attack_mode != ATTACK_MODE_STRAIGHT)
6518 {
6519 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6520
6521 return (-1);
6522 }
6523
6524 if ((rp_files_cnt == 0) && (rp_gen == 0))
6525 {
6526 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6527
6528 return (-1);
6529 }
6530 }
6531
6532 if (debug_mode > 4)
6533 {
6534 log_error ("ERROR: Invalid debug-mode specified");
6535
6536 return (-1);
6537 }
6538
6539 if (debug_file != NULL)
6540 {
6541 if (debug_mode < 1)
6542 {
6543 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6544
6545 return (-1);
6546 }
6547 }
6548
6549 if (induction_dir != NULL)
6550 {
6551 if (attack_mode == ATTACK_MODE_BF)
6552 {
6553 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6554
6555 return (-1);
6556 }
6557 }
6558
6559 if (attack_mode != ATTACK_MODE_STRAIGHT)
6560 {
6561 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6562 {
6563 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6564
6565 return (-1);
6566 }
6567
6568 weak_hash_threshold = 0;
6569 }
6570
6571 /**
6572 * induction directory
6573 */
6574
6575 char *induction_directory = NULL;
6576
6577 if (attack_mode != ATTACK_MODE_BF)
6578 {
6579 if (induction_dir == NULL)
6580 {
6581 induction_directory = (char *) mymalloc (session_size);
6582
6583 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6584
6585 // create induction folder if it does not already exist
6586
6587 if (keyspace == 0)
6588 {
6589 if (rmdir (induction_directory) == -1)
6590 {
6591 if (errno == ENOENT)
6592 {
6593 // good, we can ignore
6594 }
6595 else if (errno == ENOTEMPTY)
6596 {
6597 char *induction_directory_mv = (char *) mymalloc (session_size);
6598
6599 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6600
6601 if (rename (induction_directory, induction_directory_mv) != 0)
6602 {
6603 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6604
6605 return (-1);
6606 }
6607 }
6608 else
6609 {
6610 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6611
6612 return (-1);
6613 }
6614 }
6615
6616 if (mkdir (induction_directory, 0700) == -1)
6617 {
6618 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6619
6620 return (-1);
6621 }
6622 }
6623 }
6624 else
6625 {
6626 induction_directory = induction_dir;
6627 }
6628 }
6629
6630 data.induction_directory = induction_directory;
6631
6632 /**
6633 * loopback
6634 */
6635
6636 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6637
6638 char *loopback_file = (char *) mymalloc (loopback_size);
6639
6640 /**
6641 * tuning db
6642 */
6643
6644 char tuning_db_file[256] = { 0 };
6645
6646 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6647
6648 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6649
6650 /**
6651 * outfile-check directory
6652 */
6653
6654 char *outfile_check_directory = NULL;
6655
6656 if (outfile_check_dir == NULL)
6657 {
6658 outfile_check_directory = (char *) mymalloc (session_size);
6659
6660 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6661 }
6662 else
6663 {
6664 outfile_check_directory = outfile_check_dir;
6665 }
6666
6667 data.outfile_check_directory = outfile_check_directory;
6668
6669 if (keyspace == 0)
6670 {
6671 struct stat outfile_check_stat;
6672
6673 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6674 {
6675 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6676
6677 if (is_dir == 0)
6678 {
6679 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6680
6681 return (-1);
6682 }
6683 }
6684 else if (outfile_check_dir == NULL)
6685 {
6686 if (mkdir (outfile_check_directory, 0700) == -1)
6687 {
6688 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6689
6690 return (-1);
6691 }
6692 }
6693 }
6694
6695 /**
6696 * special other stuff
6697 */
6698
6699 if (hash_mode == 9710)
6700 {
6701 outfile_format = 5;
6702 outfile_format_chgd = 1;
6703 }
6704
6705 if (hash_mode == 9810)
6706 {
6707 outfile_format = 5;
6708 outfile_format_chgd = 1;
6709 }
6710
6711 if (hash_mode == 10410)
6712 {
6713 outfile_format = 5;
6714 outfile_format_chgd = 1;
6715 }
6716
6717 /**
6718 * store stuff
6719 */
6720
6721 data.hash_mode = hash_mode;
6722 data.restore = restore;
6723 data.restore_timer = restore_timer;
6724 data.restore_disable = restore_disable;
6725 data.status = status;
6726 data.status_timer = status_timer;
6727 data.machine_readable = machine_readable;
6728 data.loopback = loopback;
6729 data.runtime = runtime;
6730 data.remove = remove;
6731 data.remove_timer = remove_timer;
6732 data.debug_mode = debug_mode;
6733 data.debug_file = debug_file;
6734 data.username = username;
6735 data.quiet = quiet;
6736 data.outfile = outfile;
6737 data.outfile_format = outfile_format;
6738 data.outfile_autohex = outfile_autohex;
6739 data.hex_charset = hex_charset;
6740 data.hex_salt = hex_salt;
6741 data.hex_wordlist = hex_wordlist;
6742 data.separator = separator;
6743 data.rp_files = rp_files;
6744 data.rp_files_cnt = rp_files_cnt;
6745 data.rp_gen = rp_gen;
6746 data.rp_gen_seed = rp_gen_seed;
6747 data.force = force;
6748 data.benchmark = benchmark;
6749 data.skip = skip;
6750 data.limit = limit;
6751 #ifdef HAVE_HWMON
6752 data.powertune_enable = powertune_enable;
6753 #endif
6754 data.logfile_disable = logfile_disable;
6755 data.truecrypt_keyfiles = truecrypt_keyfiles;
6756 data.veracrypt_keyfiles = veracrypt_keyfiles;
6757 data.veracrypt_pim = veracrypt_pim;
6758 data.scrypt_tmto = scrypt_tmto;
6759 data.workload_profile = workload_profile;
6760
6761 /**
6762 * cpu affinity
6763 */
6764
6765 if (cpu_affinity)
6766 {
6767 set_cpu_affinity (cpu_affinity);
6768 }
6769
6770 if (rp_gen_seed_chgd == 0)
6771 {
6772 srand (proc_start);
6773 }
6774 else
6775 {
6776 srand (rp_gen_seed);
6777 }
6778
6779 /**
6780 * logfile init
6781 */
6782
6783 if (logfile_disable == 0)
6784 {
6785 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6786
6787 char *logfile = (char *) mymalloc (logfile_size);
6788
6789 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6790
6791 data.logfile = logfile;
6792
6793 char *topid = logfile_generate_topid ();
6794
6795 data.topid = topid;
6796 }
6797
6798 // logfile_append() checks for logfile_disable internally to make it easier from here
6799
6800 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6801 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6802 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6803 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6804 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6805 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6806 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6807 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6808 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6809 #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));
6810
6811 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6812 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6813 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6814 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6815 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6816 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6817 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6818 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6819
6820 logfile_top_msg ("START");
6821
6822 logfile_top_uint (attack_mode);
6823 logfile_top_uint (attack_kern);
6824 logfile_top_uint (benchmark);
6825 logfile_top_uint (bitmap_min);
6826 logfile_top_uint (bitmap_max);
6827 logfile_top_uint (debug_mode);
6828 logfile_top_uint (force);
6829 logfile_top_uint (kernel_accel);
6830 logfile_top_uint (kernel_loops);
6831 logfile_top_uint (gpu_temp_disable);
6832 #ifdef HAVE_HWMON
6833 logfile_top_uint (gpu_temp_abort);
6834 logfile_top_uint (gpu_temp_retain);
6835 #endif
6836 logfile_top_uint (hash_mode);
6837 logfile_top_uint (hex_charset);
6838 logfile_top_uint (hex_salt);
6839 logfile_top_uint (hex_wordlist);
6840 logfile_top_uint (increment);
6841 logfile_top_uint (increment_max);
6842 logfile_top_uint (increment_min);
6843 logfile_top_uint (keyspace);
6844 logfile_top_uint (left);
6845 logfile_top_uint (logfile_disable);
6846 logfile_top_uint (loopback);
6847 logfile_top_uint (markov_classic);
6848 logfile_top_uint (markov_disable);
6849 logfile_top_uint (markov_threshold);
6850 logfile_top_uint (outfile_autohex);
6851 logfile_top_uint (outfile_check_timer);
6852 logfile_top_uint (outfile_format);
6853 logfile_top_uint (potfile_disable);
6854 logfile_top_string (potfile_path);
6855 #if defined(HAVE_HWMON)
6856 logfile_top_uint (powertune_enable);
6857 #endif
6858 logfile_top_uint (scrypt_tmto);
6859 logfile_top_uint (quiet);
6860 logfile_top_uint (remove);
6861 logfile_top_uint (remove_timer);
6862 logfile_top_uint (restore);
6863 logfile_top_uint (restore_disable);
6864 logfile_top_uint (restore_timer);
6865 logfile_top_uint (rp_gen);
6866 logfile_top_uint (rp_gen_func_max);
6867 logfile_top_uint (rp_gen_func_min);
6868 logfile_top_uint (rp_gen_seed);
6869 logfile_top_uint (runtime);
6870 logfile_top_uint (segment_size);
6871 logfile_top_uint (show);
6872 logfile_top_uint (status);
6873 logfile_top_uint (machine_readable);
6874 logfile_top_uint (status_timer);
6875 logfile_top_uint (usage);
6876 logfile_top_uint (username);
6877 logfile_top_uint (version);
6878 logfile_top_uint (weak_hash_threshold);
6879 logfile_top_uint (workload_profile);
6880 logfile_top_uint64 (limit);
6881 logfile_top_uint64 (skip);
6882 logfile_top_char (separator);
6883 logfile_top_string (cpu_affinity);
6884 logfile_top_string (custom_charset_1);
6885 logfile_top_string (custom_charset_2);
6886 logfile_top_string (custom_charset_3);
6887 logfile_top_string (custom_charset_4);
6888 logfile_top_string (debug_file);
6889 logfile_top_string (opencl_devices);
6890 logfile_top_string (opencl_platforms);
6891 logfile_top_string (opencl_device_types);
6892 logfile_top_uint (opencl_vector_width);
6893 logfile_top_string (induction_dir);
6894 logfile_top_string (markov_hcstat);
6895 logfile_top_string (outfile);
6896 logfile_top_string (outfile_check_dir);
6897 logfile_top_string (rule_buf_l);
6898 logfile_top_string (rule_buf_r);
6899 logfile_top_string (session);
6900 logfile_top_string (truecrypt_keyfiles);
6901 logfile_top_string (veracrypt_keyfiles);
6902 logfile_top_uint (veracrypt_pim);
6903
6904 /**
6905 * Init OpenCL library loader
6906 */
6907
6908 if (keyspace == 0)
6909 {
6910 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6911
6912 ocl_init (ocl);
6913
6914 data.ocl = ocl;
6915 }
6916
6917 /**
6918 * OpenCL platform selection
6919 */
6920
6921 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6922
6923 /**
6924 * OpenCL device selection
6925 */
6926
6927 u32 devices_filter = setup_devices_filter (opencl_devices);
6928
6929 /**
6930 * OpenCL device type selection
6931 */
6932
6933 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6934
6935 /**
6936 * benchmark
6937 */
6938
6939 if (benchmark == 1)
6940 {
6941 /**
6942 * disable useless stuff for benchmark
6943 */
6944
6945 status_timer = 0;
6946 restore_timer = 0;
6947 restore_disable = 1;
6948 potfile_disable = 1;
6949 weak_hash_threshold = 0;
6950 gpu_temp_disable = 1;
6951
6952 #ifdef HAVE_HWMON
6953 powertune_enable = 1;
6954 #endif
6955
6956 data.status_timer = status_timer;
6957 data.restore_timer = restore_timer;
6958 data.restore_disable = restore_disable;
6959
6960 /**
6961 * force attack mode to be bruteforce
6962 */
6963
6964 attack_mode = ATTACK_MODE_BF;
6965 attack_kern = ATTACK_KERN_BF;
6966
6967 if (workload_profile_chgd == 0)
6968 {
6969 workload_profile = 3;
6970
6971 data.workload_profile = workload_profile;
6972 }
6973 }
6974
6975 /**
6976 * config
6977 */
6978
6979 uint hash_type = 0;
6980 uint salt_type = 0;
6981 uint attack_exec = 0;
6982 uint opts_type = 0;
6983 uint kern_type = 0;
6984 uint dgst_size = 0;
6985 uint esalt_size = 0;
6986 uint opti_type = 0;
6987 uint dgst_pos0 = -1;
6988 uint dgst_pos1 = -1;
6989 uint dgst_pos2 = -1;
6990 uint dgst_pos3 = -1;
6991
6992 int (*parse_func) (char *, uint, hash_t *);
6993 int (*sort_by_digest) (const void *, const void *);
6994
6995 uint algorithm_pos = 0;
6996 uint algorithm_max = 1;
6997
6998 uint *algorithms = default_benchmark_algorithms;
6999
7000 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7001
7002 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7003 {
7004 /*
7005 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7006 * the following algos are skipped entirely
7007 */
7008
7009 if (algorithm_pos > 0)
7010 {
7011 local_free (rd);
7012
7013 rd = init_restore (argc, argv);
7014
7015 data.rd = rd;
7016 }
7017
7018 /**
7019 * update hash_mode in case of multihash benchmark
7020 */
7021
7022 if (benchmark == 1)
7023 {
7024 if (hash_mode_chgd == 0)
7025 {
7026 hash_mode = algorithms[algorithm_pos];
7027
7028 data.hash_mode = hash_mode;
7029 }
7030
7031 quiet = 1;
7032
7033 data.quiet = quiet;
7034 }
7035
7036 switch (hash_mode)
7037 {
7038 case 0: hash_type = HASH_TYPE_MD5;
7039 salt_type = SALT_TYPE_NONE;
7040 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7041 opts_type = OPTS_TYPE_PT_GENERATE_LE
7042 | OPTS_TYPE_PT_ADD80
7043 | OPTS_TYPE_PT_ADDBITS14;
7044 kern_type = KERN_TYPE_MD5;
7045 dgst_size = DGST_SIZE_4_4;
7046 parse_func = md5_parse_hash;
7047 sort_by_digest = sort_by_digest_4_4;
7048 opti_type = OPTI_TYPE_ZERO_BYTE
7049 | OPTI_TYPE_PRECOMPUTE_INIT
7050 | OPTI_TYPE_PRECOMPUTE_MERKLE
7051 | OPTI_TYPE_MEET_IN_MIDDLE
7052 | OPTI_TYPE_EARLY_SKIP
7053 | OPTI_TYPE_NOT_ITERATED
7054 | OPTI_TYPE_NOT_SALTED
7055 | OPTI_TYPE_RAW_HASH;
7056 dgst_pos0 = 0;
7057 dgst_pos1 = 3;
7058 dgst_pos2 = 2;
7059 dgst_pos3 = 1;
7060 break;
7061
7062 case 10: hash_type = HASH_TYPE_MD5;
7063 salt_type = SALT_TYPE_INTERN;
7064 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7065 opts_type = OPTS_TYPE_PT_GENERATE_LE
7066 | OPTS_TYPE_ST_ADD80
7067 | OPTS_TYPE_ST_ADDBITS14;
7068 kern_type = KERN_TYPE_MD5_PWSLT;
7069 dgst_size = DGST_SIZE_4_4;
7070 parse_func = md5s_parse_hash;
7071 sort_by_digest = sort_by_digest_4_4;
7072 opti_type = OPTI_TYPE_ZERO_BYTE
7073 | OPTI_TYPE_PRECOMPUTE_INIT
7074 | OPTI_TYPE_PRECOMPUTE_MERKLE
7075 | OPTI_TYPE_MEET_IN_MIDDLE
7076 | OPTI_TYPE_EARLY_SKIP
7077 | OPTI_TYPE_NOT_ITERATED
7078 | OPTI_TYPE_APPENDED_SALT
7079 | OPTI_TYPE_RAW_HASH;
7080 dgst_pos0 = 0;
7081 dgst_pos1 = 3;
7082 dgst_pos2 = 2;
7083 dgst_pos3 = 1;
7084 break;
7085
7086 case 11: hash_type = HASH_TYPE_MD5;
7087 salt_type = SALT_TYPE_INTERN;
7088 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7089 opts_type = OPTS_TYPE_PT_GENERATE_LE
7090 | OPTS_TYPE_ST_ADD80
7091 | OPTS_TYPE_ST_ADDBITS14;
7092 kern_type = KERN_TYPE_MD5_PWSLT;
7093 dgst_size = DGST_SIZE_4_4;
7094 parse_func = joomla_parse_hash;
7095 sort_by_digest = sort_by_digest_4_4;
7096 opti_type = OPTI_TYPE_ZERO_BYTE
7097 | OPTI_TYPE_PRECOMPUTE_INIT
7098 | OPTI_TYPE_PRECOMPUTE_MERKLE
7099 | OPTI_TYPE_MEET_IN_MIDDLE
7100 | OPTI_TYPE_EARLY_SKIP
7101 | OPTI_TYPE_NOT_ITERATED
7102 | OPTI_TYPE_APPENDED_SALT
7103 | OPTI_TYPE_RAW_HASH;
7104 dgst_pos0 = 0;
7105 dgst_pos1 = 3;
7106 dgst_pos2 = 2;
7107 dgst_pos3 = 1;
7108 break;
7109
7110 case 12: hash_type = HASH_TYPE_MD5;
7111 salt_type = SALT_TYPE_INTERN;
7112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7113 opts_type = OPTS_TYPE_PT_GENERATE_LE
7114 | OPTS_TYPE_ST_ADD80
7115 | OPTS_TYPE_ST_ADDBITS14;
7116 kern_type = KERN_TYPE_MD5_PWSLT;
7117 dgst_size = DGST_SIZE_4_4;
7118 parse_func = postgresql_parse_hash;
7119 sort_by_digest = sort_by_digest_4_4;
7120 opti_type = OPTI_TYPE_ZERO_BYTE
7121 | OPTI_TYPE_PRECOMPUTE_INIT
7122 | OPTI_TYPE_PRECOMPUTE_MERKLE
7123 | OPTI_TYPE_MEET_IN_MIDDLE
7124 | OPTI_TYPE_EARLY_SKIP
7125 | OPTI_TYPE_NOT_ITERATED
7126 | OPTI_TYPE_APPENDED_SALT
7127 | OPTI_TYPE_RAW_HASH;
7128 dgst_pos0 = 0;
7129 dgst_pos1 = 3;
7130 dgst_pos2 = 2;
7131 dgst_pos3 = 1;
7132 break;
7133
7134 case 20: hash_type = HASH_TYPE_MD5;
7135 salt_type = SALT_TYPE_INTERN;
7136 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7137 opts_type = OPTS_TYPE_PT_GENERATE_LE
7138 | OPTS_TYPE_PT_ADD80
7139 | OPTS_TYPE_PT_ADDBITS14;
7140 kern_type = KERN_TYPE_MD5_SLTPW;
7141 dgst_size = DGST_SIZE_4_4;
7142 parse_func = md5s_parse_hash;
7143 sort_by_digest = sort_by_digest_4_4;
7144 opti_type = OPTI_TYPE_ZERO_BYTE
7145 | OPTI_TYPE_PRECOMPUTE_INIT
7146 | OPTI_TYPE_PRECOMPUTE_MERKLE
7147 | OPTI_TYPE_EARLY_SKIP
7148 | OPTI_TYPE_NOT_ITERATED
7149 | OPTI_TYPE_PREPENDED_SALT
7150 | OPTI_TYPE_RAW_HASH;
7151 dgst_pos0 = 0;
7152 dgst_pos1 = 3;
7153 dgst_pos2 = 2;
7154 dgst_pos3 = 1;
7155 break;
7156
7157 case 21: hash_type = HASH_TYPE_MD5;
7158 salt_type = SALT_TYPE_INTERN;
7159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7160 opts_type = OPTS_TYPE_PT_GENERATE_LE
7161 | OPTS_TYPE_PT_ADD80
7162 | OPTS_TYPE_PT_ADDBITS14;
7163 kern_type = KERN_TYPE_MD5_SLTPW;
7164 dgst_size = DGST_SIZE_4_4;
7165 parse_func = osc_parse_hash;
7166 sort_by_digest = sort_by_digest_4_4;
7167 opti_type = OPTI_TYPE_ZERO_BYTE
7168 | OPTI_TYPE_PRECOMPUTE_INIT
7169 | OPTI_TYPE_PRECOMPUTE_MERKLE
7170 | OPTI_TYPE_EARLY_SKIP
7171 | OPTI_TYPE_NOT_ITERATED
7172 | OPTI_TYPE_PREPENDED_SALT
7173 | OPTI_TYPE_RAW_HASH;
7174 dgst_pos0 = 0;
7175 dgst_pos1 = 3;
7176 dgst_pos2 = 2;
7177 dgst_pos3 = 1;
7178 break;
7179
7180 case 22: hash_type = HASH_TYPE_MD5;
7181 salt_type = SALT_TYPE_EMBEDDED;
7182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7183 opts_type = OPTS_TYPE_PT_GENERATE_LE
7184 | OPTS_TYPE_PT_ADD80
7185 | OPTS_TYPE_PT_ADDBITS14;
7186 kern_type = KERN_TYPE_MD5_SLTPW;
7187 dgst_size = DGST_SIZE_4_4;
7188 parse_func = netscreen_parse_hash;
7189 sort_by_digest = sort_by_digest_4_4;
7190 opti_type = OPTI_TYPE_ZERO_BYTE
7191 | OPTI_TYPE_PRECOMPUTE_INIT
7192 | OPTI_TYPE_PRECOMPUTE_MERKLE
7193 | OPTI_TYPE_EARLY_SKIP
7194 | OPTI_TYPE_NOT_ITERATED
7195 | OPTI_TYPE_PREPENDED_SALT
7196 | OPTI_TYPE_RAW_HASH;
7197 dgst_pos0 = 0;
7198 dgst_pos1 = 3;
7199 dgst_pos2 = 2;
7200 dgst_pos3 = 1;
7201 break;
7202
7203 case 23: hash_type = HASH_TYPE_MD5;
7204 salt_type = SALT_TYPE_EMBEDDED;
7205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7206 opts_type = OPTS_TYPE_PT_GENERATE_LE
7207 | OPTS_TYPE_PT_ADD80
7208 | OPTS_TYPE_PT_ADDBITS14;
7209 kern_type = KERN_TYPE_MD5_SLTPW;
7210 dgst_size = DGST_SIZE_4_4;
7211 parse_func = skype_parse_hash;
7212 sort_by_digest = sort_by_digest_4_4;
7213 opti_type = OPTI_TYPE_ZERO_BYTE
7214 | OPTI_TYPE_PRECOMPUTE_INIT
7215 | OPTI_TYPE_PRECOMPUTE_MERKLE
7216 | OPTI_TYPE_EARLY_SKIP
7217 | OPTI_TYPE_NOT_ITERATED
7218 | OPTI_TYPE_PREPENDED_SALT
7219 | OPTI_TYPE_RAW_HASH;
7220 dgst_pos0 = 0;
7221 dgst_pos1 = 3;
7222 dgst_pos2 = 2;
7223 dgst_pos3 = 1;
7224 break;
7225
7226 case 30: hash_type = HASH_TYPE_MD5;
7227 salt_type = SALT_TYPE_INTERN;
7228 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7229 opts_type = OPTS_TYPE_PT_GENERATE_LE
7230 | OPTS_TYPE_PT_UNICODE
7231 | OPTS_TYPE_ST_ADD80
7232 | OPTS_TYPE_ST_ADDBITS14;
7233 kern_type = KERN_TYPE_MD5_PWUSLT;
7234 dgst_size = DGST_SIZE_4_4;
7235 parse_func = md5s_parse_hash;
7236 sort_by_digest = sort_by_digest_4_4;
7237 opti_type = OPTI_TYPE_ZERO_BYTE
7238 | OPTI_TYPE_PRECOMPUTE_INIT
7239 | OPTI_TYPE_PRECOMPUTE_MERKLE
7240 | OPTI_TYPE_MEET_IN_MIDDLE
7241 | OPTI_TYPE_EARLY_SKIP
7242 | OPTI_TYPE_NOT_ITERATED
7243 | OPTI_TYPE_APPENDED_SALT
7244 | OPTI_TYPE_RAW_HASH;
7245 dgst_pos0 = 0;
7246 dgst_pos1 = 3;
7247 dgst_pos2 = 2;
7248 dgst_pos3 = 1;
7249 break;
7250
7251 case 40: hash_type = HASH_TYPE_MD5;
7252 salt_type = SALT_TYPE_INTERN;
7253 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7254 opts_type = OPTS_TYPE_PT_GENERATE_LE
7255 | OPTS_TYPE_PT_ADD80
7256 | OPTS_TYPE_PT_ADDBITS14
7257 | OPTS_TYPE_PT_UNICODE;
7258 kern_type = KERN_TYPE_MD5_SLTPWU;
7259 dgst_size = DGST_SIZE_4_4;
7260 parse_func = md5s_parse_hash;
7261 sort_by_digest = sort_by_digest_4_4;
7262 opti_type = OPTI_TYPE_ZERO_BYTE
7263 | OPTI_TYPE_PRECOMPUTE_INIT
7264 | OPTI_TYPE_PRECOMPUTE_MERKLE
7265 | OPTI_TYPE_EARLY_SKIP
7266 | OPTI_TYPE_NOT_ITERATED
7267 | OPTI_TYPE_PREPENDED_SALT
7268 | OPTI_TYPE_RAW_HASH;
7269 dgst_pos0 = 0;
7270 dgst_pos1 = 3;
7271 dgst_pos2 = 2;
7272 dgst_pos3 = 1;
7273 break;
7274
7275 case 50: hash_type = HASH_TYPE_MD5;
7276 salt_type = SALT_TYPE_INTERN;
7277 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7278 opts_type = OPTS_TYPE_PT_GENERATE_LE
7279 | OPTS_TYPE_ST_ADD80
7280 | OPTS_TYPE_ST_ADDBITS14;
7281 kern_type = KERN_TYPE_HMACMD5_PW;
7282 dgst_size = DGST_SIZE_4_4;
7283 parse_func = hmacmd5_parse_hash;
7284 sort_by_digest = sort_by_digest_4_4;
7285 opti_type = OPTI_TYPE_ZERO_BYTE
7286 | OPTI_TYPE_NOT_ITERATED;
7287 dgst_pos0 = 0;
7288 dgst_pos1 = 3;
7289 dgst_pos2 = 2;
7290 dgst_pos3 = 1;
7291 break;
7292
7293 case 60: hash_type = HASH_TYPE_MD5;
7294 salt_type = SALT_TYPE_INTERN;
7295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7296 opts_type = OPTS_TYPE_PT_GENERATE_LE
7297 | OPTS_TYPE_PT_ADD80
7298 | OPTS_TYPE_PT_ADDBITS14;
7299 kern_type = KERN_TYPE_HMACMD5_SLT;
7300 dgst_size = DGST_SIZE_4_4;
7301 parse_func = hmacmd5_parse_hash;
7302 sort_by_digest = sort_by_digest_4_4;
7303 opti_type = OPTI_TYPE_ZERO_BYTE
7304 | OPTI_TYPE_NOT_ITERATED;
7305 dgst_pos0 = 0;
7306 dgst_pos1 = 3;
7307 dgst_pos2 = 2;
7308 dgst_pos3 = 1;
7309 break;
7310
7311 case 100: hash_type = HASH_TYPE_SHA1;
7312 salt_type = SALT_TYPE_NONE;
7313 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7314 opts_type = OPTS_TYPE_PT_GENERATE_BE
7315 | OPTS_TYPE_PT_ADD80
7316 | OPTS_TYPE_PT_ADDBITS15;
7317 kern_type = KERN_TYPE_SHA1;
7318 dgst_size = DGST_SIZE_4_5;
7319 parse_func = sha1_parse_hash;
7320 sort_by_digest = sort_by_digest_4_5;
7321 opti_type = OPTI_TYPE_ZERO_BYTE
7322 | OPTI_TYPE_PRECOMPUTE_INIT
7323 | OPTI_TYPE_PRECOMPUTE_MERKLE
7324 | OPTI_TYPE_EARLY_SKIP
7325 | OPTI_TYPE_NOT_ITERATED
7326 | OPTI_TYPE_NOT_SALTED
7327 | OPTI_TYPE_RAW_HASH;
7328 dgst_pos0 = 3;
7329 dgst_pos1 = 4;
7330 dgst_pos2 = 2;
7331 dgst_pos3 = 1;
7332 break;
7333
7334 case 101: hash_type = HASH_TYPE_SHA1;
7335 salt_type = SALT_TYPE_NONE;
7336 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7337 opts_type = OPTS_TYPE_PT_GENERATE_BE
7338 | OPTS_TYPE_PT_ADD80
7339 | OPTS_TYPE_PT_ADDBITS15;
7340 kern_type = KERN_TYPE_SHA1;
7341 dgst_size = DGST_SIZE_4_5;
7342 parse_func = sha1b64_parse_hash;
7343 sort_by_digest = sort_by_digest_4_5;
7344 opti_type = OPTI_TYPE_ZERO_BYTE
7345 | OPTI_TYPE_PRECOMPUTE_INIT
7346 | OPTI_TYPE_PRECOMPUTE_MERKLE
7347 | OPTI_TYPE_EARLY_SKIP
7348 | OPTI_TYPE_NOT_ITERATED
7349 | OPTI_TYPE_NOT_SALTED
7350 | OPTI_TYPE_RAW_HASH;
7351 dgst_pos0 = 3;
7352 dgst_pos1 = 4;
7353 dgst_pos2 = 2;
7354 dgst_pos3 = 1;
7355 break;
7356
7357 case 110: hash_type = HASH_TYPE_SHA1;
7358 salt_type = SALT_TYPE_INTERN;
7359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7360 opts_type = OPTS_TYPE_PT_GENERATE_BE
7361 | OPTS_TYPE_ST_ADD80
7362 | OPTS_TYPE_ST_ADDBITS15;
7363 kern_type = KERN_TYPE_SHA1_PWSLT;
7364 dgst_size = DGST_SIZE_4_5;
7365 parse_func = sha1s_parse_hash;
7366 sort_by_digest = sort_by_digest_4_5;
7367 opti_type = OPTI_TYPE_ZERO_BYTE
7368 | OPTI_TYPE_PRECOMPUTE_INIT
7369 | OPTI_TYPE_PRECOMPUTE_MERKLE
7370 | OPTI_TYPE_EARLY_SKIP
7371 | OPTI_TYPE_NOT_ITERATED
7372 | OPTI_TYPE_APPENDED_SALT
7373 | OPTI_TYPE_RAW_HASH;
7374 dgst_pos0 = 3;
7375 dgst_pos1 = 4;
7376 dgst_pos2 = 2;
7377 dgst_pos3 = 1;
7378 break;
7379
7380 case 111: hash_type = HASH_TYPE_SHA1;
7381 salt_type = SALT_TYPE_EMBEDDED;
7382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7383 opts_type = OPTS_TYPE_PT_GENERATE_BE
7384 | OPTS_TYPE_ST_ADD80
7385 | OPTS_TYPE_ST_ADDBITS15;
7386 kern_type = KERN_TYPE_SHA1_PWSLT;
7387 dgst_size = DGST_SIZE_4_5;
7388 parse_func = sha1b64s_parse_hash;
7389 sort_by_digest = sort_by_digest_4_5;
7390 opti_type = OPTI_TYPE_ZERO_BYTE
7391 | OPTI_TYPE_PRECOMPUTE_INIT
7392 | OPTI_TYPE_PRECOMPUTE_MERKLE
7393 | OPTI_TYPE_EARLY_SKIP
7394 | OPTI_TYPE_NOT_ITERATED
7395 | OPTI_TYPE_APPENDED_SALT
7396 | OPTI_TYPE_RAW_HASH;
7397 dgst_pos0 = 3;
7398 dgst_pos1 = 4;
7399 dgst_pos2 = 2;
7400 dgst_pos3 = 1;
7401 break;
7402
7403 case 112: hash_type = HASH_TYPE_SHA1;
7404 salt_type = SALT_TYPE_INTERN;
7405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7406 opts_type = OPTS_TYPE_PT_GENERATE_BE
7407 | OPTS_TYPE_ST_ADD80
7408 | OPTS_TYPE_ST_ADDBITS15
7409 | OPTS_TYPE_ST_HEX;
7410 kern_type = KERN_TYPE_SHA1_PWSLT;
7411 dgst_size = DGST_SIZE_4_5;
7412 parse_func = oracles_parse_hash;
7413 sort_by_digest = sort_by_digest_4_5;
7414 opti_type = OPTI_TYPE_ZERO_BYTE
7415 | OPTI_TYPE_PRECOMPUTE_INIT
7416 | OPTI_TYPE_PRECOMPUTE_MERKLE
7417 | OPTI_TYPE_EARLY_SKIP
7418 | OPTI_TYPE_NOT_ITERATED
7419 | OPTI_TYPE_APPENDED_SALT
7420 | OPTI_TYPE_RAW_HASH;
7421 dgst_pos0 = 3;
7422 dgst_pos1 = 4;
7423 dgst_pos2 = 2;
7424 dgst_pos3 = 1;
7425 break;
7426
7427 case 120: hash_type = HASH_TYPE_SHA1;
7428 salt_type = SALT_TYPE_INTERN;
7429 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7430 opts_type = OPTS_TYPE_PT_GENERATE_BE
7431 | OPTS_TYPE_PT_ADD80
7432 | OPTS_TYPE_PT_ADDBITS15;
7433 kern_type = KERN_TYPE_SHA1_SLTPW;
7434 dgst_size = DGST_SIZE_4_5;
7435 parse_func = sha1s_parse_hash;
7436 sort_by_digest = sort_by_digest_4_5;
7437 opti_type = OPTI_TYPE_ZERO_BYTE
7438 | OPTI_TYPE_PRECOMPUTE_INIT
7439 | OPTI_TYPE_PRECOMPUTE_MERKLE
7440 | OPTI_TYPE_EARLY_SKIP
7441 | OPTI_TYPE_NOT_ITERATED
7442 | OPTI_TYPE_PREPENDED_SALT
7443 | OPTI_TYPE_RAW_HASH;
7444 dgst_pos0 = 3;
7445 dgst_pos1 = 4;
7446 dgst_pos2 = 2;
7447 dgst_pos3 = 1;
7448 break;
7449
7450 case 121: hash_type = HASH_TYPE_SHA1;
7451 salt_type = SALT_TYPE_INTERN;
7452 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7453 opts_type = OPTS_TYPE_PT_GENERATE_BE
7454 | OPTS_TYPE_PT_ADD80
7455 | OPTS_TYPE_PT_ADDBITS15
7456 | OPTS_TYPE_ST_LOWER;
7457 kern_type = KERN_TYPE_SHA1_SLTPW;
7458 dgst_size = DGST_SIZE_4_5;
7459 parse_func = smf_parse_hash;
7460 sort_by_digest = sort_by_digest_4_5;
7461 opti_type = OPTI_TYPE_ZERO_BYTE
7462 | OPTI_TYPE_PRECOMPUTE_INIT
7463 | OPTI_TYPE_PRECOMPUTE_MERKLE
7464 | OPTI_TYPE_EARLY_SKIP
7465 | OPTI_TYPE_NOT_ITERATED
7466 | OPTI_TYPE_PREPENDED_SALT
7467 | OPTI_TYPE_RAW_HASH;
7468 dgst_pos0 = 3;
7469 dgst_pos1 = 4;
7470 dgst_pos2 = 2;
7471 dgst_pos3 = 1;
7472 break;
7473
7474 case 122: hash_type = HASH_TYPE_SHA1;
7475 salt_type = SALT_TYPE_EMBEDDED;
7476 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7477 opts_type = OPTS_TYPE_PT_GENERATE_BE
7478 | OPTS_TYPE_PT_ADD80
7479 | OPTS_TYPE_PT_ADDBITS15
7480 | OPTS_TYPE_ST_HEX;
7481 kern_type = KERN_TYPE_SHA1_SLTPW;
7482 dgst_size = DGST_SIZE_4_5;
7483 parse_func = osx1_parse_hash;
7484 sort_by_digest = sort_by_digest_4_5;
7485 opti_type = OPTI_TYPE_ZERO_BYTE
7486 | OPTI_TYPE_PRECOMPUTE_INIT
7487 | OPTI_TYPE_PRECOMPUTE_MERKLE
7488 | OPTI_TYPE_EARLY_SKIP
7489 | OPTI_TYPE_NOT_ITERATED
7490 | OPTI_TYPE_PREPENDED_SALT
7491 | OPTI_TYPE_RAW_HASH;
7492 dgst_pos0 = 3;
7493 dgst_pos1 = 4;
7494 dgst_pos2 = 2;
7495 dgst_pos3 = 1;
7496 break;
7497
7498 case 124: hash_type = HASH_TYPE_SHA1;
7499 salt_type = SALT_TYPE_EMBEDDED;
7500 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7501 opts_type = OPTS_TYPE_PT_GENERATE_BE
7502 | OPTS_TYPE_PT_ADD80
7503 | OPTS_TYPE_PT_ADDBITS15;
7504 kern_type = KERN_TYPE_SHA1_SLTPW;
7505 dgst_size = DGST_SIZE_4_5;
7506 parse_func = djangosha1_parse_hash;
7507 sort_by_digest = sort_by_digest_4_5;
7508 opti_type = OPTI_TYPE_ZERO_BYTE
7509 | OPTI_TYPE_PRECOMPUTE_INIT
7510 | OPTI_TYPE_PRECOMPUTE_MERKLE
7511 | OPTI_TYPE_EARLY_SKIP
7512 | OPTI_TYPE_NOT_ITERATED
7513 | OPTI_TYPE_PREPENDED_SALT
7514 | OPTI_TYPE_RAW_HASH;
7515 dgst_pos0 = 3;
7516 dgst_pos1 = 4;
7517 dgst_pos2 = 2;
7518 dgst_pos3 = 1;
7519 break;
7520
7521 case 125: hash_type = HASH_TYPE_SHA1;
7522 salt_type = SALT_TYPE_EMBEDDED;
7523 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7524 opts_type = OPTS_TYPE_PT_GENERATE_BE
7525 | OPTS_TYPE_PT_ADD80
7526 | OPTS_TYPE_PT_ADDBITS15
7527 | OPTS_TYPE_ST_HEX;
7528 kern_type = KERN_TYPE_SHA1_SLTPW;
7529 dgst_size = DGST_SIZE_4_5;
7530 parse_func = arubaos_parse_hash;
7531 sort_by_digest = sort_by_digest_4_5;
7532 opti_type = OPTI_TYPE_ZERO_BYTE
7533 | OPTI_TYPE_PRECOMPUTE_INIT
7534 | OPTI_TYPE_PRECOMPUTE_MERKLE
7535 | OPTI_TYPE_EARLY_SKIP
7536 | OPTI_TYPE_NOT_ITERATED
7537 | OPTI_TYPE_PREPENDED_SALT
7538 | OPTI_TYPE_RAW_HASH;
7539 dgst_pos0 = 3;
7540 dgst_pos1 = 4;
7541 dgst_pos2 = 2;
7542 dgst_pos3 = 1;
7543 break;
7544
7545 case 130: hash_type = HASH_TYPE_SHA1;
7546 salt_type = SALT_TYPE_INTERN;
7547 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7548 opts_type = OPTS_TYPE_PT_GENERATE_BE
7549 | OPTS_TYPE_PT_UNICODE
7550 | OPTS_TYPE_ST_ADD80
7551 | OPTS_TYPE_ST_ADDBITS15;
7552 kern_type = KERN_TYPE_SHA1_PWUSLT;
7553 dgst_size = DGST_SIZE_4_5;
7554 parse_func = sha1s_parse_hash;
7555 sort_by_digest = sort_by_digest_4_5;
7556 opti_type = OPTI_TYPE_ZERO_BYTE
7557 | OPTI_TYPE_PRECOMPUTE_INIT
7558 | OPTI_TYPE_PRECOMPUTE_MERKLE
7559 | OPTI_TYPE_EARLY_SKIP
7560 | OPTI_TYPE_NOT_ITERATED
7561 | OPTI_TYPE_APPENDED_SALT
7562 | OPTI_TYPE_RAW_HASH;
7563 dgst_pos0 = 3;
7564 dgst_pos1 = 4;
7565 dgst_pos2 = 2;
7566 dgst_pos3 = 1;
7567 break;
7568
7569 case 131: hash_type = HASH_TYPE_SHA1;
7570 salt_type = SALT_TYPE_EMBEDDED;
7571 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7572 opts_type = OPTS_TYPE_PT_GENERATE_BE
7573 | OPTS_TYPE_PT_UNICODE
7574 | OPTS_TYPE_PT_UPPER
7575 | OPTS_TYPE_ST_ADD80
7576 | OPTS_TYPE_ST_ADDBITS15
7577 | OPTS_TYPE_ST_HEX;
7578 kern_type = KERN_TYPE_SHA1_PWUSLT;
7579 dgst_size = DGST_SIZE_4_5;
7580 parse_func = mssql2000_parse_hash;
7581 sort_by_digest = sort_by_digest_4_5;
7582 opti_type = OPTI_TYPE_ZERO_BYTE
7583 | OPTI_TYPE_PRECOMPUTE_INIT
7584 | OPTI_TYPE_PRECOMPUTE_MERKLE
7585 | OPTI_TYPE_EARLY_SKIP
7586 | OPTI_TYPE_NOT_ITERATED
7587 | OPTI_TYPE_APPENDED_SALT
7588 | OPTI_TYPE_RAW_HASH;
7589 dgst_pos0 = 3;
7590 dgst_pos1 = 4;
7591 dgst_pos2 = 2;
7592 dgst_pos3 = 1;
7593 break;
7594
7595 case 132: hash_type = HASH_TYPE_SHA1;
7596 salt_type = SALT_TYPE_EMBEDDED;
7597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7598 opts_type = OPTS_TYPE_PT_GENERATE_BE
7599 | OPTS_TYPE_PT_UNICODE
7600 | OPTS_TYPE_ST_ADD80
7601 | OPTS_TYPE_ST_ADDBITS15
7602 | OPTS_TYPE_ST_HEX;
7603 kern_type = KERN_TYPE_SHA1_PWUSLT;
7604 dgst_size = DGST_SIZE_4_5;
7605 parse_func = mssql2005_parse_hash;
7606 sort_by_digest = sort_by_digest_4_5;
7607 opti_type = OPTI_TYPE_ZERO_BYTE
7608 | OPTI_TYPE_PRECOMPUTE_INIT
7609 | OPTI_TYPE_PRECOMPUTE_MERKLE
7610 | OPTI_TYPE_EARLY_SKIP
7611 | OPTI_TYPE_NOT_ITERATED
7612 | OPTI_TYPE_APPENDED_SALT
7613 | OPTI_TYPE_RAW_HASH;
7614 dgst_pos0 = 3;
7615 dgst_pos1 = 4;
7616 dgst_pos2 = 2;
7617 dgst_pos3 = 1;
7618 break;
7619
7620 case 133: hash_type = HASH_TYPE_SHA1;
7621 salt_type = SALT_TYPE_EMBEDDED;
7622 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7623 opts_type = OPTS_TYPE_PT_GENERATE_BE
7624 | OPTS_TYPE_PT_UNICODE
7625 | OPTS_TYPE_ST_ADD80
7626 | OPTS_TYPE_ST_ADDBITS15;
7627 kern_type = KERN_TYPE_SHA1_PWUSLT;
7628 dgst_size = DGST_SIZE_4_5;
7629 parse_func = peoplesoft_parse_hash;
7630 sort_by_digest = sort_by_digest_4_5;
7631 opti_type = OPTI_TYPE_ZERO_BYTE
7632 | OPTI_TYPE_PRECOMPUTE_INIT
7633 | OPTI_TYPE_PRECOMPUTE_MERKLE
7634 | OPTI_TYPE_EARLY_SKIP
7635 | OPTI_TYPE_NOT_ITERATED
7636 | OPTI_TYPE_APPENDED_SALT
7637 | OPTI_TYPE_RAW_HASH;
7638 dgst_pos0 = 3;
7639 dgst_pos1 = 4;
7640 dgst_pos2 = 2;
7641 dgst_pos3 = 1;
7642 break;
7643
7644 case 140: hash_type = HASH_TYPE_SHA1;
7645 salt_type = SALT_TYPE_INTERN;
7646 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7647 opts_type = OPTS_TYPE_PT_GENERATE_BE
7648 | OPTS_TYPE_PT_ADD80
7649 | OPTS_TYPE_PT_ADDBITS15
7650 | OPTS_TYPE_PT_UNICODE;
7651 kern_type = KERN_TYPE_SHA1_SLTPWU;
7652 dgst_size = DGST_SIZE_4_5;
7653 parse_func = sha1s_parse_hash;
7654 sort_by_digest = sort_by_digest_4_5;
7655 opti_type = OPTI_TYPE_ZERO_BYTE
7656 | OPTI_TYPE_PRECOMPUTE_INIT
7657 | OPTI_TYPE_PRECOMPUTE_MERKLE
7658 | OPTI_TYPE_EARLY_SKIP
7659 | OPTI_TYPE_NOT_ITERATED
7660 | OPTI_TYPE_PREPENDED_SALT
7661 | OPTI_TYPE_RAW_HASH;
7662 dgst_pos0 = 3;
7663 dgst_pos1 = 4;
7664 dgst_pos2 = 2;
7665 dgst_pos3 = 1;
7666 break;
7667
7668 case 141: hash_type = HASH_TYPE_SHA1;
7669 salt_type = SALT_TYPE_EMBEDDED;
7670 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7671 opts_type = OPTS_TYPE_PT_GENERATE_BE
7672 | OPTS_TYPE_PT_ADD80
7673 | OPTS_TYPE_PT_ADDBITS15
7674 | OPTS_TYPE_PT_UNICODE
7675 | OPTS_TYPE_ST_BASE64;
7676 kern_type = KERN_TYPE_SHA1_SLTPWU;
7677 dgst_size = DGST_SIZE_4_5;
7678 parse_func = episerver_parse_hash;
7679 sort_by_digest = sort_by_digest_4_5;
7680 opti_type = OPTI_TYPE_ZERO_BYTE
7681 | OPTI_TYPE_PRECOMPUTE_INIT
7682 | OPTI_TYPE_PRECOMPUTE_MERKLE
7683 | OPTI_TYPE_EARLY_SKIP
7684 | OPTI_TYPE_NOT_ITERATED
7685 | OPTI_TYPE_PREPENDED_SALT
7686 | OPTI_TYPE_RAW_HASH;
7687 dgst_pos0 = 3;
7688 dgst_pos1 = 4;
7689 dgst_pos2 = 2;
7690 dgst_pos3 = 1;
7691 break;
7692
7693 case 150: hash_type = HASH_TYPE_SHA1;
7694 salt_type = SALT_TYPE_INTERN;
7695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7696 opts_type = OPTS_TYPE_PT_GENERATE_BE
7697 | OPTS_TYPE_ST_ADD80
7698 | OPTS_TYPE_ST_ADDBITS15;
7699 kern_type = KERN_TYPE_HMACSHA1_PW;
7700 dgst_size = DGST_SIZE_4_5;
7701 parse_func = hmacsha1_parse_hash;
7702 sort_by_digest = sort_by_digest_4_5;
7703 opti_type = OPTI_TYPE_ZERO_BYTE
7704 | OPTI_TYPE_NOT_ITERATED;
7705 dgst_pos0 = 3;
7706 dgst_pos1 = 4;
7707 dgst_pos2 = 2;
7708 dgst_pos3 = 1;
7709 break;
7710
7711 case 160: hash_type = HASH_TYPE_SHA1;
7712 salt_type = SALT_TYPE_INTERN;
7713 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7714 opts_type = OPTS_TYPE_PT_GENERATE_BE
7715 | OPTS_TYPE_PT_ADD80
7716 | OPTS_TYPE_PT_ADDBITS15;
7717 kern_type = KERN_TYPE_HMACSHA1_SLT;
7718 dgst_size = DGST_SIZE_4_5;
7719 parse_func = hmacsha1_parse_hash;
7720 sort_by_digest = sort_by_digest_4_5;
7721 opti_type = OPTI_TYPE_ZERO_BYTE
7722 | OPTI_TYPE_NOT_ITERATED;
7723 dgst_pos0 = 3;
7724 dgst_pos1 = 4;
7725 dgst_pos2 = 2;
7726 dgst_pos3 = 1;
7727 break;
7728
7729 case 190: hash_type = HASH_TYPE_SHA1;
7730 salt_type = SALT_TYPE_NONE;
7731 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7732 opts_type = OPTS_TYPE_PT_GENERATE_BE
7733 | OPTS_TYPE_PT_ADD80
7734 | OPTS_TYPE_PT_ADDBITS15;
7735 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7736 dgst_size = DGST_SIZE_4_5;
7737 parse_func = sha1linkedin_parse_hash;
7738 sort_by_digest = sort_by_digest_4_5;
7739 opti_type = OPTI_TYPE_ZERO_BYTE
7740 | OPTI_TYPE_PRECOMPUTE_INIT
7741 | OPTI_TYPE_EARLY_SKIP
7742 | OPTI_TYPE_NOT_ITERATED
7743 | OPTI_TYPE_NOT_SALTED;
7744 dgst_pos0 = 0;
7745 dgst_pos1 = 4;
7746 dgst_pos2 = 3;
7747 dgst_pos3 = 2;
7748 break;
7749
7750 case 200: hash_type = HASH_TYPE_MYSQL;
7751 salt_type = SALT_TYPE_NONE;
7752 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7753 opts_type = 0;
7754 kern_type = KERN_TYPE_MYSQL;
7755 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7756 parse_func = mysql323_parse_hash;
7757 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7758 opti_type = OPTI_TYPE_ZERO_BYTE;
7759 dgst_pos0 = 0;
7760 dgst_pos1 = 1;
7761 dgst_pos2 = 2;
7762 dgst_pos3 = 3;
7763 break;
7764
7765 case 300: hash_type = HASH_TYPE_SHA1;
7766 salt_type = SALT_TYPE_NONE;
7767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7768 opts_type = OPTS_TYPE_PT_GENERATE_BE
7769 | OPTS_TYPE_PT_ADD80
7770 | OPTS_TYPE_PT_ADDBITS15;
7771 kern_type = KERN_TYPE_MYSQL41;
7772 dgst_size = DGST_SIZE_4_5;
7773 parse_func = sha1_parse_hash;
7774 sort_by_digest = sort_by_digest_4_5;
7775 opti_type = OPTI_TYPE_ZERO_BYTE
7776 | OPTI_TYPE_PRECOMPUTE_INIT
7777 | OPTI_TYPE_PRECOMPUTE_MERKLE
7778 | OPTI_TYPE_EARLY_SKIP
7779 | OPTI_TYPE_NOT_ITERATED
7780 | OPTI_TYPE_NOT_SALTED;
7781 dgst_pos0 = 3;
7782 dgst_pos1 = 4;
7783 dgst_pos2 = 2;
7784 dgst_pos3 = 1;
7785 break;
7786
7787 case 400: hash_type = HASH_TYPE_MD5;
7788 salt_type = SALT_TYPE_EMBEDDED;
7789 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7790 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7791 kern_type = KERN_TYPE_PHPASS;
7792 dgst_size = DGST_SIZE_4_4;
7793 parse_func = phpass_parse_hash;
7794 sort_by_digest = sort_by_digest_4_4;
7795 opti_type = OPTI_TYPE_ZERO_BYTE
7796 | OPTI_TYPE_SLOW_HASH_SIMD;
7797 dgst_pos0 = 0;
7798 dgst_pos1 = 1;
7799 dgst_pos2 = 2;
7800 dgst_pos3 = 3;
7801 break;
7802
7803 case 500: hash_type = HASH_TYPE_MD5;
7804 salt_type = SALT_TYPE_EMBEDDED;
7805 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7806 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7807 kern_type = KERN_TYPE_MD5CRYPT;
7808 dgst_size = DGST_SIZE_4_4;
7809 parse_func = md5crypt_parse_hash;
7810 sort_by_digest = sort_by_digest_4_4;
7811 opti_type = OPTI_TYPE_ZERO_BYTE;
7812 dgst_pos0 = 0;
7813 dgst_pos1 = 1;
7814 dgst_pos2 = 2;
7815 dgst_pos3 = 3;
7816 break;
7817
7818 case 501: hash_type = HASH_TYPE_MD5;
7819 salt_type = SALT_TYPE_EMBEDDED;
7820 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7821 opts_type = OPTS_TYPE_PT_GENERATE_LE
7822 | OPTS_TYPE_HASH_COPY;
7823 kern_type = KERN_TYPE_MD5CRYPT;
7824 dgst_size = DGST_SIZE_4_4;
7825 parse_func = juniper_parse_hash;
7826 sort_by_digest = sort_by_digest_4_4;
7827 opti_type = OPTI_TYPE_ZERO_BYTE;
7828 dgst_pos0 = 0;
7829 dgst_pos1 = 1;
7830 dgst_pos2 = 2;
7831 dgst_pos3 = 3;
7832 break;
7833
7834 case 900: hash_type = HASH_TYPE_MD4;
7835 salt_type = SALT_TYPE_NONE;
7836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7837 opts_type = OPTS_TYPE_PT_GENERATE_LE
7838 | OPTS_TYPE_PT_ADD80
7839 | OPTS_TYPE_PT_ADDBITS14;
7840 kern_type = KERN_TYPE_MD4;
7841 dgst_size = DGST_SIZE_4_4;
7842 parse_func = md4_parse_hash;
7843 sort_by_digest = sort_by_digest_4_4;
7844 opti_type = OPTI_TYPE_ZERO_BYTE
7845 | OPTI_TYPE_PRECOMPUTE_INIT
7846 | OPTI_TYPE_PRECOMPUTE_MERKLE
7847 | OPTI_TYPE_MEET_IN_MIDDLE
7848 | OPTI_TYPE_EARLY_SKIP
7849 | OPTI_TYPE_NOT_ITERATED
7850 | OPTI_TYPE_NOT_SALTED
7851 | OPTI_TYPE_RAW_HASH;
7852 dgst_pos0 = 0;
7853 dgst_pos1 = 3;
7854 dgst_pos2 = 2;
7855 dgst_pos3 = 1;
7856 break;
7857
7858 case 1000: hash_type = HASH_TYPE_MD4;
7859 salt_type = SALT_TYPE_NONE;
7860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7861 opts_type = OPTS_TYPE_PT_GENERATE_LE
7862 | OPTS_TYPE_PT_ADD80
7863 | OPTS_TYPE_PT_ADDBITS14
7864 | OPTS_TYPE_PT_UNICODE;
7865 kern_type = KERN_TYPE_MD4_PWU;
7866 dgst_size = DGST_SIZE_4_4;
7867 parse_func = md4_parse_hash;
7868 sort_by_digest = sort_by_digest_4_4;
7869 opti_type = OPTI_TYPE_ZERO_BYTE
7870 | OPTI_TYPE_PRECOMPUTE_INIT
7871 | OPTI_TYPE_PRECOMPUTE_MERKLE
7872 | OPTI_TYPE_MEET_IN_MIDDLE
7873 | OPTI_TYPE_EARLY_SKIP
7874 | OPTI_TYPE_NOT_ITERATED
7875 | OPTI_TYPE_NOT_SALTED
7876 | OPTI_TYPE_RAW_HASH;
7877 dgst_pos0 = 0;
7878 dgst_pos1 = 3;
7879 dgst_pos2 = 2;
7880 dgst_pos3 = 1;
7881 break;
7882
7883 case 1100: hash_type = HASH_TYPE_MD4;
7884 salt_type = SALT_TYPE_INTERN;
7885 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7886 opts_type = OPTS_TYPE_PT_GENERATE_LE
7887 | OPTS_TYPE_PT_ADD80
7888 | OPTS_TYPE_PT_ADDBITS14
7889 | OPTS_TYPE_PT_UNICODE
7890 | OPTS_TYPE_ST_ADD80
7891 | OPTS_TYPE_ST_UNICODE
7892 | OPTS_TYPE_ST_LOWER;
7893 kern_type = KERN_TYPE_MD44_PWUSLT;
7894 dgst_size = DGST_SIZE_4_4;
7895 parse_func = dcc_parse_hash;
7896 sort_by_digest = sort_by_digest_4_4;
7897 opti_type = OPTI_TYPE_ZERO_BYTE
7898 | OPTI_TYPE_PRECOMPUTE_INIT
7899 | OPTI_TYPE_PRECOMPUTE_MERKLE
7900 | OPTI_TYPE_EARLY_SKIP
7901 | OPTI_TYPE_NOT_ITERATED;
7902 dgst_pos0 = 0;
7903 dgst_pos1 = 3;
7904 dgst_pos2 = 2;
7905 dgst_pos3 = 1;
7906 break;
7907
7908 case 1400: hash_type = HASH_TYPE_SHA256;
7909 salt_type = SALT_TYPE_NONE;
7910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7911 opts_type = OPTS_TYPE_PT_GENERATE_BE
7912 | OPTS_TYPE_PT_ADD80
7913 | OPTS_TYPE_PT_ADDBITS15;
7914 kern_type = KERN_TYPE_SHA256;
7915 dgst_size = DGST_SIZE_4_8;
7916 parse_func = sha256_parse_hash;
7917 sort_by_digest = sort_by_digest_4_8;
7918 opti_type = OPTI_TYPE_ZERO_BYTE
7919 | OPTI_TYPE_PRECOMPUTE_INIT
7920 | OPTI_TYPE_PRECOMPUTE_MERKLE
7921 | OPTI_TYPE_EARLY_SKIP
7922 | OPTI_TYPE_NOT_ITERATED
7923 | OPTI_TYPE_NOT_SALTED
7924 | OPTI_TYPE_RAW_HASH;
7925 dgst_pos0 = 3;
7926 dgst_pos1 = 7;
7927 dgst_pos2 = 2;
7928 dgst_pos3 = 6;
7929 break;
7930
7931 case 1410: hash_type = HASH_TYPE_SHA256;
7932 salt_type = SALT_TYPE_INTERN;
7933 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7934 opts_type = OPTS_TYPE_PT_GENERATE_BE
7935 | OPTS_TYPE_ST_ADD80
7936 | OPTS_TYPE_ST_ADDBITS15;
7937 kern_type = KERN_TYPE_SHA256_PWSLT;
7938 dgst_size = DGST_SIZE_4_8;
7939 parse_func = sha256s_parse_hash;
7940 sort_by_digest = sort_by_digest_4_8;
7941 opti_type = OPTI_TYPE_ZERO_BYTE
7942 | OPTI_TYPE_PRECOMPUTE_INIT
7943 | OPTI_TYPE_PRECOMPUTE_MERKLE
7944 | OPTI_TYPE_EARLY_SKIP
7945 | OPTI_TYPE_NOT_ITERATED
7946 | OPTI_TYPE_APPENDED_SALT
7947 | OPTI_TYPE_RAW_HASH;
7948 dgst_pos0 = 3;
7949 dgst_pos1 = 7;
7950 dgst_pos2 = 2;
7951 dgst_pos3 = 6;
7952 break;
7953
7954 case 1420: hash_type = HASH_TYPE_SHA256;
7955 salt_type = SALT_TYPE_INTERN;
7956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7957 opts_type = OPTS_TYPE_PT_GENERATE_BE
7958 | OPTS_TYPE_PT_ADD80
7959 | OPTS_TYPE_PT_ADDBITS15;
7960 kern_type = KERN_TYPE_SHA256_SLTPW;
7961 dgst_size = DGST_SIZE_4_8;
7962 parse_func = sha256s_parse_hash;
7963 sort_by_digest = sort_by_digest_4_8;
7964 opti_type = OPTI_TYPE_ZERO_BYTE
7965 | OPTI_TYPE_PRECOMPUTE_INIT
7966 | OPTI_TYPE_PRECOMPUTE_MERKLE
7967 | OPTI_TYPE_EARLY_SKIP
7968 | OPTI_TYPE_NOT_ITERATED
7969 | OPTI_TYPE_PREPENDED_SALT
7970 | OPTI_TYPE_RAW_HASH;
7971 dgst_pos0 = 3;
7972 dgst_pos1 = 7;
7973 dgst_pos2 = 2;
7974 dgst_pos3 = 6;
7975 break;
7976
7977 case 1421: hash_type = HASH_TYPE_SHA256;
7978 salt_type = SALT_TYPE_EMBEDDED;
7979 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7980 opts_type = OPTS_TYPE_PT_GENERATE_BE
7981 | OPTS_TYPE_PT_ADD80
7982 | OPTS_TYPE_PT_ADDBITS15;
7983 kern_type = KERN_TYPE_SHA256_SLTPW;
7984 dgst_size = DGST_SIZE_4_8;
7985 parse_func = hmailserver_parse_hash;
7986 sort_by_digest = sort_by_digest_4_8;
7987 opti_type = OPTI_TYPE_ZERO_BYTE
7988 | OPTI_TYPE_PRECOMPUTE_INIT
7989 | OPTI_TYPE_PRECOMPUTE_MERKLE
7990 | OPTI_TYPE_EARLY_SKIP
7991 | OPTI_TYPE_NOT_ITERATED
7992 | OPTI_TYPE_PREPENDED_SALT
7993 | OPTI_TYPE_RAW_HASH;
7994 dgst_pos0 = 3;
7995 dgst_pos1 = 7;
7996 dgst_pos2 = 2;
7997 dgst_pos3 = 6;
7998 break;
7999
8000 case 1430: hash_type = HASH_TYPE_SHA256;
8001 salt_type = SALT_TYPE_INTERN;
8002 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8003 opts_type = OPTS_TYPE_PT_GENERATE_BE
8004 | OPTS_TYPE_PT_UNICODE
8005 | OPTS_TYPE_ST_ADD80
8006 | OPTS_TYPE_ST_ADDBITS15;
8007 kern_type = KERN_TYPE_SHA256_PWUSLT;
8008 dgst_size = DGST_SIZE_4_8;
8009 parse_func = sha256s_parse_hash;
8010 sort_by_digest = sort_by_digest_4_8;
8011 opti_type = OPTI_TYPE_ZERO_BYTE
8012 | OPTI_TYPE_PRECOMPUTE_INIT
8013 | OPTI_TYPE_PRECOMPUTE_MERKLE
8014 | OPTI_TYPE_EARLY_SKIP
8015 | OPTI_TYPE_NOT_ITERATED
8016 | OPTI_TYPE_APPENDED_SALT
8017 | OPTI_TYPE_RAW_HASH;
8018 dgst_pos0 = 3;
8019 dgst_pos1 = 7;
8020 dgst_pos2 = 2;
8021 dgst_pos3 = 6;
8022 break;
8023
8024 case 1440: hash_type = HASH_TYPE_SHA256;
8025 salt_type = SALT_TYPE_INTERN;
8026 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8027 opts_type = OPTS_TYPE_PT_GENERATE_BE
8028 | OPTS_TYPE_PT_ADD80
8029 | OPTS_TYPE_PT_ADDBITS15
8030 | OPTS_TYPE_PT_UNICODE;
8031 kern_type = KERN_TYPE_SHA256_SLTPWU;
8032 dgst_size = DGST_SIZE_4_8;
8033 parse_func = sha256s_parse_hash;
8034 sort_by_digest = sort_by_digest_4_8;
8035 opti_type = OPTI_TYPE_ZERO_BYTE
8036 | OPTI_TYPE_PRECOMPUTE_INIT
8037 | OPTI_TYPE_PRECOMPUTE_MERKLE
8038 | OPTI_TYPE_EARLY_SKIP
8039 | OPTI_TYPE_NOT_ITERATED
8040 | OPTI_TYPE_PREPENDED_SALT
8041 | OPTI_TYPE_RAW_HASH;
8042 dgst_pos0 = 3;
8043 dgst_pos1 = 7;
8044 dgst_pos2 = 2;
8045 dgst_pos3 = 6;
8046 break;
8047
8048 case 1441: hash_type = HASH_TYPE_SHA256;
8049 salt_type = SALT_TYPE_EMBEDDED;
8050 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8051 opts_type = OPTS_TYPE_PT_GENERATE_BE
8052 | OPTS_TYPE_PT_ADD80
8053 | OPTS_TYPE_PT_ADDBITS15
8054 | OPTS_TYPE_PT_UNICODE
8055 | OPTS_TYPE_ST_BASE64;
8056 kern_type = KERN_TYPE_SHA256_SLTPWU;
8057 dgst_size = DGST_SIZE_4_8;
8058 parse_func = episerver4_parse_hash;
8059 sort_by_digest = sort_by_digest_4_8;
8060 opti_type = OPTI_TYPE_ZERO_BYTE
8061 | OPTI_TYPE_PRECOMPUTE_INIT
8062 | OPTI_TYPE_PRECOMPUTE_MERKLE
8063 | OPTI_TYPE_EARLY_SKIP
8064 | OPTI_TYPE_NOT_ITERATED
8065 | OPTI_TYPE_PREPENDED_SALT
8066 | OPTI_TYPE_RAW_HASH;
8067 dgst_pos0 = 3;
8068 dgst_pos1 = 7;
8069 dgst_pos2 = 2;
8070 dgst_pos3 = 6;
8071 break;
8072
8073 case 1450: hash_type = HASH_TYPE_SHA256;
8074 salt_type = SALT_TYPE_INTERN;
8075 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8076 opts_type = OPTS_TYPE_PT_GENERATE_BE
8077 | OPTS_TYPE_ST_ADD80;
8078 kern_type = KERN_TYPE_HMACSHA256_PW;
8079 dgst_size = DGST_SIZE_4_8;
8080 parse_func = hmacsha256_parse_hash;
8081 sort_by_digest = sort_by_digest_4_8;
8082 opti_type = OPTI_TYPE_ZERO_BYTE
8083 | OPTI_TYPE_NOT_ITERATED;
8084 dgst_pos0 = 3;
8085 dgst_pos1 = 7;
8086 dgst_pos2 = 2;
8087 dgst_pos3 = 6;
8088 break;
8089
8090 case 1460: hash_type = HASH_TYPE_SHA256;
8091 salt_type = SALT_TYPE_INTERN;
8092 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8093 opts_type = OPTS_TYPE_PT_GENERATE_BE
8094 | OPTS_TYPE_PT_ADD80
8095 | OPTS_TYPE_PT_ADDBITS15;
8096 kern_type = KERN_TYPE_HMACSHA256_SLT;
8097 dgst_size = DGST_SIZE_4_8;
8098 parse_func = hmacsha256_parse_hash;
8099 sort_by_digest = sort_by_digest_4_8;
8100 opti_type = OPTI_TYPE_ZERO_BYTE
8101 | OPTI_TYPE_NOT_ITERATED;
8102 dgst_pos0 = 3;
8103 dgst_pos1 = 7;
8104 dgst_pos2 = 2;
8105 dgst_pos3 = 6;
8106 break;
8107
8108 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8109 salt_type = SALT_TYPE_EMBEDDED;
8110 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8111 opts_type = OPTS_TYPE_PT_GENERATE_LE
8112 | OPTS_TYPE_PT_BITSLICE;
8113 kern_type = KERN_TYPE_DESCRYPT;
8114 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8115 parse_func = descrypt_parse_hash;
8116 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8117 opti_type = OPTI_TYPE_ZERO_BYTE
8118 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8119 dgst_pos0 = 0;
8120 dgst_pos1 = 1;
8121 dgst_pos2 = 2;
8122 dgst_pos3 = 3;
8123 break;
8124
8125 case 1600: hash_type = HASH_TYPE_MD5;
8126 salt_type = SALT_TYPE_EMBEDDED;
8127 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8128 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8129 kern_type = KERN_TYPE_APR1CRYPT;
8130 dgst_size = DGST_SIZE_4_4;
8131 parse_func = md5apr1_parse_hash;
8132 sort_by_digest = sort_by_digest_4_4;
8133 opti_type = OPTI_TYPE_ZERO_BYTE;
8134 dgst_pos0 = 0;
8135 dgst_pos1 = 1;
8136 dgst_pos2 = 2;
8137 dgst_pos3 = 3;
8138 break;
8139
8140 case 1700: hash_type = HASH_TYPE_SHA512;
8141 salt_type = SALT_TYPE_NONE;
8142 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8143 opts_type = OPTS_TYPE_PT_GENERATE_BE
8144 | OPTS_TYPE_PT_ADD80
8145 | OPTS_TYPE_PT_ADDBITS15;
8146 kern_type = KERN_TYPE_SHA512;
8147 dgst_size = DGST_SIZE_8_8;
8148 parse_func = sha512_parse_hash;
8149 sort_by_digest = sort_by_digest_8_8;
8150 opti_type = OPTI_TYPE_ZERO_BYTE
8151 | OPTI_TYPE_PRECOMPUTE_INIT
8152 | OPTI_TYPE_PRECOMPUTE_MERKLE
8153 | OPTI_TYPE_EARLY_SKIP
8154 | OPTI_TYPE_NOT_ITERATED
8155 | OPTI_TYPE_NOT_SALTED
8156 | OPTI_TYPE_USES_BITS_64
8157 | OPTI_TYPE_RAW_HASH;
8158 dgst_pos0 = 14;
8159 dgst_pos1 = 15;
8160 dgst_pos2 = 6;
8161 dgst_pos3 = 7;
8162 break;
8163
8164 case 1710: hash_type = HASH_TYPE_SHA512;
8165 salt_type = SALT_TYPE_INTERN;
8166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8167 opts_type = OPTS_TYPE_PT_GENERATE_BE
8168 | OPTS_TYPE_ST_ADD80
8169 | OPTS_TYPE_ST_ADDBITS15;
8170 kern_type = KERN_TYPE_SHA512_PWSLT;
8171 dgst_size = DGST_SIZE_8_8;
8172 parse_func = sha512s_parse_hash;
8173 sort_by_digest = sort_by_digest_8_8;
8174 opti_type = OPTI_TYPE_ZERO_BYTE
8175 | OPTI_TYPE_PRECOMPUTE_INIT
8176 | OPTI_TYPE_PRECOMPUTE_MERKLE
8177 | OPTI_TYPE_EARLY_SKIP
8178 | OPTI_TYPE_NOT_ITERATED
8179 | OPTI_TYPE_APPENDED_SALT
8180 | OPTI_TYPE_USES_BITS_64
8181 | OPTI_TYPE_RAW_HASH;
8182 dgst_pos0 = 14;
8183 dgst_pos1 = 15;
8184 dgst_pos2 = 6;
8185 dgst_pos3 = 7;
8186 break;
8187
8188 case 1711: hash_type = HASH_TYPE_SHA512;
8189 salt_type = SALT_TYPE_EMBEDDED;
8190 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8191 opts_type = OPTS_TYPE_PT_GENERATE_BE
8192 | OPTS_TYPE_ST_ADD80
8193 | OPTS_TYPE_ST_ADDBITS15;
8194 kern_type = KERN_TYPE_SHA512_PWSLT;
8195 dgst_size = DGST_SIZE_8_8;
8196 parse_func = sha512b64s_parse_hash;
8197 sort_by_digest = sort_by_digest_8_8;
8198 opti_type = OPTI_TYPE_ZERO_BYTE
8199 | OPTI_TYPE_PRECOMPUTE_INIT
8200 | OPTI_TYPE_PRECOMPUTE_MERKLE
8201 | OPTI_TYPE_EARLY_SKIP
8202 | OPTI_TYPE_NOT_ITERATED
8203 | OPTI_TYPE_APPENDED_SALT
8204 | OPTI_TYPE_USES_BITS_64
8205 | OPTI_TYPE_RAW_HASH;
8206 dgst_pos0 = 14;
8207 dgst_pos1 = 15;
8208 dgst_pos2 = 6;
8209 dgst_pos3 = 7;
8210 break;
8211
8212 case 1720: hash_type = HASH_TYPE_SHA512;
8213 salt_type = SALT_TYPE_INTERN;
8214 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8215 opts_type = OPTS_TYPE_PT_GENERATE_BE
8216 | OPTS_TYPE_PT_ADD80
8217 | OPTS_TYPE_PT_ADDBITS15;
8218 kern_type = KERN_TYPE_SHA512_SLTPW;
8219 dgst_size = DGST_SIZE_8_8;
8220 parse_func = sha512s_parse_hash;
8221 sort_by_digest = sort_by_digest_8_8;
8222 opti_type = OPTI_TYPE_ZERO_BYTE
8223 | OPTI_TYPE_PRECOMPUTE_INIT
8224 | OPTI_TYPE_PRECOMPUTE_MERKLE
8225 | OPTI_TYPE_EARLY_SKIP
8226 | OPTI_TYPE_NOT_ITERATED
8227 | OPTI_TYPE_PREPENDED_SALT
8228 | OPTI_TYPE_USES_BITS_64
8229 | OPTI_TYPE_RAW_HASH;
8230 dgst_pos0 = 14;
8231 dgst_pos1 = 15;
8232 dgst_pos2 = 6;
8233 dgst_pos3 = 7;
8234 break;
8235
8236 case 1722: hash_type = HASH_TYPE_SHA512;
8237 salt_type = SALT_TYPE_EMBEDDED;
8238 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8239 opts_type = OPTS_TYPE_PT_GENERATE_BE
8240 | OPTS_TYPE_PT_ADD80
8241 | OPTS_TYPE_PT_ADDBITS15
8242 | OPTS_TYPE_ST_HEX;
8243 kern_type = KERN_TYPE_SHA512_SLTPW;
8244 dgst_size = DGST_SIZE_8_8;
8245 parse_func = osx512_parse_hash;
8246 sort_by_digest = sort_by_digest_8_8;
8247 opti_type = OPTI_TYPE_ZERO_BYTE
8248 | OPTI_TYPE_PRECOMPUTE_INIT
8249 | OPTI_TYPE_PRECOMPUTE_MERKLE
8250 | OPTI_TYPE_EARLY_SKIP
8251 | OPTI_TYPE_NOT_ITERATED
8252 | OPTI_TYPE_PREPENDED_SALT
8253 | OPTI_TYPE_USES_BITS_64
8254 | OPTI_TYPE_RAW_HASH;
8255 dgst_pos0 = 14;
8256 dgst_pos1 = 15;
8257 dgst_pos2 = 6;
8258 dgst_pos3 = 7;
8259 break;
8260
8261 case 1730: hash_type = HASH_TYPE_SHA512;
8262 salt_type = SALT_TYPE_INTERN;
8263 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8264 opts_type = OPTS_TYPE_PT_GENERATE_BE
8265 | OPTS_TYPE_PT_UNICODE
8266 | OPTS_TYPE_ST_ADD80
8267 | OPTS_TYPE_ST_ADDBITS15;
8268 kern_type = KERN_TYPE_SHA512_PWSLTU;
8269 dgst_size = DGST_SIZE_8_8;
8270 parse_func = sha512s_parse_hash;
8271 sort_by_digest = sort_by_digest_8_8;
8272 opti_type = OPTI_TYPE_ZERO_BYTE
8273 | OPTI_TYPE_PRECOMPUTE_INIT
8274 | OPTI_TYPE_PRECOMPUTE_MERKLE
8275 | OPTI_TYPE_EARLY_SKIP
8276 | OPTI_TYPE_NOT_ITERATED
8277 | OPTI_TYPE_APPENDED_SALT
8278 | OPTI_TYPE_USES_BITS_64
8279 | OPTI_TYPE_RAW_HASH;
8280 dgst_pos0 = 14;
8281 dgst_pos1 = 15;
8282 dgst_pos2 = 6;
8283 dgst_pos3 = 7;
8284 break;
8285
8286 case 1731: hash_type = HASH_TYPE_SHA512;
8287 salt_type = SALT_TYPE_EMBEDDED;
8288 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8289 opts_type = OPTS_TYPE_PT_GENERATE_BE
8290 | OPTS_TYPE_PT_UNICODE
8291 | OPTS_TYPE_ST_ADD80
8292 | OPTS_TYPE_ST_ADDBITS15
8293 | OPTS_TYPE_ST_HEX;
8294 kern_type = KERN_TYPE_SHA512_PWSLTU;
8295 dgst_size = DGST_SIZE_8_8;
8296 parse_func = mssql2012_parse_hash;
8297 sort_by_digest = sort_by_digest_8_8;
8298 opti_type = OPTI_TYPE_ZERO_BYTE
8299 | OPTI_TYPE_PRECOMPUTE_INIT
8300 | OPTI_TYPE_PRECOMPUTE_MERKLE
8301 | OPTI_TYPE_EARLY_SKIP
8302 | OPTI_TYPE_NOT_ITERATED
8303 | OPTI_TYPE_APPENDED_SALT
8304 | OPTI_TYPE_USES_BITS_64
8305 | OPTI_TYPE_RAW_HASH;
8306 dgst_pos0 = 14;
8307 dgst_pos1 = 15;
8308 dgst_pos2 = 6;
8309 dgst_pos3 = 7;
8310 break;
8311
8312 case 1740: hash_type = HASH_TYPE_SHA512;
8313 salt_type = SALT_TYPE_INTERN;
8314 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8315 opts_type = OPTS_TYPE_PT_GENERATE_BE
8316 | OPTS_TYPE_PT_ADD80
8317 | OPTS_TYPE_PT_ADDBITS15
8318 | OPTS_TYPE_PT_UNICODE;
8319 kern_type = KERN_TYPE_SHA512_SLTPWU;
8320 dgst_size = DGST_SIZE_8_8;
8321 parse_func = sha512s_parse_hash;
8322 sort_by_digest = sort_by_digest_8_8;
8323 opti_type = OPTI_TYPE_ZERO_BYTE
8324 | OPTI_TYPE_PRECOMPUTE_INIT
8325 | OPTI_TYPE_PRECOMPUTE_MERKLE
8326 | OPTI_TYPE_EARLY_SKIP
8327 | OPTI_TYPE_NOT_ITERATED
8328 | OPTI_TYPE_PREPENDED_SALT
8329 | OPTI_TYPE_USES_BITS_64
8330 | OPTI_TYPE_RAW_HASH;
8331 dgst_pos0 = 14;
8332 dgst_pos1 = 15;
8333 dgst_pos2 = 6;
8334 dgst_pos3 = 7;
8335 break;
8336
8337 case 1750: hash_type = HASH_TYPE_SHA512;
8338 salt_type = SALT_TYPE_INTERN;
8339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8340 opts_type = OPTS_TYPE_PT_GENERATE_BE
8341 | OPTS_TYPE_ST_ADD80;
8342 kern_type = KERN_TYPE_HMACSHA512_PW;
8343 dgst_size = DGST_SIZE_8_8;
8344 parse_func = hmacsha512_parse_hash;
8345 sort_by_digest = sort_by_digest_8_8;
8346 opti_type = OPTI_TYPE_ZERO_BYTE
8347 | OPTI_TYPE_USES_BITS_64
8348 | OPTI_TYPE_NOT_ITERATED;
8349 dgst_pos0 = 14;
8350 dgst_pos1 = 15;
8351 dgst_pos2 = 6;
8352 dgst_pos3 = 7;
8353 break;
8354
8355 case 1760: hash_type = HASH_TYPE_SHA512;
8356 salt_type = SALT_TYPE_INTERN;
8357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8358 opts_type = OPTS_TYPE_PT_GENERATE_BE
8359 | OPTS_TYPE_PT_ADD80
8360 | OPTS_TYPE_PT_ADDBITS15;
8361 kern_type = KERN_TYPE_HMACSHA512_SLT;
8362 dgst_size = DGST_SIZE_8_8;
8363 parse_func = hmacsha512_parse_hash;
8364 sort_by_digest = sort_by_digest_8_8;
8365 opti_type = OPTI_TYPE_ZERO_BYTE
8366 | OPTI_TYPE_USES_BITS_64
8367 | OPTI_TYPE_NOT_ITERATED;
8368 dgst_pos0 = 14;
8369 dgst_pos1 = 15;
8370 dgst_pos2 = 6;
8371 dgst_pos3 = 7;
8372 break;
8373
8374 case 1800: hash_type = HASH_TYPE_SHA512;
8375 salt_type = SALT_TYPE_EMBEDDED;
8376 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8377 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8378 kern_type = KERN_TYPE_SHA512CRYPT;
8379 dgst_size = DGST_SIZE_8_8;
8380 parse_func = sha512crypt_parse_hash;
8381 sort_by_digest = sort_by_digest_8_8;
8382 opti_type = OPTI_TYPE_ZERO_BYTE
8383 | OPTI_TYPE_USES_BITS_64;
8384 dgst_pos0 = 0;
8385 dgst_pos1 = 1;
8386 dgst_pos2 = 2;
8387 dgst_pos3 = 3;
8388 break;
8389
8390 case 2100: hash_type = HASH_TYPE_DCC2;
8391 salt_type = SALT_TYPE_EMBEDDED;
8392 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8393 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8394 | OPTS_TYPE_ST_LOWER
8395 | OPTS_TYPE_ST_UNICODE;
8396 kern_type = KERN_TYPE_DCC2;
8397 dgst_size = DGST_SIZE_4_4;
8398 parse_func = dcc2_parse_hash;
8399 sort_by_digest = sort_by_digest_4_4;
8400 opti_type = OPTI_TYPE_ZERO_BYTE
8401 | OPTI_TYPE_SLOW_HASH_SIMD;
8402 dgst_pos0 = 0;
8403 dgst_pos1 = 1;
8404 dgst_pos2 = 2;
8405 dgst_pos3 = 3;
8406 break;
8407
8408 case 2400: hash_type = HASH_TYPE_MD5;
8409 salt_type = SALT_TYPE_NONE;
8410 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8411 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8412 kern_type = KERN_TYPE_MD5PIX;
8413 dgst_size = DGST_SIZE_4_4;
8414 parse_func = md5pix_parse_hash;
8415 sort_by_digest = sort_by_digest_4_4;
8416 opti_type = OPTI_TYPE_ZERO_BYTE
8417 | OPTI_TYPE_PRECOMPUTE_INIT
8418 | OPTI_TYPE_PRECOMPUTE_MERKLE
8419 | OPTI_TYPE_EARLY_SKIP
8420 | OPTI_TYPE_NOT_ITERATED
8421 | OPTI_TYPE_NOT_SALTED;
8422 dgst_pos0 = 0;
8423 dgst_pos1 = 3;
8424 dgst_pos2 = 2;
8425 dgst_pos3 = 1;
8426 break;
8427
8428 case 2410: hash_type = HASH_TYPE_MD5;
8429 salt_type = SALT_TYPE_INTERN;
8430 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8431 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8432 kern_type = KERN_TYPE_MD5ASA;
8433 dgst_size = DGST_SIZE_4_4;
8434 parse_func = md5asa_parse_hash;
8435 sort_by_digest = sort_by_digest_4_4;
8436 opti_type = OPTI_TYPE_ZERO_BYTE
8437 | OPTI_TYPE_PRECOMPUTE_INIT
8438 | OPTI_TYPE_PRECOMPUTE_MERKLE
8439 | OPTI_TYPE_EARLY_SKIP
8440 | OPTI_TYPE_NOT_ITERATED;
8441 dgst_pos0 = 0;
8442 dgst_pos1 = 3;
8443 dgst_pos2 = 2;
8444 dgst_pos3 = 1;
8445 break;
8446
8447 case 2500: hash_type = HASH_TYPE_WPA;
8448 salt_type = SALT_TYPE_EMBEDDED;
8449 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8450 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8451 kern_type = KERN_TYPE_WPA;
8452 dgst_size = DGST_SIZE_4_4;
8453 parse_func = wpa_parse_hash;
8454 sort_by_digest = sort_by_digest_4_4;
8455 opti_type = OPTI_TYPE_ZERO_BYTE
8456 | OPTI_TYPE_SLOW_HASH_SIMD;
8457 dgst_pos0 = 0;
8458 dgst_pos1 = 1;
8459 dgst_pos2 = 2;
8460 dgst_pos3 = 3;
8461 break;
8462
8463 case 2600: hash_type = HASH_TYPE_MD5;
8464 salt_type = SALT_TYPE_VIRTUAL;
8465 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8466 opts_type = OPTS_TYPE_PT_GENERATE_LE
8467 | OPTS_TYPE_PT_ADD80
8468 | OPTS_TYPE_PT_ADDBITS14
8469 | OPTS_TYPE_ST_ADD80;
8470 kern_type = KERN_TYPE_MD55_PWSLT1;
8471 dgst_size = DGST_SIZE_4_4;
8472 parse_func = md5md5_parse_hash;
8473 sort_by_digest = sort_by_digest_4_4;
8474 opti_type = OPTI_TYPE_ZERO_BYTE
8475 | OPTI_TYPE_PRECOMPUTE_INIT
8476 | OPTI_TYPE_PRECOMPUTE_MERKLE
8477 | OPTI_TYPE_EARLY_SKIP;
8478 dgst_pos0 = 0;
8479 dgst_pos1 = 3;
8480 dgst_pos2 = 2;
8481 dgst_pos3 = 1;
8482 break;
8483
8484 case 2611: hash_type = HASH_TYPE_MD5;
8485 salt_type = SALT_TYPE_INTERN;
8486 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8487 opts_type = OPTS_TYPE_PT_GENERATE_LE
8488 | OPTS_TYPE_PT_ADD80
8489 | OPTS_TYPE_PT_ADDBITS14
8490 | OPTS_TYPE_ST_ADD80;
8491 kern_type = KERN_TYPE_MD55_PWSLT1;
8492 dgst_size = DGST_SIZE_4_4;
8493 parse_func = vb3_parse_hash;
8494 sort_by_digest = sort_by_digest_4_4;
8495 opti_type = OPTI_TYPE_ZERO_BYTE
8496 | OPTI_TYPE_PRECOMPUTE_INIT
8497 | OPTI_TYPE_PRECOMPUTE_MERKLE
8498 | OPTI_TYPE_EARLY_SKIP;
8499 dgst_pos0 = 0;
8500 dgst_pos1 = 3;
8501 dgst_pos2 = 2;
8502 dgst_pos3 = 1;
8503 break;
8504
8505 case 2612: hash_type = HASH_TYPE_MD5;
8506 salt_type = SALT_TYPE_EMBEDDED;
8507 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8508 opts_type = OPTS_TYPE_PT_GENERATE_LE
8509 | OPTS_TYPE_PT_ADD80
8510 | OPTS_TYPE_PT_ADDBITS14
8511 | OPTS_TYPE_ST_ADD80
8512 | OPTS_TYPE_ST_HEX;
8513 kern_type = KERN_TYPE_MD55_PWSLT1;
8514 dgst_size = DGST_SIZE_4_4;
8515 parse_func = phps_parse_hash;
8516 sort_by_digest = sort_by_digest_4_4;
8517 opti_type = OPTI_TYPE_ZERO_BYTE
8518 | OPTI_TYPE_PRECOMPUTE_INIT
8519 | OPTI_TYPE_PRECOMPUTE_MERKLE
8520 | OPTI_TYPE_EARLY_SKIP;
8521 dgst_pos0 = 0;
8522 dgst_pos1 = 3;
8523 dgst_pos2 = 2;
8524 dgst_pos3 = 1;
8525 break;
8526
8527 case 2711: hash_type = HASH_TYPE_MD5;
8528 salt_type = SALT_TYPE_INTERN;
8529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8530 opts_type = OPTS_TYPE_PT_GENERATE_LE
8531 | OPTS_TYPE_PT_ADD80
8532 | OPTS_TYPE_PT_ADDBITS14
8533 | OPTS_TYPE_ST_ADD80;
8534 kern_type = KERN_TYPE_MD55_PWSLT2;
8535 dgst_size = DGST_SIZE_4_4;
8536 parse_func = vb30_parse_hash;
8537 sort_by_digest = sort_by_digest_4_4;
8538 opti_type = OPTI_TYPE_ZERO_BYTE
8539 | OPTI_TYPE_PRECOMPUTE_INIT
8540 | OPTI_TYPE_EARLY_SKIP;
8541 dgst_pos0 = 0;
8542 dgst_pos1 = 3;
8543 dgst_pos2 = 2;
8544 dgst_pos3 = 1;
8545 break;
8546
8547 case 2811: hash_type = HASH_TYPE_MD5;
8548 salt_type = SALT_TYPE_INTERN;
8549 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8550 opts_type = OPTS_TYPE_PT_GENERATE_LE
8551 | OPTS_TYPE_PT_ADD80
8552 | OPTS_TYPE_PT_ADDBITS14;
8553 kern_type = KERN_TYPE_MD55_SLTPW;
8554 dgst_size = DGST_SIZE_4_4;
8555 parse_func = ipb2_parse_hash;
8556 sort_by_digest = sort_by_digest_4_4;
8557 opti_type = OPTI_TYPE_ZERO_BYTE
8558 | OPTI_TYPE_PRECOMPUTE_INIT
8559 | OPTI_TYPE_EARLY_SKIP;
8560 dgst_pos0 = 0;
8561 dgst_pos1 = 3;
8562 dgst_pos2 = 2;
8563 dgst_pos3 = 1;
8564 break;
8565
8566 case 3000: hash_type = HASH_TYPE_LM;
8567 salt_type = SALT_TYPE_NONE;
8568 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8569 opts_type = OPTS_TYPE_PT_GENERATE_LE
8570 | OPTS_TYPE_PT_UPPER
8571 | OPTS_TYPE_PT_BITSLICE;
8572 kern_type = KERN_TYPE_LM;
8573 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8574 parse_func = lm_parse_hash;
8575 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8576 opti_type = OPTI_TYPE_ZERO_BYTE
8577 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8578 dgst_pos0 = 0;
8579 dgst_pos1 = 1;
8580 dgst_pos2 = 2;
8581 dgst_pos3 = 3;
8582 break;
8583
8584 case 3100: hash_type = HASH_TYPE_ORACLEH;
8585 salt_type = SALT_TYPE_INTERN;
8586 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8587 opts_type = OPTS_TYPE_PT_GENERATE_LE
8588 | OPTS_TYPE_PT_UPPER
8589 | OPTS_TYPE_ST_UPPER;
8590 kern_type = KERN_TYPE_ORACLEH;
8591 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8592 parse_func = oracleh_parse_hash;
8593 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8594 opti_type = OPTI_TYPE_ZERO_BYTE;
8595 dgst_pos0 = 0;
8596 dgst_pos1 = 1;
8597 dgst_pos2 = 2;
8598 dgst_pos3 = 3;
8599 break;
8600
8601 case 3200: hash_type = HASH_TYPE_BCRYPT;
8602 salt_type = SALT_TYPE_EMBEDDED;
8603 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8604 opts_type = OPTS_TYPE_PT_GENERATE_LE
8605 | OPTS_TYPE_ST_GENERATE_LE;
8606 kern_type = KERN_TYPE_BCRYPT;
8607 dgst_size = DGST_SIZE_4_6;
8608 parse_func = bcrypt_parse_hash;
8609 sort_by_digest = sort_by_digest_4_6;
8610 opti_type = OPTI_TYPE_ZERO_BYTE;
8611 dgst_pos0 = 0;
8612 dgst_pos1 = 1;
8613 dgst_pos2 = 2;
8614 dgst_pos3 = 3;
8615 break;
8616
8617 case 3710: hash_type = HASH_TYPE_MD5;
8618 salt_type = SALT_TYPE_INTERN;
8619 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8620 opts_type = OPTS_TYPE_PT_GENERATE_LE
8621 | OPTS_TYPE_PT_ADD80
8622 | OPTS_TYPE_PT_ADDBITS14;
8623 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8624 dgst_size = DGST_SIZE_4_4;
8625 parse_func = md5s_parse_hash;
8626 sort_by_digest = sort_by_digest_4_4;
8627 opti_type = OPTI_TYPE_ZERO_BYTE
8628 | OPTI_TYPE_PRECOMPUTE_INIT
8629 | OPTI_TYPE_PRECOMPUTE_MERKLE
8630 | OPTI_TYPE_EARLY_SKIP;
8631 dgst_pos0 = 0;
8632 dgst_pos1 = 3;
8633 dgst_pos2 = 2;
8634 dgst_pos3 = 1;
8635 break;
8636
8637 case 3711: hash_type = HASH_TYPE_MD5;
8638 salt_type = SALT_TYPE_EMBEDDED;
8639 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8640 opts_type = OPTS_TYPE_PT_GENERATE_LE
8641 | OPTS_TYPE_PT_ADD80
8642 | OPTS_TYPE_PT_ADDBITS14;
8643 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8644 dgst_size = DGST_SIZE_4_4;
8645 parse_func = mediawiki_b_parse_hash;
8646 sort_by_digest = sort_by_digest_4_4;
8647 opti_type = OPTI_TYPE_ZERO_BYTE
8648 | OPTI_TYPE_PRECOMPUTE_INIT
8649 | OPTI_TYPE_PRECOMPUTE_MERKLE
8650 | OPTI_TYPE_EARLY_SKIP;
8651 dgst_pos0 = 0;
8652 dgst_pos1 = 3;
8653 dgst_pos2 = 2;
8654 dgst_pos3 = 1;
8655 break;
8656
8657 case 3800: hash_type = HASH_TYPE_MD5;
8658 salt_type = SALT_TYPE_INTERN;
8659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8660 opts_type = OPTS_TYPE_PT_GENERATE_LE
8661 | OPTS_TYPE_ST_ADDBITS14;
8662 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8663 dgst_size = DGST_SIZE_4_4;
8664 parse_func = md5s_parse_hash;
8665 sort_by_digest = sort_by_digest_4_4;
8666 opti_type = OPTI_TYPE_ZERO_BYTE
8667 | OPTI_TYPE_PRECOMPUTE_INIT
8668 | OPTI_TYPE_PRECOMPUTE_MERKLE
8669 | OPTI_TYPE_EARLY_SKIP
8670 | OPTI_TYPE_NOT_ITERATED
8671 | OPTI_TYPE_RAW_HASH;
8672 dgst_pos0 = 0;
8673 dgst_pos1 = 3;
8674 dgst_pos2 = 2;
8675 dgst_pos3 = 1;
8676 break;
8677
8678 case 4300: hash_type = HASH_TYPE_MD5;
8679 salt_type = SALT_TYPE_VIRTUAL;
8680 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8681 opts_type = OPTS_TYPE_PT_GENERATE_LE
8682 | OPTS_TYPE_PT_ADD80
8683 | OPTS_TYPE_PT_ADDBITS14
8684 | OPTS_TYPE_ST_ADD80;
8685 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8686 dgst_size = DGST_SIZE_4_4;
8687 parse_func = md5md5_parse_hash;
8688 sort_by_digest = sort_by_digest_4_4;
8689 opti_type = OPTI_TYPE_ZERO_BYTE
8690 | OPTI_TYPE_PRECOMPUTE_INIT
8691 | OPTI_TYPE_PRECOMPUTE_MERKLE
8692 | OPTI_TYPE_EARLY_SKIP;
8693 dgst_pos0 = 0;
8694 dgst_pos1 = 3;
8695 dgst_pos2 = 2;
8696 dgst_pos3 = 1;
8697 break;
8698
8699
8700 case 4400: hash_type = HASH_TYPE_MD5;
8701 salt_type = SALT_TYPE_NONE;
8702 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8703 opts_type = OPTS_TYPE_PT_GENERATE_BE
8704 | OPTS_TYPE_PT_ADD80
8705 | OPTS_TYPE_PT_ADDBITS15;
8706 kern_type = KERN_TYPE_MD5_SHA1;
8707 dgst_size = DGST_SIZE_4_4;
8708 parse_func = md5_parse_hash;
8709 sort_by_digest = sort_by_digest_4_4;
8710 opti_type = OPTI_TYPE_ZERO_BYTE
8711 | OPTI_TYPE_PRECOMPUTE_INIT
8712 | OPTI_TYPE_PRECOMPUTE_MERKLE
8713 | OPTI_TYPE_EARLY_SKIP
8714 | OPTI_TYPE_NOT_ITERATED
8715 | OPTI_TYPE_NOT_SALTED
8716 | OPTI_TYPE_RAW_HASH;
8717 dgst_pos0 = 0;
8718 dgst_pos1 = 3;
8719 dgst_pos2 = 2;
8720 dgst_pos3 = 1;
8721 break;
8722
8723 case 4500: hash_type = HASH_TYPE_SHA1;
8724 salt_type = SALT_TYPE_NONE;
8725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8726 opts_type = OPTS_TYPE_PT_GENERATE_BE
8727 | OPTS_TYPE_PT_ADD80
8728 | OPTS_TYPE_PT_ADDBITS15;
8729 kern_type = KERN_TYPE_SHA11;
8730 dgst_size = DGST_SIZE_4_5;
8731 parse_func = sha1_parse_hash;
8732 sort_by_digest = sort_by_digest_4_5;
8733 opti_type = OPTI_TYPE_ZERO_BYTE
8734 | OPTI_TYPE_PRECOMPUTE_INIT
8735 | OPTI_TYPE_PRECOMPUTE_MERKLE
8736 | OPTI_TYPE_EARLY_SKIP
8737 | OPTI_TYPE_NOT_SALTED;
8738 dgst_pos0 = 3;
8739 dgst_pos1 = 4;
8740 dgst_pos2 = 2;
8741 dgst_pos3 = 1;
8742 break;
8743
8744 case 4700: hash_type = HASH_TYPE_SHA1;
8745 salt_type = SALT_TYPE_NONE;
8746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8747 opts_type = OPTS_TYPE_PT_GENERATE_LE
8748 | OPTS_TYPE_PT_ADD80
8749 | OPTS_TYPE_PT_ADDBITS14;
8750 kern_type = KERN_TYPE_SHA1_MD5;
8751 dgst_size = DGST_SIZE_4_5;
8752 parse_func = sha1_parse_hash;
8753 sort_by_digest = sort_by_digest_4_5;
8754 opti_type = OPTI_TYPE_ZERO_BYTE
8755 | OPTI_TYPE_PRECOMPUTE_INIT
8756 | OPTI_TYPE_PRECOMPUTE_MERKLE
8757 | OPTI_TYPE_EARLY_SKIP
8758 | OPTI_TYPE_NOT_ITERATED
8759 | OPTI_TYPE_NOT_SALTED
8760 | OPTI_TYPE_RAW_HASH;
8761 dgst_pos0 = 3;
8762 dgst_pos1 = 4;
8763 dgst_pos2 = 2;
8764 dgst_pos3 = 1;
8765 break;
8766
8767 case 4800: hash_type = HASH_TYPE_MD5;
8768 salt_type = SALT_TYPE_EMBEDDED;
8769 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8770 opts_type = OPTS_TYPE_PT_GENERATE_LE
8771 | OPTS_TYPE_PT_ADDBITS14;
8772 kern_type = KERN_TYPE_MD5_CHAP;
8773 dgst_size = DGST_SIZE_4_4;
8774 parse_func = chap_parse_hash;
8775 sort_by_digest = sort_by_digest_4_4;
8776 opti_type = OPTI_TYPE_ZERO_BYTE
8777 | OPTI_TYPE_PRECOMPUTE_INIT
8778 | OPTI_TYPE_PRECOMPUTE_MERKLE
8779 | OPTI_TYPE_MEET_IN_MIDDLE
8780 | OPTI_TYPE_EARLY_SKIP
8781 | OPTI_TYPE_NOT_ITERATED
8782 | OPTI_TYPE_RAW_HASH;
8783 dgst_pos0 = 0;
8784 dgst_pos1 = 3;
8785 dgst_pos2 = 2;
8786 dgst_pos3 = 1;
8787 break;
8788
8789 case 4900: hash_type = HASH_TYPE_SHA1;
8790 salt_type = SALT_TYPE_INTERN;
8791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8792 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8793 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8794 dgst_size = DGST_SIZE_4_5;
8795 parse_func = sha1s_parse_hash;
8796 sort_by_digest = sort_by_digest_4_5;
8797 opti_type = OPTI_TYPE_ZERO_BYTE
8798 | OPTI_TYPE_PRECOMPUTE_INIT
8799 | OPTI_TYPE_PRECOMPUTE_MERKLE
8800 | OPTI_TYPE_EARLY_SKIP;
8801 dgst_pos0 = 3;
8802 dgst_pos1 = 4;
8803 dgst_pos2 = 2;
8804 dgst_pos3 = 1;
8805 break;
8806
8807 case 5000: hash_type = HASH_TYPE_KECCAK;
8808 salt_type = SALT_TYPE_EMBEDDED;
8809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8810 opts_type = OPTS_TYPE_PT_GENERATE_LE
8811 | OPTS_TYPE_PT_ADD01;
8812 kern_type = KERN_TYPE_KECCAK;
8813 dgst_size = DGST_SIZE_8_25;
8814 parse_func = keccak_parse_hash;
8815 sort_by_digest = sort_by_digest_8_25;
8816 opti_type = OPTI_TYPE_ZERO_BYTE
8817 | OPTI_TYPE_USES_BITS_64
8818 | OPTI_TYPE_RAW_HASH;
8819 dgst_pos0 = 2;
8820 dgst_pos1 = 3;
8821 dgst_pos2 = 4;
8822 dgst_pos3 = 5;
8823 break;
8824
8825 case 5100: hash_type = HASH_TYPE_MD5H;
8826 salt_type = SALT_TYPE_NONE;
8827 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8828 opts_type = OPTS_TYPE_PT_GENERATE_LE
8829 | OPTS_TYPE_PT_ADD80
8830 | OPTS_TYPE_PT_ADDBITS14;
8831 kern_type = KERN_TYPE_MD5H;
8832 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8833 parse_func = md5half_parse_hash;
8834 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8835 opti_type = OPTI_TYPE_ZERO_BYTE
8836 | OPTI_TYPE_RAW_HASH;
8837 dgst_pos0 = 0;
8838 dgst_pos1 = 1;
8839 dgst_pos2 = 2;
8840 dgst_pos3 = 3;
8841 break;
8842
8843 case 5200: hash_type = HASH_TYPE_SHA256;
8844 salt_type = SALT_TYPE_EMBEDDED;
8845 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8846 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8847 kern_type = KERN_TYPE_PSAFE3;
8848 dgst_size = DGST_SIZE_4_8;
8849 parse_func = psafe3_parse_hash;
8850 sort_by_digest = sort_by_digest_4_8;
8851 opti_type = OPTI_TYPE_ZERO_BYTE;
8852 dgst_pos0 = 0;
8853 dgst_pos1 = 1;
8854 dgst_pos2 = 2;
8855 dgst_pos3 = 3;
8856 break;
8857
8858 case 5300: hash_type = HASH_TYPE_MD5;
8859 salt_type = SALT_TYPE_EMBEDDED;
8860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8861 opts_type = OPTS_TYPE_PT_GENERATE_LE
8862 | OPTS_TYPE_ST_ADD80;
8863 kern_type = KERN_TYPE_IKEPSK_MD5;
8864 dgst_size = DGST_SIZE_4_4;
8865 parse_func = ikepsk_md5_parse_hash;
8866 sort_by_digest = sort_by_digest_4_4;
8867 opti_type = OPTI_TYPE_ZERO_BYTE;
8868 dgst_pos0 = 0;
8869 dgst_pos1 = 3;
8870 dgst_pos2 = 2;
8871 dgst_pos3 = 1;
8872 break;
8873
8874 case 5400: hash_type = HASH_TYPE_SHA1;
8875 salt_type = SALT_TYPE_EMBEDDED;
8876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8877 opts_type = OPTS_TYPE_PT_GENERATE_BE
8878 | OPTS_TYPE_ST_ADD80;
8879 kern_type = KERN_TYPE_IKEPSK_SHA1;
8880 dgst_size = DGST_SIZE_4_5;
8881 parse_func = ikepsk_sha1_parse_hash;
8882 sort_by_digest = sort_by_digest_4_5;
8883 opti_type = OPTI_TYPE_ZERO_BYTE;
8884 dgst_pos0 = 3;
8885 dgst_pos1 = 4;
8886 dgst_pos2 = 2;
8887 dgst_pos3 = 1;
8888 break;
8889
8890 case 5500: hash_type = HASH_TYPE_NETNTLM;
8891 salt_type = SALT_TYPE_EMBEDDED;
8892 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8893 opts_type = OPTS_TYPE_PT_GENERATE_LE
8894 | OPTS_TYPE_PT_ADD80
8895 | OPTS_TYPE_PT_ADDBITS14
8896 | OPTS_TYPE_PT_UNICODE
8897 | OPTS_TYPE_ST_HEX;
8898 kern_type = KERN_TYPE_NETNTLMv1;
8899 dgst_size = DGST_SIZE_4_4;
8900 parse_func = netntlmv1_parse_hash;
8901 sort_by_digest = sort_by_digest_4_4;
8902 opti_type = OPTI_TYPE_ZERO_BYTE
8903 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8904 dgst_pos0 = 0;
8905 dgst_pos1 = 1;
8906 dgst_pos2 = 2;
8907 dgst_pos3 = 3;
8908 break;
8909
8910 case 5600: hash_type = HASH_TYPE_MD5;
8911 salt_type = SALT_TYPE_EMBEDDED;
8912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8913 opts_type = OPTS_TYPE_PT_GENERATE_LE
8914 | OPTS_TYPE_PT_ADD80
8915 | OPTS_TYPE_PT_ADDBITS14
8916 | OPTS_TYPE_PT_UNICODE;
8917 kern_type = KERN_TYPE_NETNTLMv2;
8918 dgst_size = DGST_SIZE_4_4;
8919 parse_func = netntlmv2_parse_hash;
8920 sort_by_digest = sort_by_digest_4_4;
8921 opti_type = OPTI_TYPE_ZERO_BYTE;
8922 dgst_pos0 = 0;
8923 dgst_pos1 = 3;
8924 dgst_pos2 = 2;
8925 dgst_pos3 = 1;
8926 break;
8927
8928 case 5700: hash_type = HASH_TYPE_SHA256;
8929 salt_type = SALT_TYPE_NONE;
8930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8931 opts_type = OPTS_TYPE_PT_GENERATE_BE
8932 | OPTS_TYPE_PT_ADD80
8933 | OPTS_TYPE_PT_ADDBITS15;
8934 kern_type = KERN_TYPE_SHA256;
8935 dgst_size = DGST_SIZE_4_8;
8936 parse_func = cisco4_parse_hash;
8937 sort_by_digest = sort_by_digest_4_8;
8938 opti_type = OPTI_TYPE_ZERO_BYTE
8939 | OPTI_TYPE_PRECOMPUTE_INIT
8940 | OPTI_TYPE_PRECOMPUTE_MERKLE
8941 | OPTI_TYPE_EARLY_SKIP
8942 | OPTI_TYPE_NOT_ITERATED
8943 | OPTI_TYPE_NOT_SALTED
8944 | OPTI_TYPE_RAW_HASH;
8945 dgst_pos0 = 3;
8946 dgst_pos1 = 7;
8947 dgst_pos2 = 2;
8948 dgst_pos3 = 6;
8949 break;
8950
8951 case 5800: hash_type = HASH_TYPE_SHA1;
8952 salt_type = SALT_TYPE_INTERN;
8953 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8954 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8955 | OPTS_TYPE_ST_ADD80;
8956 kern_type = KERN_TYPE_ANDROIDPIN;
8957 dgst_size = DGST_SIZE_4_5;
8958 parse_func = androidpin_parse_hash;
8959 sort_by_digest = sort_by_digest_4_5;
8960 opti_type = OPTI_TYPE_ZERO_BYTE;
8961 dgst_pos0 = 0;
8962 dgst_pos1 = 1;
8963 dgst_pos2 = 2;
8964 dgst_pos3 = 3;
8965 break;
8966
8967 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8968 salt_type = SALT_TYPE_NONE;
8969 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8970 opts_type = OPTS_TYPE_PT_GENERATE_LE
8971 | OPTS_TYPE_PT_ADD80;
8972 kern_type = KERN_TYPE_RIPEMD160;
8973 dgst_size = DGST_SIZE_4_5;
8974 parse_func = ripemd160_parse_hash;
8975 sort_by_digest = sort_by_digest_4_5;
8976 opti_type = OPTI_TYPE_ZERO_BYTE;
8977 dgst_pos0 = 0;
8978 dgst_pos1 = 1;
8979 dgst_pos2 = 2;
8980 dgst_pos3 = 3;
8981 break;
8982
8983 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8984 salt_type = SALT_TYPE_NONE;
8985 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8986 opts_type = OPTS_TYPE_PT_GENERATE_BE
8987 | OPTS_TYPE_PT_ADD80;
8988 kern_type = KERN_TYPE_WHIRLPOOL;
8989 dgst_size = DGST_SIZE_4_16;
8990 parse_func = whirlpool_parse_hash;
8991 sort_by_digest = sort_by_digest_4_16;
8992 opti_type = OPTI_TYPE_ZERO_BYTE;
8993 dgst_pos0 = 0;
8994 dgst_pos1 = 1;
8995 dgst_pos2 = 2;
8996 dgst_pos3 = 3;
8997 break;
8998
8999 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9000 salt_type = SALT_TYPE_EMBEDDED;
9001 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9002 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9003 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9004 dgst_size = DGST_SIZE_4_5;
9005 parse_func = truecrypt_parse_hash_2k;
9006 sort_by_digest = sort_by_digest_4_5;
9007 opti_type = OPTI_TYPE_ZERO_BYTE;
9008 dgst_pos0 = 0;
9009 dgst_pos1 = 1;
9010 dgst_pos2 = 2;
9011 dgst_pos3 = 3;
9012 break;
9013
9014 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9015 salt_type = SALT_TYPE_EMBEDDED;
9016 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9017 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9018 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9019 dgst_size = DGST_SIZE_4_5;
9020 parse_func = truecrypt_parse_hash_2k;
9021 sort_by_digest = sort_by_digest_4_5;
9022 opti_type = OPTI_TYPE_ZERO_BYTE;
9023 dgst_pos0 = 0;
9024 dgst_pos1 = 1;
9025 dgst_pos2 = 2;
9026 dgst_pos3 = 3;
9027 break;
9028
9029 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9030 salt_type = SALT_TYPE_EMBEDDED;
9031 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9032 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9033 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9034 dgst_size = DGST_SIZE_4_5;
9035 parse_func = truecrypt_parse_hash_2k;
9036 sort_by_digest = sort_by_digest_4_5;
9037 opti_type = OPTI_TYPE_ZERO_BYTE;
9038 dgst_pos0 = 0;
9039 dgst_pos1 = 1;
9040 dgst_pos2 = 2;
9041 dgst_pos3 = 3;
9042 break;
9043
9044 case 6221: hash_type = HASH_TYPE_SHA512;
9045 salt_type = SALT_TYPE_EMBEDDED;
9046 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9047 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9048 kern_type = KERN_TYPE_TCSHA512_XTS512;
9049 dgst_size = DGST_SIZE_8_8;
9050 parse_func = truecrypt_parse_hash_1k;
9051 sort_by_digest = sort_by_digest_8_8;
9052 opti_type = OPTI_TYPE_ZERO_BYTE
9053 | OPTI_TYPE_USES_BITS_64;
9054 dgst_pos0 = 0;
9055 dgst_pos1 = 1;
9056 dgst_pos2 = 2;
9057 dgst_pos3 = 3;
9058 break;
9059
9060 case 6222: hash_type = HASH_TYPE_SHA512;
9061 salt_type = SALT_TYPE_EMBEDDED;
9062 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9063 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9064 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9065 dgst_size = DGST_SIZE_8_8;
9066 parse_func = truecrypt_parse_hash_1k;
9067 sort_by_digest = sort_by_digest_8_8;
9068 opti_type = OPTI_TYPE_ZERO_BYTE
9069 | OPTI_TYPE_USES_BITS_64;
9070 dgst_pos0 = 0;
9071 dgst_pos1 = 1;
9072 dgst_pos2 = 2;
9073 dgst_pos3 = 3;
9074 break;
9075
9076 case 6223: hash_type = HASH_TYPE_SHA512;
9077 salt_type = SALT_TYPE_EMBEDDED;
9078 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9079 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9080 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9081 dgst_size = DGST_SIZE_8_8;
9082 parse_func = truecrypt_parse_hash_1k;
9083 sort_by_digest = sort_by_digest_8_8;
9084 opti_type = OPTI_TYPE_ZERO_BYTE
9085 | OPTI_TYPE_USES_BITS_64;
9086 dgst_pos0 = 0;
9087 dgst_pos1 = 1;
9088 dgst_pos2 = 2;
9089 dgst_pos3 = 3;
9090 break;
9091
9092 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9093 salt_type = SALT_TYPE_EMBEDDED;
9094 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9095 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9096 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9097 dgst_size = DGST_SIZE_4_8;
9098 parse_func = truecrypt_parse_hash_1k;
9099 sort_by_digest = sort_by_digest_4_8;
9100 opti_type = OPTI_TYPE_ZERO_BYTE;
9101 dgst_pos0 = 0;
9102 dgst_pos1 = 1;
9103 dgst_pos2 = 2;
9104 dgst_pos3 = 3;
9105 break;
9106
9107 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9108 salt_type = SALT_TYPE_EMBEDDED;
9109 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9110 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9111 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9112 dgst_size = DGST_SIZE_4_8;
9113 parse_func = truecrypt_parse_hash_1k;
9114 sort_by_digest = sort_by_digest_4_8;
9115 opti_type = OPTI_TYPE_ZERO_BYTE;
9116 dgst_pos0 = 0;
9117 dgst_pos1 = 1;
9118 dgst_pos2 = 2;
9119 dgst_pos3 = 3;
9120 break;
9121
9122 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9123 salt_type = SALT_TYPE_EMBEDDED;
9124 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9125 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9126 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9127 dgst_size = DGST_SIZE_4_8;
9128 parse_func = truecrypt_parse_hash_1k;
9129 sort_by_digest = sort_by_digest_4_8;
9130 opti_type = OPTI_TYPE_ZERO_BYTE;
9131 dgst_pos0 = 0;
9132 dgst_pos1 = 1;
9133 dgst_pos2 = 2;
9134 dgst_pos3 = 3;
9135 break;
9136
9137 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9138 salt_type = SALT_TYPE_EMBEDDED;
9139 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9140 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9141 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9142 dgst_size = DGST_SIZE_4_5;
9143 parse_func = truecrypt_parse_hash_1k;
9144 sort_by_digest = sort_by_digest_4_5;
9145 opti_type = OPTI_TYPE_ZERO_BYTE;
9146 dgst_pos0 = 0;
9147 dgst_pos1 = 1;
9148 dgst_pos2 = 2;
9149 dgst_pos3 = 3;
9150 break;
9151
9152 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9153 salt_type = SALT_TYPE_EMBEDDED;
9154 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9155 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9156 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9157 dgst_size = DGST_SIZE_4_5;
9158 parse_func = truecrypt_parse_hash_1k;
9159 sort_by_digest = sort_by_digest_4_5;
9160 opti_type = OPTI_TYPE_ZERO_BYTE;
9161 dgst_pos0 = 0;
9162 dgst_pos1 = 1;
9163 dgst_pos2 = 2;
9164 dgst_pos3 = 3;
9165 break;
9166
9167 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9168 salt_type = SALT_TYPE_EMBEDDED;
9169 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9170 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9171 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9172 dgst_size = DGST_SIZE_4_5;
9173 parse_func = truecrypt_parse_hash_1k;
9174 sort_by_digest = sort_by_digest_4_5;
9175 opti_type = OPTI_TYPE_ZERO_BYTE;
9176 dgst_pos0 = 0;
9177 dgst_pos1 = 1;
9178 dgst_pos2 = 2;
9179 dgst_pos3 = 3;
9180 break;
9181
9182 case 6300: hash_type = HASH_TYPE_MD5;
9183 salt_type = SALT_TYPE_EMBEDDED;
9184 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9185 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9186 kern_type = KERN_TYPE_MD5AIX;
9187 dgst_size = DGST_SIZE_4_4;
9188 parse_func = md5aix_parse_hash;
9189 sort_by_digest = sort_by_digest_4_4;
9190 opti_type = OPTI_TYPE_ZERO_BYTE;
9191 dgst_pos0 = 0;
9192 dgst_pos1 = 1;
9193 dgst_pos2 = 2;
9194 dgst_pos3 = 3;
9195 break;
9196
9197 case 6400: hash_type = HASH_TYPE_SHA256;
9198 salt_type = SALT_TYPE_EMBEDDED;
9199 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9200 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9201 kern_type = KERN_TYPE_SHA256AIX;
9202 dgst_size = DGST_SIZE_4_8;
9203 parse_func = sha256aix_parse_hash;
9204 sort_by_digest = sort_by_digest_4_8;
9205 opti_type = OPTI_TYPE_ZERO_BYTE;
9206 dgst_pos0 = 0;
9207 dgst_pos1 = 1;
9208 dgst_pos2 = 2;
9209 dgst_pos3 = 3;
9210 break;
9211
9212 case 6500: hash_type = HASH_TYPE_SHA512;
9213 salt_type = SALT_TYPE_EMBEDDED;
9214 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9215 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9216 kern_type = KERN_TYPE_SHA512AIX;
9217 dgst_size = DGST_SIZE_8_8;
9218 parse_func = sha512aix_parse_hash;
9219 sort_by_digest = sort_by_digest_8_8;
9220 opti_type = OPTI_TYPE_ZERO_BYTE
9221 | OPTI_TYPE_USES_BITS_64;
9222 dgst_pos0 = 0;
9223 dgst_pos1 = 1;
9224 dgst_pos2 = 2;
9225 dgst_pos3 = 3;
9226 break;
9227
9228 case 6600: hash_type = HASH_TYPE_AES;
9229 salt_type = SALT_TYPE_EMBEDDED;
9230 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9231 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9232 kern_type = KERN_TYPE_AGILEKEY;
9233 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9234 parse_func = agilekey_parse_hash;
9235 sort_by_digest = sort_by_digest_4_5;
9236 opti_type = OPTI_TYPE_ZERO_BYTE;
9237 dgst_pos0 = 0;
9238 dgst_pos1 = 1;
9239 dgst_pos2 = 2;
9240 dgst_pos3 = 3;
9241 break;
9242
9243 case 6700: hash_type = HASH_TYPE_SHA1;
9244 salt_type = SALT_TYPE_EMBEDDED;
9245 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9246 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9247 kern_type = KERN_TYPE_SHA1AIX;
9248 dgst_size = DGST_SIZE_4_5;
9249 parse_func = sha1aix_parse_hash;
9250 sort_by_digest = sort_by_digest_4_5;
9251 opti_type = OPTI_TYPE_ZERO_BYTE;
9252 dgst_pos0 = 0;
9253 dgst_pos1 = 1;
9254 dgst_pos2 = 2;
9255 dgst_pos3 = 3;
9256 break;
9257
9258 case 6800: hash_type = HASH_TYPE_AES;
9259 salt_type = SALT_TYPE_EMBEDDED;
9260 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9261 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9262 kern_type = KERN_TYPE_LASTPASS;
9263 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9264 parse_func = lastpass_parse_hash;
9265 sort_by_digest = sort_by_digest_4_8;
9266 opti_type = OPTI_TYPE_ZERO_BYTE;
9267 dgst_pos0 = 0;
9268 dgst_pos1 = 1;
9269 dgst_pos2 = 2;
9270 dgst_pos3 = 3;
9271 break;
9272
9273 case 6900: hash_type = HASH_TYPE_GOST;
9274 salt_type = SALT_TYPE_NONE;
9275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9276 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9277 kern_type = KERN_TYPE_GOST;
9278 dgst_size = DGST_SIZE_4_8;
9279 parse_func = gost_parse_hash;
9280 sort_by_digest = sort_by_digest_4_8;
9281 opti_type = OPTI_TYPE_ZERO_BYTE;
9282 dgst_pos0 = 0;
9283 dgst_pos1 = 1;
9284 dgst_pos2 = 2;
9285 dgst_pos3 = 3;
9286 break;
9287
9288 case 7100: hash_type = HASH_TYPE_SHA512;
9289 salt_type = SALT_TYPE_EMBEDDED;
9290 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9291 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9292 kern_type = KERN_TYPE_PBKDF2_SHA512;
9293 dgst_size = DGST_SIZE_8_16;
9294 parse_func = sha512osx_parse_hash;
9295 sort_by_digest = sort_by_digest_8_16;
9296 opti_type = OPTI_TYPE_ZERO_BYTE
9297 | OPTI_TYPE_USES_BITS_64
9298 | OPTI_TYPE_SLOW_HASH_SIMD;
9299 dgst_pos0 = 0;
9300 dgst_pos1 = 1;
9301 dgst_pos2 = 2;
9302 dgst_pos3 = 3;
9303 break;
9304
9305 case 7200: hash_type = HASH_TYPE_SHA512;
9306 salt_type = SALT_TYPE_EMBEDDED;
9307 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9308 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9309 kern_type = KERN_TYPE_PBKDF2_SHA512;
9310 dgst_size = DGST_SIZE_8_16;
9311 parse_func = sha512grub_parse_hash;
9312 sort_by_digest = sort_by_digest_8_16;
9313 opti_type = OPTI_TYPE_ZERO_BYTE
9314 | OPTI_TYPE_USES_BITS_64
9315 | OPTI_TYPE_SLOW_HASH_SIMD;
9316 dgst_pos0 = 0;
9317 dgst_pos1 = 1;
9318 dgst_pos2 = 2;
9319 dgst_pos3 = 3;
9320 break;
9321
9322 case 7300: hash_type = HASH_TYPE_SHA1;
9323 salt_type = SALT_TYPE_EMBEDDED;
9324 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9325 opts_type = OPTS_TYPE_PT_GENERATE_BE
9326 | OPTS_TYPE_ST_ADD80
9327 | OPTS_TYPE_ST_ADDBITS15;
9328 kern_type = KERN_TYPE_RAKP;
9329 dgst_size = DGST_SIZE_4_5;
9330 parse_func = rakp_parse_hash;
9331 sort_by_digest = sort_by_digest_4_5;
9332 opti_type = OPTI_TYPE_ZERO_BYTE
9333 | OPTI_TYPE_NOT_ITERATED;
9334 dgst_pos0 = 3;
9335 dgst_pos1 = 4;
9336 dgst_pos2 = 2;
9337 dgst_pos3 = 1;
9338 break;
9339
9340 case 7400: hash_type = HASH_TYPE_SHA256;
9341 salt_type = SALT_TYPE_EMBEDDED;
9342 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9343 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9344 kern_type = KERN_TYPE_SHA256CRYPT;
9345 dgst_size = DGST_SIZE_4_8;
9346 parse_func = sha256crypt_parse_hash;
9347 sort_by_digest = sort_by_digest_4_8;
9348 opti_type = OPTI_TYPE_ZERO_BYTE;
9349 dgst_pos0 = 0;
9350 dgst_pos1 = 1;
9351 dgst_pos2 = 2;
9352 dgst_pos3 = 3;
9353 break;
9354
9355 case 7500: hash_type = HASH_TYPE_KRB5PA;
9356 salt_type = SALT_TYPE_EMBEDDED;
9357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9358 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9359 kern_type = KERN_TYPE_KRB5PA;
9360 dgst_size = DGST_SIZE_4_4;
9361 parse_func = krb5pa_parse_hash;
9362 sort_by_digest = sort_by_digest_4_4;
9363 opti_type = OPTI_TYPE_ZERO_BYTE
9364 | OPTI_TYPE_NOT_ITERATED;
9365 dgst_pos0 = 0;
9366 dgst_pos1 = 1;
9367 dgst_pos2 = 2;
9368 dgst_pos3 = 3;
9369 break;
9370
9371 case 7600: hash_type = HASH_TYPE_SHA1;
9372 salt_type = SALT_TYPE_INTERN;
9373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9374 opts_type = OPTS_TYPE_PT_GENERATE_BE
9375 | OPTS_TYPE_PT_ADD80
9376 | OPTS_TYPE_PT_ADDBITS15;
9377 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9378 dgst_size = DGST_SIZE_4_5;
9379 parse_func = redmine_parse_hash;
9380 sort_by_digest = sort_by_digest_4_5;
9381 opti_type = OPTI_TYPE_ZERO_BYTE
9382 | OPTI_TYPE_PRECOMPUTE_INIT
9383 | OPTI_TYPE_EARLY_SKIP
9384 | OPTI_TYPE_NOT_ITERATED
9385 | OPTI_TYPE_PREPENDED_SALT;
9386 dgst_pos0 = 3;
9387 dgst_pos1 = 4;
9388 dgst_pos2 = 2;
9389 dgst_pos3 = 1;
9390 break;
9391
9392 case 7700: hash_type = HASH_TYPE_SAPB;
9393 salt_type = SALT_TYPE_EMBEDDED;
9394 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9395 opts_type = OPTS_TYPE_PT_GENERATE_LE
9396 | OPTS_TYPE_PT_UPPER
9397 | OPTS_TYPE_ST_UPPER;
9398 kern_type = KERN_TYPE_SAPB;
9399 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9400 parse_func = sapb_parse_hash;
9401 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9402 opti_type = OPTI_TYPE_ZERO_BYTE
9403 | OPTI_TYPE_PRECOMPUTE_INIT
9404 | OPTI_TYPE_NOT_ITERATED;
9405 dgst_pos0 = 0;
9406 dgst_pos1 = 1;
9407 dgst_pos2 = 2;
9408 dgst_pos3 = 3;
9409 break;
9410
9411 case 7800: hash_type = HASH_TYPE_SAPG;
9412 salt_type = SALT_TYPE_EMBEDDED;
9413 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9414 opts_type = OPTS_TYPE_PT_GENERATE_BE
9415 | OPTS_TYPE_ST_ADD80
9416 | OPTS_TYPE_ST_UPPER;
9417 kern_type = KERN_TYPE_SAPG;
9418 dgst_size = DGST_SIZE_4_5;
9419 parse_func = sapg_parse_hash;
9420 sort_by_digest = sort_by_digest_4_5;
9421 opti_type = OPTI_TYPE_ZERO_BYTE
9422 | OPTI_TYPE_PRECOMPUTE_INIT
9423 | OPTI_TYPE_NOT_ITERATED;
9424 dgst_pos0 = 3;
9425 dgst_pos1 = 4;
9426 dgst_pos2 = 2;
9427 dgst_pos3 = 1;
9428 break;
9429
9430 case 7900: hash_type = HASH_TYPE_SHA512;
9431 salt_type = SALT_TYPE_EMBEDDED;
9432 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9433 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9434 kern_type = KERN_TYPE_DRUPAL7;
9435 dgst_size = DGST_SIZE_8_8;
9436 parse_func = drupal7_parse_hash;
9437 sort_by_digest = sort_by_digest_8_8;
9438 opti_type = OPTI_TYPE_ZERO_BYTE
9439 | OPTI_TYPE_USES_BITS_64;
9440 dgst_pos0 = 0;
9441 dgst_pos1 = 1;
9442 dgst_pos2 = 2;
9443 dgst_pos3 = 3;
9444 break;
9445
9446 case 8000: hash_type = HASH_TYPE_SHA256;
9447 salt_type = SALT_TYPE_EMBEDDED;
9448 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9449 opts_type = OPTS_TYPE_PT_GENERATE_BE
9450 | OPTS_TYPE_PT_UNICODE
9451 | OPTS_TYPE_ST_ADD80
9452 | OPTS_TYPE_ST_HEX;
9453 kern_type = KERN_TYPE_SYBASEASE;
9454 dgst_size = DGST_SIZE_4_8;
9455 parse_func = sybasease_parse_hash;
9456 sort_by_digest = sort_by_digest_4_8;
9457 opti_type = OPTI_TYPE_ZERO_BYTE
9458 | OPTI_TYPE_PRECOMPUTE_INIT
9459 | OPTI_TYPE_EARLY_SKIP
9460 | OPTI_TYPE_NOT_ITERATED
9461 | OPTI_TYPE_RAW_HASH;
9462 dgst_pos0 = 3;
9463 dgst_pos1 = 7;
9464 dgst_pos2 = 2;
9465 dgst_pos3 = 6;
9466 break;
9467
9468 case 8100: hash_type = HASH_TYPE_SHA1;
9469 salt_type = SALT_TYPE_EMBEDDED;
9470 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9471 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9472 kern_type = KERN_TYPE_NETSCALER;
9473 dgst_size = DGST_SIZE_4_5;
9474 parse_func = netscaler_parse_hash;
9475 sort_by_digest = sort_by_digest_4_5;
9476 opti_type = OPTI_TYPE_ZERO_BYTE
9477 | OPTI_TYPE_PRECOMPUTE_INIT
9478 | OPTI_TYPE_PRECOMPUTE_MERKLE
9479 | OPTI_TYPE_EARLY_SKIP
9480 | OPTI_TYPE_NOT_ITERATED
9481 | OPTI_TYPE_PREPENDED_SALT
9482 | OPTI_TYPE_RAW_HASH;
9483 dgst_pos0 = 3;
9484 dgst_pos1 = 4;
9485 dgst_pos2 = 2;
9486 dgst_pos3 = 1;
9487 break;
9488
9489 case 8200: hash_type = HASH_TYPE_SHA256;
9490 salt_type = SALT_TYPE_EMBEDDED;
9491 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9492 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9493 kern_type = KERN_TYPE_CLOUDKEY;
9494 dgst_size = DGST_SIZE_4_8;
9495 parse_func = cloudkey_parse_hash;
9496 sort_by_digest = sort_by_digest_4_8;
9497 opti_type = OPTI_TYPE_ZERO_BYTE;
9498 dgst_pos0 = 0;
9499 dgst_pos1 = 1;
9500 dgst_pos2 = 2;
9501 dgst_pos3 = 3;
9502 break;
9503
9504 case 8300: hash_type = HASH_TYPE_SHA1;
9505 salt_type = SALT_TYPE_EMBEDDED;
9506 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9507 opts_type = OPTS_TYPE_PT_GENERATE_BE
9508 | OPTS_TYPE_ST_HEX
9509 | OPTS_TYPE_ST_ADD80;
9510 kern_type = KERN_TYPE_NSEC3;
9511 dgst_size = DGST_SIZE_4_5;
9512 parse_func = nsec3_parse_hash;
9513 sort_by_digest = sort_by_digest_4_5;
9514 opti_type = OPTI_TYPE_ZERO_BYTE;
9515 dgst_pos0 = 3;
9516 dgst_pos1 = 4;
9517 dgst_pos2 = 2;
9518 dgst_pos3 = 1;
9519 break;
9520
9521 case 8400: hash_type = HASH_TYPE_SHA1;
9522 salt_type = SALT_TYPE_INTERN;
9523 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9524 opts_type = OPTS_TYPE_PT_GENERATE_BE
9525 | OPTS_TYPE_PT_ADD80
9526 | OPTS_TYPE_PT_ADDBITS15;
9527 kern_type = KERN_TYPE_WBB3;
9528 dgst_size = DGST_SIZE_4_5;
9529 parse_func = wbb3_parse_hash;
9530 sort_by_digest = sort_by_digest_4_5;
9531 opti_type = OPTI_TYPE_ZERO_BYTE
9532 | OPTI_TYPE_PRECOMPUTE_INIT
9533 | OPTI_TYPE_NOT_ITERATED;
9534 dgst_pos0 = 3;
9535 dgst_pos1 = 4;
9536 dgst_pos2 = 2;
9537 dgst_pos3 = 1;
9538 break;
9539
9540 case 8500: hash_type = HASH_TYPE_DESRACF;
9541 salt_type = SALT_TYPE_EMBEDDED;
9542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9543 opts_type = OPTS_TYPE_PT_GENERATE_LE
9544 | OPTS_TYPE_ST_UPPER;
9545 kern_type = KERN_TYPE_RACF;
9546 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9547 parse_func = racf_parse_hash;
9548 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9549 opti_type = OPTI_TYPE_ZERO_BYTE
9550 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9551 dgst_pos0 = 0;
9552 dgst_pos1 = 1;
9553 dgst_pos2 = 2;
9554 dgst_pos3 = 3;
9555 break;
9556
9557 case 8600: hash_type = HASH_TYPE_LOTUS5;
9558 salt_type = SALT_TYPE_NONE;
9559 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9560 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9561 kern_type = KERN_TYPE_LOTUS5;
9562 dgst_size = DGST_SIZE_4_4;
9563 parse_func = lotus5_parse_hash;
9564 sort_by_digest = sort_by_digest_4_4;
9565 opti_type = OPTI_TYPE_EARLY_SKIP
9566 | OPTI_TYPE_NOT_ITERATED
9567 | OPTI_TYPE_NOT_SALTED
9568 | OPTI_TYPE_RAW_HASH;
9569 dgst_pos0 = 0;
9570 dgst_pos1 = 1;
9571 dgst_pos2 = 2;
9572 dgst_pos3 = 3;
9573 break;
9574
9575 case 8700: hash_type = HASH_TYPE_LOTUS6;
9576 salt_type = SALT_TYPE_EMBEDDED;
9577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9578 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9579 kern_type = KERN_TYPE_LOTUS6;
9580 dgst_size = DGST_SIZE_4_4;
9581 parse_func = lotus6_parse_hash;
9582 sort_by_digest = sort_by_digest_4_4;
9583 opti_type = OPTI_TYPE_EARLY_SKIP
9584 | OPTI_TYPE_NOT_ITERATED
9585 | OPTI_TYPE_RAW_HASH;
9586 dgst_pos0 = 0;
9587 dgst_pos1 = 1;
9588 dgst_pos2 = 2;
9589 dgst_pos3 = 3;
9590 break;
9591
9592 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9593 salt_type = SALT_TYPE_EMBEDDED;
9594 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9595 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9596 kern_type = KERN_TYPE_ANDROIDFDE;
9597 dgst_size = DGST_SIZE_4_4;
9598 parse_func = androidfde_parse_hash;
9599 sort_by_digest = sort_by_digest_4_4;
9600 opti_type = OPTI_TYPE_ZERO_BYTE;
9601 dgst_pos0 = 0;
9602 dgst_pos1 = 1;
9603 dgst_pos2 = 2;
9604 dgst_pos3 = 3;
9605 break;
9606
9607 case 8900: hash_type = HASH_TYPE_SCRYPT;
9608 salt_type = SALT_TYPE_EMBEDDED;
9609 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9610 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9611 kern_type = KERN_TYPE_SCRYPT;
9612 dgst_size = DGST_SIZE_4_8;
9613 parse_func = scrypt_parse_hash;
9614 sort_by_digest = sort_by_digest_4_8;
9615 opti_type = OPTI_TYPE_ZERO_BYTE;
9616 dgst_pos0 = 0;
9617 dgst_pos1 = 1;
9618 dgst_pos2 = 2;
9619 dgst_pos3 = 3;
9620 break;
9621
9622 case 9000: hash_type = HASH_TYPE_SHA1;
9623 salt_type = SALT_TYPE_EMBEDDED;
9624 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9625 opts_type = OPTS_TYPE_PT_GENERATE_LE
9626 | OPTS_TYPE_ST_GENERATE_LE;
9627 kern_type = KERN_TYPE_PSAFE2;
9628 dgst_size = DGST_SIZE_4_5;
9629 parse_func = psafe2_parse_hash;
9630 sort_by_digest = sort_by_digest_4_5;
9631 opti_type = OPTI_TYPE_ZERO_BYTE;
9632 dgst_pos0 = 0;
9633 dgst_pos1 = 1;
9634 dgst_pos2 = 2;
9635 dgst_pos3 = 3;
9636 break;
9637
9638 case 9100: hash_type = HASH_TYPE_LOTUS8;
9639 salt_type = SALT_TYPE_EMBEDDED;
9640 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9641 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9642 kern_type = KERN_TYPE_LOTUS8;
9643 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9644 parse_func = lotus8_parse_hash;
9645 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9646 opti_type = OPTI_TYPE_ZERO_BYTE;
9647 dgst_pos0 = 0;
9648 dgst_pos1 = 1;
9649 dgst_pos2 = 2;
9650 dgst_pos3 = 3;
9651 break;
9652
9653 case 9200: hash_type = HASH_TYPE_SHA256;
9654 salt_type = SALT_TYPE_EMBEDDED;
9655 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9656 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9657 kern_type = KERN_TYPE_PBKDF2_SHA256;
9658 dgst_size = DGST_SIZE_4_32;
9659 parse_func = cisco8_parse_hash;
9660 sort_by_digest = sort_by_digest_4_32;
9661 opti_type = OPTI_TYPE_ZERO_BYTE
9662 | OPTI_TYPE_SLOW_HASH_SIMD;
9663 dgst_pos0 = 0;
9664 dgst_pos1 = 1;
9665 dgst_pos2 = 2;
9666 dgst_pos3 = 3;
9667 break;
9668
9669 case 9300: hash_type = HASH_TYPE_SCRYPT;
9670 salt_type = SALT_TYPE_EMBEDDED;
9671 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9672 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9673 kern_type = KERN_TYPE_SCRYPT;
9674 dgst_size = DGST_SIZE_4_8;
9675 parse_func = cisco9_parse_hash;
9676 sort_by_digest = sort_by_digest_4_8;
9677 opti_type = OPTI_TYPE_ZERO_BYTE;
9678 dgst_pos0 = 0;
9679 dgst_pos1 = 1;
9680 dgst_pos2 = 2;
9681 dgst_pos3 = 3;
9682 break;
9683
9684 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9685 salt_type = SALT_TYPE_EMBEDDED;
9686 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9687 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9688 kern_type = KERN_TYPE_OFFICE2007;
9689 dgst_size = DGST_SIZE_4_4;
9690 parse_func = office2007_parse_hash;
9691 sort_by_digest = sort_by_digest_4_4;
9692 opti_type = OPTI_TYPE_ZERO_BYTE;
9693 dgst_pos0 = 0;
9694 dgst_pos1 = 1;
9695 dgst_pos2 = 2;
9696 dgst_pos3 = 3;
9697 break;
9698
9699 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9700 salt_type = SALT_TYPE_EMBEDDED;
9701 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9702 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9703 kern_type = KERN_TYPE_OFFICE2010;
9704 dgst_size = DGST_SIZE_4_4;
9705 parse_func = office2010_parse_hash;
9706 sort_by_digest = sort_by_digest_4_4;
9707 opti_type = OPTI_TYPE_ZERO_BYTE;
9708 dgst_pos0 = 0;
9709 dgst_pos1 = 1;
9710 dgst_pos2 = 2;
9711 dgst_pos3 = 3;
9712 break;
9713
9714 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9715 salt_type = SALT_TYPE_EMBEDDED;
9716 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9717 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9718 kern_type = KERN_TYPE_OFFICE2013;
9719 dgst_size = DGST_SIZE_4_4;
9720 parse_func = office2013_parse_hash;
9721 sort_by_digest = sort_by_digest_4_4;
9722 opti_type = OPTI_TYPE_ZERO_BYTE;
9723 dgst_pos0 = 0;
9724 dgst_pos1 = 1;
9725 dgst_pos2 = 2;
9726 dgst_pos3 = 3;
9727 break;
9728
9729 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9730 salt_type = SALT_TYPE_EMBEDDED;
9731 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9732 opts_type = OPTS_TYPE_PT_GENERATE_LE
9733 | OPTS_TYPE_PT_ADD80
9734 | OPTS_TYPE_PT_UNICODE;
9735 kern_type = KERN_TYPE_OLDOFFICE01;
9736 dgst_size = DGST_SIZE_4_4;
9737 parse_func = oldoffice01_parse_hash;
9738 sort_by_digest = sort_by_digest_4_4;
9739 opti_type = OPTI_TYPE_ZERO_BYTE
9740 | OPTI_TYPE_PRECOMPUTE_INIT
9741 | OPTI_TYPE_NOT_ITERATED;
9742 dgst_pos0 = 0;
9743 dgst_pos1 = 1;
9744 dgst_pos2 = 2;
9745 dgst_pos3 = 3;
9746 break;
9747
9748 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9749 salt_type = SALT_TYPE_EMBEDDED;
9750 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9751 opts_type = OPTS_TYPE_PT_GENERATE_LE
9752 | OPTS_TYPE_PT_ADD80;
9753 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9754 dgst_size = DGST_SIZE_4_4;
9755 parse_func = oldoffice01cm1_parse_hash;
9756 sort_by_digest = sort_by_digest_4_4;
9757 opti_type = OPTI_TYPE_ZERO_BYTE
9758 | OPTI_TYPE_PRECOMPUTE_INIT
9759 | OPTI_TYPE_NOT_ITERATED;
9760 dgst_pos0 = 0;
9761 dgst_pos1 = 1;
9762 dgst_pos2 = 2;
9763 dgst_pos3 = 3;
9764 break;
9765
9766 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9767 salt_type = SALT_TYPE_EMBEDDED;
9768 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9769 opts_type = OPTS_TYPE_PT_GENERATE_LE
9770 | OPTS_TYPE_PT_ADD80
9771 | OPTS_TYPE_PT_UNICODE
9772 | OPTS_TYPE_PT_NEVERCRACK;
9773 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9774 dgst_size = DGST_SIZE_4_4;
9775 parse_func = oldoffice01cm2_parse_hash;
9776 sort_by_digest = sort_by_digest_4_4;
9777 opti_type = OPTI_TYPE_ZERO_BYTE
9778 | OPTI_TYPE_PRECOMPUTE_INIT
9779 | OPTI_TYPE_NOT_ITERATED;
9780 dgst_pos0 = 0;
9781 dgst_pos1 = 1;
9782 dgst_pos2 = 2;
9783 dgst_pos3 = 3;
9784 break;
9785
9786 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9787 salt_type = SALT_TYPE_EMBEDDED;
9788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9789 opts_type = OPTS_TYPE_PT_GENERATE_BE
9790 | OPTS_TYPE_PT_ADD80
9791 | OPTS_TYPE_PT_UNICODE;
9792 kern_type = KERN_TYPE_OLDOFFICE34;
9793 dgst_size = DGST_SIZE_4_4;
9794 parse_func = oldoffice34_parse_hash;
9795 sort_by_digest = sort_by_digest_4_4;
9796 opti_type = OPTI_TYPE_ZERO_BYTE
9797 | OPTI_TYPE_PRECOMPUTE_INIT
9798 | OPTI_TYPE_NOT_ITERATED;
9799 dgst_pos0 = 0;
9800 dgst_pos1 = 1;
9801 dgst_pos2 = 2;
9802 dgst_pos3 = 3;
9803 break;
9804
9805 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9806 salt_type = SALT_TYPE_EMBEDDED;
9807 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9808 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9809 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9810 dgst_size = DGST_SIZE_4_4;
9811 parse_func = oldoffice34cm1_parse_hash;
9812 sort_by_digest = sort_by_digest_4_4;
9813 opti_type = OPTI_TYPE_ZERO_BYTE
9814 | OPTI_TYPE_PRECOMPUTE_INIT
9815 | OPTI_TYPE_NOT_ITERATED;
9816 dgst_pos0 = 0;
9817 dgst_pos1 = 1;
9818 dgst_pos2 = 2;
9819 dgst_pos3 = 3;
9820 break;
9821
9822 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9823 salt_type = SALT_TYPE_EMBEDDED;
9824 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9825 opts_type = OPTS_TYPE_PT_GENERATE_BE
9826 | OPTS_TYPE_PT_ADD80
9827 | OPTS_TYPE_PT_UNICODE
9828 | OPTS_TYPE_PT_NEVERCRACK;
9829 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9830 dgst_size = DGST_SIZE_4_4;
9831 parse_func = oldoffice34cm2_parse_hash;
9832 sort_by_digest = sort_by_digest_4_4;
9833 opti_type = OPTI_TYPE_ZERO_BYTE
9834 | OPTI_TYPE_PRECOMPUTE_INIT
9835 | OPTI_TYPE_NOT_ITERATED;
9836 dgst_pos0 = 0;
9837 dgst_pos1 = 1;
9838 dgst_pos2 = 2;
9839 dgst_pos3 = 3;
9840 break;
9841
9842 case 9900: hash_type = HASH_TYPE_MD5;
9843 salt_type = SALT_TYPE_NONE;
9844 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9845 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9846 kern_type = KERN_TYPE_RADMIN2;
9847 dgst_size = DGST_SIZE_4_4;
9848 parse_func = radmin2_parse_hash;
9849 sort_by_digest = sort_by_digest_4_4;
9850 opti_type = OPTI_TYPE_ZERO_BYTE
9851 | OPTI_TYPE_PRECOMPUTE_INIT
9852 | OPTI_TYPE_EARLY_SKIP
9853 | OPTI_TYPE_NOT_ITERATED
9854 | OPTI_TYPE_NOT_SALTED;
9855 dgst_pos0 = 0;
9856 dgst_pos1 = 3;
9857 dgst_pos2 = 2;
9858 dgst_pos3 = 1;
9859 break;
9860
9861 case 10000: hash_type = HASH_TYPE_SHA256;
9862 salt_type = SALT_TYPE_EMBEDDED;
9863 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9864 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9865 kern_type = KERN_TYPE_PBKDF2_SHA256;
9866 dgst_size = DGST_SIZE_4_32;
9867 parse_func = djangopbkdf2_parse_hash;
9868 sort_by_digest = sort_by_digest_4_32;
9869 opti_type = OPTI_TYPE_ZERO_BYTE
9870 | OPTI_TYPE_SLOW_HASH_SIMD;
9871 dgst_pos0 = 0;
9872 dgst_pos1 = 1;
9873 dgst_pos2 = 2;
9874 dgst_pos3 = 3;
9875 break;
9876
9877 case 10100: hash_type = HASH_TYPE_SIPHASH;
9878 salt_type = SALT_TYPE_EMBEDDED;
9879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9880 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9881 kern_type = KERN_TYPE_SIPHASH;
9882 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9883 parse_func = siphash_parse_hash;
9884 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9885 opti_type = OPTI_TYPE_ZERO_BYTE
9886 | OPTI_TYPE_NOT_ITERATED
9887 | OPTI_TYPE_RAW_HASH;
9888 dgst_pos0 = 0;
9889 dgst_pos1 = 1;
9890 dgst_pos2 = 2;
9891 dgst_pos3 = 3;
9892 break;
9893
9894 case 10200: hash_type = HASH_TYPE_MD5;
9895 salt_type = SALT_TYPE_EMBEDDED;
9896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9897 opts_type = OPTS_TYPE_PT_GENERATE_LE
9898 | OPTS_TYPE_ST_ADD80
9899 | OPTS_TYPE_ST_ADDBITS14;
9900 kern_type = KERN_TYPE_HMACMD5_PW;
9901 dgst_size = DGST_SIZE_4_4;
9902 parse_func = crammd5_parse_hash;
9903 sort_by_digest = sort_by_digest_4_4;
9904 opti_type = OPTI_TYPE_ZERO_BYTE
9905 | OPTI_TYPE_NOT_ITERATED;
9906 dgst_pos0 = 0;
9907 dgst_pos1 = 3;
9908 dgst_pos2 = 2;
9909 dgst_pos3 = 1;
9910 break;
9911
9912 case 10300: hash_type = HASH_TYPE_SHA1;
9913 salt_type = SALT_TYPE_EMBEDDED;
9914 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9915 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9916 kern_type = KERN_TYPE_SAPH_SHA1;
9917 dgst_size = DGST_SIZE_4_5;
9918 parse_func = saph_sha1_parse_hash;
9919 sort_by_digest = sort_by_digest_4_5;
9920 opti_type = OPTI_TYPE_ZERO_BYTE;
9921 dgst_pos0 = 0;
9922 dgst_pos1 = 1;
9923 dgst_pos2 = 2;
9924 dgst_pos3 = 3;
9925 break;
9926
9927 case 10400: hash_type = HASH_TYPE_PDFU16;
9928 salt_type = SALT_TYPE_EMBEDDED;
9929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9930 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9931 kern_type = KERN_TYPE_PDF11;
9932 dgst_size = DGST_SIZE_4_4;
9933 parse_func = pdf11_parse_hash;
9934 sort_by_digest = sort_by_digest_4_4;
9935 opti_type = OPTI_TYPE_ZERO_BYTE
9936 | OPTI_TYPE_NOT_ITERATED;
9937 dgst_pos0 = 0;
9938 dgst_pos1 = 1;
9939 dgst_pos2 = 2;
9940 dgst_pos3 = 3;
9941 break;
9942
9943 case 10410: hash_type = HASH_TYPE_PDFU16;
9944 salt_type = SALT_TYPE_EMBEDDED;
9945 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9946 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9947 kern_type = KERN_TYPE_PDF11CM1;
9948 dgst_size = DGST_SIZE_4_4;
9949 parse_func = pdf11cm1_parse_hash;
9950 sort_by_digest = sort_by_digest_4_4;
9951 opti_type = OPTI_TYPE_ZERO_BYTE
9952 | OPTI_TYPE_NOT_ITERATED;
9953 dgst_pos0 = 0;
9954 dgst_pos1 = 1;
9955 dgst_pos2 = 2;
9956 dgst_pos3 = 3;
9957 break;
9958
9959 case 10420: hash_type = HASH_TYPE_PDFU16;
9960 salt_type = SALT_TYPE_EMBEDDED;
9961 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9962 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9963 kern_type = KERN_TYPE_PDF11CM2;
9964 dgst_size = DGST_SIZE_4_4;
9965 parse_func = pdf11cm2_parse_hash;
9966 sort_by_digest = sort_by_digest_4_4;
9967 opti_type = OPTI_TYPE_ZERO_BYTE
9968 | OPTI_TYPE_NOT_ITERATED;
9969 dgst_pos0 = 0;
9970 dgst_pos1 = 1;
9971 dgst_pos2 = 2;
9972 dgst_pos3 = 3;
9973 break;
9974
9975 case 10500: hash_type = HASH_TYPE_PDFU16;
9976 salt_type = SALT_TYPE_EMBEDDED;
9977 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9978 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9979 kern_type = KERN_TYPE_PDF14;
9980 dgst_size = DGST_SIZE_4_4;
9981 parse_func = pdf14_parse_hash;
9982 sort_by_digest = sort_by_digest_4_4;
9983 opti_type = OPTI_TYPE_ZERO_BYTE
9984 | OPTI_TYPE_NOT_ITERATED;
9985 dgst_pos0 = 0;
9986 dgst_pos1 = 1;
9987 dgst_pos2 = 2;
9988 dgst_pos3 = 3;
9989 break;
9990
9991 case 10600: hash_type = HASH_TYPE_SHA256;
9992 salt_type = SALT_TYPE_EMBEDDED;
9993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9994 opts_type = OPTS_TYPE_PT_GENERATE_BE
9995 | OPTS_TYPE_ST_ADD80
9996 | OPTS_TYPE_ST_ADDBITS15
9997 | OPTS_TYPE_HASH_COPY;
9998 kern_type = KERN_TYPE_SHA256_PWSLT;
9999 dgst_size = DGST_SIZE_4_8;
10000 parse_func = pdf17l3_parse_hash;
10001 sort_by_digest = sort_by_digest_4_8;
10002 opti_type = OPTI_TYPE_ZERO_BYTE
10003 | OPTI_TYPE_PRECOMPUTE_INIT
10004 | OPTI_TYPE_PRECOMPUTE_MERKLE
10005 | OPTI_TYPE_EARLY_SKIP
10006 | OPTI_TYPE_NOT_ITERATED
10007 | OPTI_TYPE_APPENDED_SALT
10008 | OPTI_TYPE_RAW_HASH;
10009 dgst_pos0 = 3;
10010 dgst_pos1 = 7;
10011 dgst_pos2 = 2;
10012 dgst_pos3 = 6;
10013 break;
10014
10015 case 10700: hash_type = HASH_TYPE_PDFU32;
10016 salt_type = SALT_TYPE_EMBEDDED;
10017 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10018 opts_type = OPTS_TYPE_PT_GENERATE_LE
10019 | OPTS_TYPE_HASH_COPY;
10020 kern_type = KERN_TYPE_PDF17L8;
10021 dgst_size = DGST_SIZE_4_8;
10022 parse_func = pdf17l8_parse_hash;
10023 sort_by_digest = sort_by_digest_4_8;
10024 opti_type = OPTI_TYPE_ZERO_BYTE
10025 | OPTI_TYPE_NOT_ITERATED;
10026 dgst_pos0 = 0;
10027 dgst_pos1 = 1;
10028 dgst_pos2 = 2;
10029 dgst_pos3 = 3;
10030 break;
10031
10032 case 10800: hash_type = HASH_TYPE_SHA384;
10033 salt_type = SALT_TYPE_NONE;
10034 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10035 opts_type = OPTS_TYPE_PT_GENERATE_BE
10036 | OPTS_TYPE_PT_ADD80
10037 | OPTS_TYPE_PT_ADDBITS15;
10038 kern_type = KERN_TYPE_SHA384;
10039 dgst_size = DGST_SIZE_8_8;
10040 parse_func = sha384_parse_hash;
10041 sort_by_digest = sort_by_digest_8_8;
10042 opti_type = OPTI_TYPE_ZERO_BYTE
10043 | OPTI_TYPE_PRECOMPUTE_INIT
10044 | OPTI_TYPE_PRECOMPUTE_MERKLE
10045 | OPTI_TYPE_EARLY_SKIP
10046 | OPTI_TYPE_NOT_ITERATED
10047 | OPTI_TYPE_NOT_SALTED
10048 | OPTI_TYPE_USES_BITS_64
10049 | OPTI_TYPE_RAW_HASH;
10050 dgst_pos0 = 6;
10051 dgst_pos1 = 7;
10052 dgst_pos2 = 4;
10053 dgst_pos3 = 5;
10054 break;
10055
10056 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10057 salt_type = SALT_TYPE_EMBEDDED;
10058 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10059 opts_type = OPTS_TYPE_PT_GENERATE_LE
10060 | OPTS_TYPE_ST_BASE64
10061 | OPTS_TYPE_HASH_COPY;
10062 kern_type = KERN_TYPE_PBKDF2_SHA256;
10063 dgst_size = DGST_SIZE_4_32;
10064 parse_func = pbkdf2_sha256_parse_hash;
10065 sort_by_digest = sort_by_digest_4_32;
10066 opti_type = OPTI_TYPE_ZERO_BYTE
10067 | OPTI_TYPE_SLOW_HASH_SIMD;
10068 dgst_pos0 = 0;
10069 dgst_pos1 = 1;
10070 dgst_pos2 = 2;
10071 dgst_pos3 = 3;
10072 break;
10073
10074 case 11000: hash_type = HASH_TYPE_MD5;
10075 salt_type = SALT_TYPE_INTERN;
10076 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10077 opts_type = OPTS_TYPE_PT_GENERATE_LE
10078 | OPTS_TYPE_PT_ADD80;
10079 kern_type = KERN_TYPE_PRESTASHOP;
10080 dgst_size = DGST_SIZE_4_4;
10081 parse_func = prestashop_parse_hash;
10082 sort_by_digest = sort_by_digest_4_4;
10083 opti_type = OPTI_TYPE_ZERO_BYTE
10084 | OPTI_TYPE_PRECOMPUTE_INIT
10085 | OPTI_TYPE_NOT_ITERATED
10086 | OPTI_TYPE_PREPENDED_SALT;
10087 dgst_pos0 = 0;
10088 dgst_pos1 = 3;
10089 dgst_pos2 = 2;
10090 dgst_pos3 = 1;
10091 break;
10092
10093 case 11100: hash_type = HASH_TYPE_MD5;
10094 salt_type = SALT_TYPE_EMBEDDED;
10095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10096 opts_type = OPTS_TYPE_PT_GENERATE_LE
10097 | OPTS_TYPE_ST_ADD80;
10098 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10099 dgst_size = DGST_SIZE_4_4;
10100 parse_func = postgresql_auth_parse_hash;
10101 sort_by_digest = sort_by_digest_4_4;
10102 opti_type = OPTI_TYPE_ZERO_BYTE
10103 | OPTI_TYPE_PRECOMPUTE_INIT
10104 | OPTI_TYPE_PRECOMPUTE_MERKLE
10105 | OPTI_TYPE_EARLY_SKIP;
10106 dgst_pos0 = 0;
10107 dgst_pos1 = 3;
10108 dgst_pos2 = 2;
10109 dgst_pos3 = 1;
10110 break;
10111
10112 case 11200: hash_type = HASH_TYPE_SHA1;
10113 salt_type = SALT_TYPE_EMBEDDED;
10114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10115 opts_type = OPTS_TYPE_PT_GENERATE_BE
10116 | OPTS_TYPE_PT_ADD80
10117 | OPTS_TYPE_ST_HEX;
10118 kern_type = KERN_TYPE_MYSQL_AUTH;
10119 dgst_size = DGST_SIZE_4_5;
10120 parse_func = mysql_auth_parse_hash;
10121 sort_by_digest = sort_by_digest_4_5;
10122 opti_type = OPTI_TYPE_ZERO_BYTE
10123 | OPTI_TYPE_EARLY_SKIP;
10124 dgst_pos0 = 3;
10125 dgst_pos1 = 4;
10126 dgst_pos2 = 2;
10127 dgst_pos3 = 1;
10128 break;
10129
10130 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10131 salt_type = SALT_TYPE_EMBEDDED;
10132 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10133 opts_type = OPTS_TYPE_PT_GENERATE_LE
10134 | OPTS_TYPE_ST_HEX
10135 | OPTS_TYPE_ST_ADD80;
10136 kern_type = KERN_TYPE_BITCOIN_WALLET;
10137 dgst_size = DGST_SIZE_4_4;
10138 parse_func = bitcoin_wallet_parse_hash;
10139 sort_by_digest = sort_by_digest_4_4;
10140 opti_type = OPTI_TYPE_ZERO_BYTE;
10141 dgst_pos0 = 0;
10142 dgst_pos1 = 1;
10143 dgst_pos2 = 2;
10144 dgst_pos3 = 3;
10145 break;
10146
10147 case 11400: hash_type = HASH_TYPE_MD5;
10148 salt_type = SALT_TYPE_EMBEDDED;
10149 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10150 opts_type = OPTS_TYPE_PT_GENERATE_LE
10151 | OPTS_TYPE_PT_ADD80
10152 | OPTS_TYPE_HASH_COPY;
10153 kern_type = KERN_TYPE_SIP_AUTH;
10154 dgst_size = DGST_SIZE_4_4;
10155 parse_func = sip_auth_parse_hash;
10156 sort_by_digest = sort_by_digest_4_4;
10157 opti_type = OPTI_TYPE_ZERO_BYTE;
10158 dgst_pos0 = 0;
10159 dgst_pos1 = 3;
10160 dgst_pos2 = 2;
10161 dgst_pos3 = 1;
10162 break;
10163
10164 case 11500: hash_type = HASH_TYPE_CRC32;
10165 salt_type = SALT_TYPE_INTERN;
10166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10167 opts_type = OPTS_TYPE_PT_GENERATE_LE
10168 | OPTS_TYPE_ST_GENERATE_LE
10169 | OPTS_TYPE_ST_HEX;
10170 kern_type = KERN_TYPE_CRC32;
10171 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10172 parse_func = crc32_parse_hash;
10173 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10174 opti_type = OPTI_TYPE_ZERO_BYTE;
10175 dgst_pos0 = 0;
10176 dgst_pos1 = 1;
10177 dgst_pos2 = 2;
10178 dgst_pos3 = 3;
10179 break;
10180
10181 case 11600: hash_type = HASH_TYPE_AES;
10182 salt_type = SALT_TYPE_EMBEDDED;
10183 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10184 opts_type = OPTS_TYPE_PT_GENERATE_LE
10185 | OPTS_TYPE_PT_NEVERCRACK;
10186 kern_type = KERN_TYPE_SEVEN_ZIP;
10187 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10188 parse_func = seven_zip_parse_hash;
10189 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10190 opti_type = OPTI_TYPE_ZERO_BYTE;
10191 dgst_pos0 = 0;
10192 dgst_pos1 = 1;
10193 dgst_pos2 = 2;
10194 dgst_pos3 = 3;
10195 break;
10196
10197 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10198 salt_type = SALT_TYPE_NONE;
10199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10200 opts_type = OPTS_TYPE_PT_GENERATE_LE
10201 | OPTS_TYPE_PT_ADD01;
10202 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10203 dgst_size = DGST_SIZE_4_8;
10204 parse_func = gost2012sbog_256_parse_hash;
10205 sort_by_digest = sort_by_digest_4_8;
10206 opti_type = OPTI_TYPE_ZERO_BYTE;
10207 dgst_pos0 = 0;
10208 dgst_pos1 = 1;
10209 dgst_pos2 = 2;
10210 dgst_pos3 = 3;
10211 break;
10212
10213 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10214 salt_type = SALT_TYPE_NONE;
10215 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10216 opts_type = OPTS_TYPE_PT_GENERATE_LE
10217 | OPTS_TYPE_PT_ADD01;
10218 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10219 dgst_size = DGST_SIZE_4_16;
10220 parse_func = gost2012sbog_512_parse_hash;
10221 sort_by_digest = sort_by_digest_4_16;
10222 opti_type = OPTI_TYPE_ZERO_BYTE;
10223 dgst_pos0 = 0;
10224 dgst_pos1 = 1;
10225 dgst_pos2 = 2;
10226 dgst_pos3 = 3;
10227 break;
10228
10229 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10230 salt_type = SALT_TYPE_EMBEDDED;
10231 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10232 opts_type = OPTS_TYPE_PT_GENERATE_LE
10233 | OPTS_TYPE_ST_BASE64
10234 | OPTS_TYPE_HASH_COPY;
10235 kern_type = KERN_TYPE_PBKDF2_MD5;
10236 dgst_size = DGST_SIZE_4_32;
10237 parse_func = pbkdf2_md5_parse_hash;
10238 sort_by_digest = sort_by_digest_4_32;
10239 opti_type = OPTI_TYPE_ZERO_BYTE
10240 | OPTI_TYPE_SLOW_HASH_SIMD;
10241 dgst_pos0 = 0;
10242 dgst_pos1 = 1;
10243 dgst_pos2 = 2;
10244 dgst_pos3 = 3;
10245 break;
10246
10247 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10248 salt_type = SALT_TYPE_EMBEDDED;
10249 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10250 opts_type = OPTS_TYPE_PT_GENERATE_LE
10251 | OPTS_TYPE_ST_BASE64
10252 | OPTS_TYPE_HASH_COPY;
10253 kern_type = KERN_TYPE_PBKDF2_SHA1;
10254 dgst_size = DGST_SIZE_4_32;
10255 parse_func = pbkdf2_sha1_parse_hash;
10256 sort_by_digest = sort_by_digest_4_32;
10257 opti_type = OPTI_TYPE_ZERO_BYTE
10258 | OPTI_TYPE_SLOW_HASH_SIMD;
10259 dgst_pos0 = 0;
10260 dgst_pos1 = 1;
10261 dgst_pos2 = 2;
10262 dgst_pos3 = 3;
10263 break;
10264
10265 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10266 salt_type = SALT_TYPE_EMBEDDED;
10267 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10268 opts_type = OPTS_TYPE_PT_GENERATE_LE
10269 | OPTS_TYPE_ST_BASE64
10270 | OPTS_TYPE_HASH_COPY;
10271 kern_type = KERN_TYPE_PBKDF2_SHA512;
10272 dgst_size = DGST_SIZE_8_16;
10273 parse_func = pbkdf2_sha512_parse_hash;
10274 sort_by_digest = sort_by_digest_8_16;
10275 opti_type = OPTI_TYPE_ZERO_BYTE
10276 | OPTI_TYPE_USES_BITS_64
10277 | OPTI_TYPE_SLOW_HASH_SIMD;
10278 dgst_pos0 = 0;
10279 dgst_pos1 = 1;
10280 dgst_pos2 = 2;
10281 dgst_pos3 = 3;
10282 break;
10283
10284 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10285 salt_type = SALT_TYPE_EMBEDDED;
10286 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10287 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10288 kern_type = KERN_TYPE_ECRYPTFS;
10289 dgst_size = DGST_SIZE_8_8;
10290 parse_func = ecryptfs_parse_hash;
10291 sort_by_digest = sort_by_digest_8_8;
10292 opti_type = OPTI_TYPE_ZERO_BYTE
10293 | OPTI_TYPE_USES_BITS_64;
10294 dgst_pos0 = 0;
10295 dgst_pos1 = 1;
10296 dgst_pos2 = 2;
10297 dgst_pos3 = 3;
10298 break;
10299
10300 case 12300: hash_type = HASH_TYPE_ORACLET;
10301 salt_type = SALT_TYPE_EMBEDDED;
10302 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10303 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10304 kern_type = KERN_TYPE_ORACLET;
10305 dgst_size = DGST_SIZE_8_16;
10306 parse_func = oraclet_parse_hash;
10307 sort_by_digest = sort_by_digest_8_16;
10308 opti_type = OPTI_TYPE_ZERO_BYTE
10309 | OPTI_TYPE_USES_BITS_64;
10310 dgst_pos0 = 0;
10311 dgst_pos1 = 1;
10312 dgst_pos2 = 2;
10313 dgst_pos3 = 3;
10314 break;
10315
10316 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10317 salt_type = SALT_TYPE_EMBEDDED;
10318 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10319 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10320 kern_type = KERN_TYPE_BSDICRYPT;
10321 dgst_size = DGST_SIZE_4_4;
10322 parse_func = bsdicrypt_parse_hash;
10323 sort_by_digest = sort_by_digest_4_4;
10324 opti_type = OPTI_TYPE_ZERO_BYTE
10325 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10326 dgst_pos0 = 0;
10327 dgst_pos1 = 1;
10328 dgst_pos2 = 2;
10329 dgst_pos3 = 3;
10330 break;
10331
10332 case 12500: hash_type = HASH_TYPE_RAR3HP;
10333 salt_type = SALT_TYPE_EMBEDDED;
10334 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10335 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10336 kern_type = KERN_TYPE_RAR3;
10337 dgst_size = DGST_SIZE_4_4;
10338 parse_func = rar3hp_parse_hash;
10339 sort_by_digest = sort_by_digest_4_4;
10340 opti_type = OPTI_TYPE_ZERO_BYTE;
10341 dgst_pos0 = 0;
10342 dgst_pos1 = 1;
10343 dgst_pos2 = 2;
10344 dgst_pos3 = 3;
10345 break;
10346
10347 case 12600: hash_type = HASH_TYPE_SHA256;
10348 salt_type = SALT_TYPE_INTERN;
10349 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10350 opts_type = OPTS_TYPE_PT_GENERATE_BE
10351 | OPTS_TYPE_PT_ADD80;
10352 kern_type = KERN_TYPE_CF10;
10353 dgst_size = DGST_SIZE_4_8;
10354 parse_func = cf10_parse_hash;
10355 sort_by_digest = sort_by_digest_4_8;
10356 opti_type = OPTI_TYPE_ZERO_BYTE
10357 | OPTI_TYPE_PRECOMPUTE_INIT
10358 | OPTI_TYPE_EARLY_SKIP
10359 | OPTI_TYPE_NOT_ITERATED;
10360 dgst_pos0 = 3;
10361 dgst_pos1 = 7;
10362 dgst_pos2 = 2;
10363 dgst_pos3 = 6;
10364 break;
10365
10366 case 12700: hash_type = HASH_TYPE_AES;
10367 salt_type = SALT_TYPE_EMBEDDED;
10368 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10369 opts_type = OPTS_TYPE_PT_GENERATE_LE
10370 | OPTS_TYPE_HASH_COPY;
10371 kern_type = KERN_TYPE_MYWALLET;
10372 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10373 parse_func = mywallet_parse_hash;
10374 sort_by_digest = sort_by_digest_4_5;
10375 opti_type = OPTI_TYPE_ZERO_BYTE;
10376 dgst_pos0 = 0;
10377 dgst_pos1 = 1;
10378 dgst_pos2 = 2;
10379 dgst_pos3 = 3;
10380 break;
10381
10382 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10383 salt_type = SALT_TYPE_EMBEDDED;
10384 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10385 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10386 kern_type = KERN_TYPE_MS_DRSR;
10387 dgst_size = DGST_SIZE_4_8;
10388 parse_func = ms_drsr_parse_hash;
10389 sort_by_digest = sort_by_digest_4_8;
10390 opti_type = OPTI_TYPE_ZERO_BYTE;
10391 dgst_pos0 = 0;
10392 dgst_pos1 = 1;
10393 dgst_pos2 = 2;
10394 dgst_pos3 = 3;
10395 break;
10396
10397 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10398 salt_type = SALT_TYPE_EMBEDDED;
10399 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10400 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10401 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10402 dgst_size = DGST_SIZE_4_8;
10403 parse_func = androidfde_samsung_parse_hash;
10404 sort_by_digest = sort_by_digest_4_8;
10405 opti_type = OPTI_TYPE_ZERO_BYTE;
10406 dgst_pos0 = 0;
10407 dgst_pos1 = 1;
10408 dgst_pos2 = 2;
10409 dgst_pos3 = 3;
10410 break;
10411
10412 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10413 salt_type = SALT_TYPE_EMBEDDED;
10414 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10415 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10416 kern_type = KERN_TYPE_RAR5;
10417 dgst_size = DGST_SIZE_4_4;
10418 parse_func = rar5_parse_hash;
10419 sort_by_digest = sort_by_digest_4_4;
10420 opti_type = OPTI_TYPE_ZERO_BYTE;
10421 dgst_pos0 = 0;
10422 dgst_pos1 = 1;
10423 dgst_pos2 = 2;
10424 dgst_pos3 = 3;
10425 break;
10426
10427 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10428 salt_type = SALT_TYPE_EMBEDDED;
10429 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10430 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10431 kern_type = KERN_TYPE_KRB5TGS;
10432 dgst_size = DGST_SIZE_4_4;
10433 parse_func = krb5tgs_parse_hash;
10434 sort_by_digest = sort_by_digest_4_4;
10435 opti_type = OPTI_TYPE_ZERO_BYTE
10436 | OPTI_TYPE_NOT_ITERATED;
10437 dgst_pos0 = 0;
10438 dgst_pos1 = 1;
10439 dgst_pos2 = 2;
10440 dgst_pos3 = 3;
10441 break;
10442
10443 case 13200: hash_type = HASH_TYPE_AES;
10444 salt_type = SALT_TYPE_EMBEDDED;
10445 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10446 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10447 kern_type = KERN_TYPE_AXCRYPT;
10448 dgst_size = DGST_SIZE_4_4;
10449 parse_func = axcrypt_parse_hash;
10450 sort_by_digest = sort_by_digest_4_4;
10451 opti_type = OPTI_TYPE_ZERO_BYTE;
10452 dgst_pos0 = 0;
10453 dgst_pos1 = 1;
10454 dgst_pos2 = 2;
10455 dgst_pos3 = 3;
10456 break;
10457
10458 case 13300: hash_type = HASH_TYPE_SHA1;
10459 salt_type = SALT_TYPE_NONE;
10460 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10461 opts_type = OPTS_TYPE_PT_GENERATE_BE
10462 | OPTS_TYPE_PT_ADD80
10463 | OPTS_TYPE_PT_ADDBITS15;
10464 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10465 dgst_size = DGST_SIZE_4_5;
10466 parse_func = sha1axcrypt_parse_hash;
10467 sort_by_digest = sort_by_digest_4_5;
10468 opti_type = OPTI_TYPE_ZERO_BYTE
10469 | OPTI_TYPE_PRECOMPUTE_INIT
10470 | OPTI_TYPE_EARLY_SKIP
10471 | OPTI_TYPE_NOT_ITERATED
10472 | OPTI_TYPE_NOT_SALTED;
10473 dgst_pos0 = 0;
10474 dgst_pos1 = 4;
10475 dgst_pos2 = 3;
10476 dgst_pos3 = 2;
10477 break;
10478
10479 case 13400: hash_type = HASH_TYPE_AES;
10480 salt_type = SALT_TYPE_EMBEDDED;
10481 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10482 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10483 kern_type = KERN_TYPE_KEEPASS;
10484 dgst_size = DGST_SIZE_4_4;
10485 parse_func = keepass_parse_hash;
10486 sort_by_digest = sort_by_digest_4_4;
10487 opti_type = OPTI_TYPE_ZERO_BYTE;
10488 dgst_pos0 = 0;
10489 dgst_pos1 = 1;
10490 dgst_pos2 = 2;
10491 dgst_pos3 = 3;
10492 break;
10493
10494 case 13500: hash_type = HASH_TYPE_SHA1;
10495 salt_type = SALT_TYPE_EMBEDDED;
10496 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10497 opts_type = OPTS_TYPE_PT_GENERATE_BE
10498 | OPTS_TYPE_PT_UNICODE
10499 | OPTS_TYPE_PT_ADD80;
10500 kern_type = KERN_TYPE_PSTOKEN;
10501 dgst_size = DGST_SIZE_4_5;
10502 parse_func = pstoken_parse_hash;
10503 sort_by_digest = sort_by_digest_4_5;
10504 opti_type = OPTI_TYPE_ZERO_BYTE
10505 | OPTI_TYPE_PRECOMPUTE_INIT
10506 | OPTI_TYPE_EARLY_SKIP
10507 | OPTI_TYPE_NOT_ITERATED
10508 | OPTI_TYPE_PREPENDED_SALT
10509 | OPTI_TYPE_RAW_HASH;
10510 dgst_pos0 = 3;
10511 dgst_pos1 = 4;
10512 dgst_pos2 = 2;
10513 dgst_pos3 = 1;
10514 break;
10515
10516 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10517 salt_type = SALT_TYPE_EMBEDDED;
10518 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10519 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10520 kern_type = KERN_TYPE_ZIP2;
10521 dgst_size = DGST_SIZE_4_4;
10522 parse_func = zip2_parse_hash;
10523 sort_by_digest = sort_by_digest_4_4;
10524 opti_type = OPTI_TYPE_ZERO_BYTE;
10525 dgst_pos0 = 0;
10526 dgst_pos1 = 1;
10527 dgst_pos2 = 2;
10528 dgst_pos3 = 3;
10529 break;
10530
10531 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10532 salt_type = SALT_TYPE_EMBEDDED;
10533 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10534 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10535 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10536 dgst_size = DGST_SIZE_4_5;
10537 parse_func = veracrypt_parse_hash_655331;
10538 sort_by_digest = sort_by_digest_4_5;
10539 opti_type = OPTI_TYPE_ZERO_BYTE;
10540 dgst_pos0 = 0;
10541 dgst_pos1 = 1;
10542 dgst_pos2 = 2;
10543 dgst_pos3 = 3;
10544 break;
10545
10546 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10547 salt_type = SALT_TYPE_EMBEDDED;
10548 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10549 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10550 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10551 dgst_size = DGST_SIZE_4_5;
10552 parse_func = veracrypt_parse_hash_655331;
10553 sort_by_digest = sort_by_digest_4_5;
10554 opti_type = OPTI_TYPE_ZERO_BYTE;
10555 dgst_pos0 = 0;
10556 dgst_pos1 = 1;
10557 dgst_pos2 = 2;
10558 dgst_pos3 = 3;
10559 break;
10560
10561 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10562 salt_type = SALT_TYPE_EMBEDDED;
10563 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10564 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10565 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10566 dgst_size = DGST_SIZE_4_5;
10567 parse_func = veracrypt_parse_hash_655331;
10568 sort_by_digest = sort_by_digest_4_5;
10569 opti_type = OPTI_TYPE_ZERO_BYTE;
10570 dgst_pos0 = 0;
10571 dgst_pos1 = 1;
10572 dgst_pos2 = 2;
10573 dgst_pos3 = 3;
10574 break;
10575
10576 case 13721: hash_type = HASH_TYPE_SHA512;
10577 salt_type = SALT_TYPE_EMBEDDED;
10578 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10579 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10580 kern_type = KERN_TYPE_TCSHA512_XTS512;
10581 dgst_size = DGST_SIZE_8_8;
10582 parse_func = veracrypt_parse_hash_500000;
10583 sort_by_digest = sort_by_digest_8_8;
10584 opti_type = OPTI_TYPE_ZERO_BYTE
10585 | OPTI_TYPE_USES_BITS_64;
10586 dgst_pos0 = 0;
10587 dgst_pos1 = 1;
10588 dgst_pos2 = 2;
10589 dgst_pos3 = 3;
10590 break;
10591
10592 case 13722: hash_type = HASH_TYPE_SHA512;
10593 salt_type = SALT_TYPE_EMBEDDED;
10594 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10595 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10596 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10597 dgst_size = DGST_SIZE_8_8;
10598 parse_func = veracrypt_parse_hash_500000;
10599 sort_by_digest = sort_by_digest_8_8;
10600 opti_type = OPTI_TYPE_ZERO_BYTE
10601 | OPTI_TYPE_USES_BITS_64;
10602 dgst_pos0 = 0;
10603 dgst_pos1 = 1;
10604 dgst_pos2 = 2;
10605 dgst_pos3 = 3;
10606 break;
10607
10608 case 13723: hash_type = HASH_TYPE_SHA512;
10609 salt_type = SALT_TYPE_EMBEDDED;
10610 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10611 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10612 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10613 dgst_size = DGST_SIZE_8_8;
10614 parse_func = veracrypt_parse_hash_500000;
10615 sort_by_digest = sort_by_digest_8_8;
10616 opti_type = OPTI_TYPE_ZERO_BYTE
10617 | OPTI_TYPE_USES_BITS_64;
10618 dgst_pos0 = 0;
10619 dgst_pos1 = 1;
10620 dgst_pos2 = 2;
10621 dgst_pos3 = 3;
10622 break;
10623
10624 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10625 salt_type = SALT_TYPE_EMBEDDED;
10626 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10627 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10628 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10629 dgst_size = DGST_SIZE_4_8;
10630 parse_func = veracrypt_parse_hash_500000;
10631 sort_by_digest = sort_by_digest_4_8;
10632 opti_type = OPTI_TYPE_ZERO_BYTE;
10633 dgst_pos0 = 0;
10634 dgst_pos1 = 1;
10635 dgst_pos2 = 2;
10636 dgst_pos3 = 3;
10637 break;
10638
10639 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10640 salt_type = SALT_TYPE_EMBEDDED;
10641 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10642 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10643 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10644 dgst_size = DGST_SIZE_4_8;
10645 parse_func = veracrypt_parse_hash_500000;
10646 sort_by_digest = sort_by_digest_4_8;
10647 opti_type = OPTI_TYPE_ZERO_BYTE;
10648 dgst_pos0 = 0;
10649 dgst_pos1 = 1;
10650 dgst_pos2 = 2;
10651 dgst_pos3 = 3;
10652 break;
10653
10654 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10655 salt_type = SALT_TYPE_EMBEDDED;
10656 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10657 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10658 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10659 dgst_size = DGST_SIZE_4_8;
10660 parse_func = veracrypt_parse_hash_500000;
10661 sort_by_digest = sort_by_digest_4_8;
10662 opti_type = OPTI_TYPE_ZERO_BYTE;
10663 dgst_pos0 = 0;
10664 dgst_pos1 = 1;
10665 dgst_pos2 = 2;
10666 dgst_pos3 = 3;
10667 break;
10668
10669 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10670 salt_type = SALT_TYPE_EMBEDDED;
10671 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10672 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10673 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10674 dgst_size = DGST_SIZE_4_5;
10675 parse_func = veracrypt_parse_hash_327661;
10676 sort_by_digest = sort_by_digest_4_5;
10677 opti_type = OPTI_TYPE_ZERO_BYTE;
10678 dgst_pos0 = 0;
10679 dgst_pos1 = 1;
10680 dgst_pos2 = 2;
10681 dgst_pos3 = 3;
10682 break;
10683
10684 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10685 salt_type = SALT_TYPE_EMBEDDED;
10686 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10687 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10688 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10689 dgst_size = DGST_SIZE_4_5;
10690 parse_func = veracrypt_parse_hash_327661;
10691 sort_by_digest = sort_by_digest_4_5;
10692 opti_type = OPTI_TYPE_ZERO_BYTE;
10693 dgst_pos0 = 0;
10694 dgst_pos1 = 1;
10695 dgst_pos2 = 2;
10696 dgst_pos3 = 3;
10697 break;
10698
10699 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10700 salt_type = SALT_TYPE_EMBEDDED;
10701 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10702 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10703 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10704 dgst_size = DGST_SIZE_4_5;
10705 parse_func = veracrypt_parse_hash_327661;
10706 sort_by_digest = sort_by_digest_4_5;
10707 opti_type = OPTI_TYPE_ZERO_BYTE;
10708 dgst_pos0 = 0;
10709 dgst_pos1 = 1;
10710 dgst_pos2 = 2;
10711 dgst_pos3 = 3;
10712 break;
10713
10714 case 13751: hash_type = HASH_TYPE_SHA256;
10715 salt_type = SALT_TYPE_EMBEDDED;
10716 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10717 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10718 kern_type = KERN_TYPE_VCSHA256_XTS512;
10719 dgst_size = DGST_SIZE_4_8;
10720 parse_func = veracrypt_parse_hash_500000;
10721 sort_by_digest = sort_by_digest_4_8;
10722 opti_type = OPTI_TYPE_ZERO_BYTE;
10723 dgst_pos0 = 0;
10724 dgst_pos1 = 1;
10725 dgst_pos2 = 2;
10726 dgst_pos3 = 3;
10727 break;
10728
10729 case 13752: hash_type = HASH_TYPE_SHA256;
10730 salt_type = SALT_TYPE_EMBEDDED;
10731 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10732 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10733 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10734 dgst_size = DGST_SIZE_4_8;
10735 parse_func = veracrypt_parse_hash_500000;
10736 sort_by_digest = sort_by_digest_4_8;
10737 opti_type = OPTI_TYPE_ZERO_BYTE;
10738 dgst_pos0 = 0;
10739 dgst_pos1 = 1;
10740 dgst_pos2 = 2;
10741 dgst_pos3 = 3;
10742 break;
10743
10744 case 13753: hash_type = HASH_TYPE_SHA256;
10745 salt_type = SALT_TYPE_EMBEDDED;
10746 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10747 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10748 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10749 dgst_size = DGST_SIZE_4_8;
10750 parse_func = veracrypt_parse_hash_500000;
10751 sort_by_digest = sort_by_digest_4_8;
10752 opti_type = OPTI_TYPE_ZERO_BYTE;
10753 dgst_pos0 = 0;
10754 dgst_pos1 = 1;
10755 dgst_pos2 = 2;
10756 dgst_pos3 = 3;
10757 break;
10758
10759 case 13761: hash_type = HASH_TYPE_SHA256;
10760 salt_type = SALT_TYPE_EMBEDDED;
10761 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10762 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10763 kern_type = KERN_TYPE_VCSHA256_XTS512;
10764 dgst_size = DGST_SIZE_4_8;
10765 parse_func = veracrypt_parse_hash_200000;
10766 sort_by_digest = sort_by_digest_4_8;
10767 opti_type = OPTI_TYPE_ZERO_BYTE;
10768 dgst_pos0 = 0;
10769 dgst_pos1 = 1;
10770 dgst_pos2 = 2;
10771 dgst_pos3 = 3;
10772 break;
10773
10774 case 13762: hash_type = HASH_TYPE_SHA256;
10775 salt_type = SALT_TYPE_EMBEDDED;
10776 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10777 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10778 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10779 dgst_size = DGST_SIZE_4_8;
10780 parse_func = veracrypt_parse_hash_200000;
10781 sort_by_digest = sort_by_digest_4_8;
10782 opti_type = OPTI_TYPE_ZERO_BYTE;
10783 dgst_pos0 = 0;
10784 dgst_pos1 = 1;
10785 dgst_pos2 = 2;
10786 dgst_pos3 = 3;
10787 break;
10788
10789 case 13763: hash_type = HASH_TYPE_SHA256;
10790 salt_type = SALT_TYPE_EMBEDDED;
10791 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10792 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10793 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10794 dgst_size = DGST_SIZE_4_8;
10795 parse_func = veracrypt_parse_hash_200000;
10796 sort_by_digest = sort_by_digest_4_8;
10797 opti_type = OPTI_TYPE_ZERO_BYTE;
10798 dgst_pos0 = 0;
10799 dgst_pos1 = 1;
10800 dgst_pos2 = 2;
10801 dgst_pos3 = 3;
10802 break;
10803
10804
10805 default: usage_mini_print (PROGNAME); return (-1);
10806 }
10807
10808 /**
10809 * parser
10810 */
10811
10812 data.parse_func = parse_func;
10813
10814 /**
10815 * misc stuff
10816 */
10817
10818 if (hex_salt)
10819 {
10820 if (salt_type == SALT_TYPE_INTERN)
10821 {
10822 opts_type |= OPTS_TYPE_ST_HEX;
10823 }
10824 else
10825 {
10826 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10827
10828 return (-1);
10829 }
10830 }
10831
10832 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10833 | (salt_type == SALT_TYPE_EXTERN)
10834 | (salt_type == SALT_TYPE_EMBEDDED)
10835 | (salt_type == SALT_TYPE_VIRTUAL));
10836
10837 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10838
10839 data.hash_type = hash_type;
10840 data.attack_mode = attack_mode;
10841 data.attack_kern = attack_kern;
10842 data.attack_exec = attack_exec;
10843 data.kern_type = kern_type;
10844 data.opts_type = opts_type;
10845 data.dgst_size = dgst_size;
10846 data.salt_type = salt_type;
10847 data.isSalted = isSalted;
10848 data.sort_by_digest = sort_by_digest;
10849 data.dgst_pos0 = dgst_pos0;
10850 data.dgst_pos1 = dgst_pos1;
10851 data.dgst_pos2 = dgst_pos2;
10852 data.dgst_pos3 = dgst_pos3;
10853
10854 esalt_size = 0;
10855
10856 switch (hash_mode)
10857 {
10858 case 2500: esalt_size = sizeof (wpa_t); break;
10859 case 5300: esalt_size = sizeof (ikepsk_t); break;
10860 case 5400: esalt_size = sizeof (ikepsk_t); break;
10861 case 5500: esalt_size = sizeof (netntlm_t); break;
10862 case 5600: esalt_size = sizeof (netntlm_t); break;
10863 case 6211: esalt_size = sizeof (tc_t); break;
10864 case 6212: esalt_size = sizeof (tc_t); break;
10865 case 6213: esalt_size = sizeof (tc_t); break;
10866 case 6221: esalt_size = sizeof (tc_t); break;
10867 case 6222: esalt_size = sizeof (tc_t); break;
10868 case 6223: esalt_size = sizeof (tc_t); break;
10869 case 6231: esalt_size = sizeof (tc_t); break;
10870 case 6232: esalt_size = sizeof (tc_t); break;
10871 case 6233: esalt_size = sizeof (tc_t); break;
10872 case 6241: esalt_size = sizeof (tc_t); break;
10873 case 6242: esalt_size = sizeof (tc_t); break;
10874 case 6243: esalt_size = sizeof (tc_t); break;
10875 case 6600: esalt_size = sizeof (agilekey_t); break;
10876 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10877 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10878 case 7300: esalt_size = sizeof (rakp_t); break;
10879 case 7500: esalt_size = sizeof (krb5pa_t); break;
10880 case 8200: esalt_size = sizeof (cloudkey_t); break;
10881 case 8800: esalt_size = sizeof (androidfde_t); break;
10882 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10883 case 9400: esalt_size = sizeof (office2007_t); break;
10884 case 9500: esalt_size = sizeof (office2010_t); break;
10885 case 9600: esalt_size = sizeof (office2013_t); break;
10886 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10887 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10888 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10889 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10890 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10891 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10892 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10893 case 10200: esalt_size = sizeof (cram_md5_t); break;
10894 case 10400: esalt_size = sizeof (pdf_t); break;
10895 case 10410: esalt_size = sizeof (pdf_t); break;
10896 case 10420: esalt_size = sizeof (pdf_t); break;
10897 case 10500: esalt_size = sizeof (pdf_t); break;
10898 case 10600: esalt_size = sizeof (pdf_t); break;
10899 case 10700: esalt_size = sizeof (pdf_t); break;
10900 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10901 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10902 case 11400: esalt_size = sizeof (sip_t); break;
10903 case 11600: esalt_size = sizeof (seven_zip_t); break;
10904 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10905 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10906 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10907 case 13000: esalt_size = sizeof (rar5_t); break;
10908 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10909 case 13400: esalt_size = sizeof (keepass_t); break;
10910 case 13500: esalt_size = sizeof (pstoken_t); break;
10911 case 13600: esalt_size = sizeof (zip2_t); break;
10912 case 13711: esalt_size = sizeof (tc_t); break;
10913 case 13712: esalt_size = sizeof (tc_t); break;
10914 case 13713: esalt_size = sizeof (tc_t); break;
10915 case 13721: esalt_size = sizeof (tc_t); break;
10916 case 13722: esalt_size = sizeof (tc_t); break;
10917 case 13723: esalt_size = sizeof (tc_t); break;
10918 case 13731: esalt_size = sizeof (tc_t); break;
10919 case 13732: esalt_size = sizeof (tc_t); break;
10920 case 13733: esalt_size = sizeof (tc_t); break;
10921 case 13741: esalt_size = sizeof (tc_t); break;
10922 case 13742: esalt_size = sizeof (tc_t); break;
10923 case 13743: esalt_size = sizeof (tc_t); break;
10924 case 13751: esalt_size = sizeof (tc_t); break;
10925 case 13752: esalt_size = sizeof (tc_t); break;
10926 case 13753: esalt_size = sizeof (tc_t); break;
10927 case 13761: esalt_size = sizeof (tc_t); break;
10928 case 13762: esalt_size = sizeof (tc_t); break;
10929 case 13763: esalt_size = sizeof (tc_t); break;
10930 }
10931
10932 data.esalt_size = esalt_size;
10933
10934 /**
10935 * choose dictionary parser
10936 */
10937
10938 if (hash_type == HASH_TYPE_LM)
10939 {
10940 get_next_word_func = get_next_word_lm;
10941 }
10942 else if (opts_type & OPTS_TYPE_PT_UPPER)
10943 {
10944 get_next_word_func = get_next_word_uc;
10945 }
10946 else
10947 {
10948 get_next_word_func = get_next_word_std;
10949 }
10950
10951 /**
10952 * dictstat
10953 */
10954
10955 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10956
10957 #ifdef _POSIX
10958 size_t dictstat_nmemb = 0;
10959 #endif
10960
10961 #ifdef _WIN
10962 uint dictstat_nmemb = 0;
10963 #endif
10964
10965 char dictstat[256] = { 0 };
10966
10967 FILE *dictstat_fp = NULL;
10968
10969 if (keyspace == 0)
10970 {
10971 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10972
10973 dictstat_fp = fopen (dictstat, "rb");
10974
10975 if (dictstat_fp)
10976 {
10977 #ifdef _POSIX
10978 struct stat tmpstat;
10979
10980 fstat (fileno (dictstat_fp), &tmpstat);
10981 #endif
10982
10983 #ifdef _WIN
10984 struct stat64 tmpstat;
10985
10986 _fstat64 (fileno (dictstat_fp), &tmpstat);
10987 #endif
10988
10989 if (tmpstat.st_mtime < COMPTIME)
10990 {
10991 /* with v0.15 the format changed so we have to ensure user is using a good version
10992 since there is no version-header in the dictstat file */
10993
10994 fclose (dictstat_fp);
10995
10996 unlink (dictstat);
10997 }
10998 else
10999 {
11000 while (!feof (dictstat_fp))
11001 {
11002 dictstat_t d;
11003
11004 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11005
11006 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11007
11008 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11009 {
11010 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11011
11012 return -1;
11013 }
11014 }
11015
11016 fclose (dictstat_fp);
11017 }
11018 }
11019 }
11020
11021 /**
11022 * potfile
11023 */
11024
11025 char potfile[256] = { 0 };
11026
11027 if (potfile_path == NULL)
11028 {
11029 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11030 }
11031 else
11032 {
11033 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11034 }
11035
11036 data.pot_fp = NULL;
11037
11038 FILE *out_fp = NULL;
11039 FILE *pot_fp = NULL;
11040
11041 if (show == 1 || left == 1)
11042 {
11043 pot_fp = fopen (potfile, "rb");
11044
11045 if (pot_fp == NULL)
11046 {
11047 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11048
11049 return (-1);
11050 }
11051
11052 if (outfile != NULL)
11053 {
11054 if ((out_fp = fopen (outfile, "ab")) == NULL)
11055 {
11056 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11057
11058 fclose (pot_fp);
11059
11060 return (-1);
11061 }
11062 }
11063 else
11064 {
11065 out_fp = stdout;
11066 }
11067 }
11068 else
11069 {
11070 if (potfile_disable == 0)
11071 {
11072 pot_fp = fopen (potfile, "ab");
11073
11074 if (pot_fp == NULL)
11075 {
11076 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11077
11078 return (-1);
11079 }
11080
11081 data.pot_fp = pot_fp;
11082 }
11083 }
11084
11085 pot_t *pot = NULL;
11086
11087 uint pot_cnt = 0;
11088 uint pot_avail = 0;
11089
11090 if (show == 1 || left == 1)
11091 {
11092 SUPPRESS_OUTPUT = 1;
11093
11094 pot_avail = count_lines (pot_fp);
11095
11096 rewind (pot_fp);
11097
11098 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11099
11100 uint pot_hashes_avail = 0;
11101
11102 uint line_num = 0;
11103
11104 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11105
11106 while (!feof (pot_fp))
11107 {
11108 line_num++;
11109
11110 int line_len = fgetl (pot_fp, line_buf);
11111
11112 if (line_len == 0) continue;
11113
11114 char *plain_buf = line_buf + line_len;
11115
11116 pot_t *pot_ptr = &pot[pot_cnt];
11117
11118 hash_t *hashes_buf = &pot_ptr->hash;
11119
11120 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11121 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11122
11123 if (pot_cnt == pot_hashes_avail)
11124 {
11125 uint pos = 0;
11126
11127 for (pos = 0; pos < INCR_POT; pos++)
11128 {
11129 if ((pot_cnt + pos) >= pot_avail) break;
11130
11131 pot_t *tmp_pot = &pot[pot_cnt + pos];
11132
11133 hash_t *tmp_hash = &tmp_pot->hash;
11134
11135 tmp_hash->digest = mymalloc (dgst_size);
11136
11137 if (isSalted)
11138 {
11139 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11140 }
11141
11142 if (esalt_size)
11143 {
11144 tmp_hash->esalt = mymalloc (esalt_size);
11145 }
11146
11147 pot_hashes_avail++;
11148 }
11149 }
11150
11151 int plain_len = 0;
11152
11153 int parser_status;
11154
11155 int iter = MAX_CUT_TRIES;
11156
11157 do
11158 {
11159 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11160 {
11161 if (line_buf[i] == ':')
11162 {
11163 line_len--;
11164
11165 break;
11166 }
11167 }
11168
11169 if (data.hash_mode != 2500)
11170 {
11171 parser_status = parse_func (line_buf, line_len, hashes_buf);
11172 }
11173 else
11174 {
11175 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11176
11177 if (line_len > max_salt_size)
11178 {
11179 parser_status = PARSER_GLOBAL_LENGTH;
11180 }
11181 else
11182 {
11183 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11184
11185 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11186
11187 hashes_buf->salt->salt_len = line_len;
11188
11189 parser_status = PARSER_OK;
11190 }
11191 }
11192
11193 // if NOT parsed without error, we add the ":" to the plain
11194
11195 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11196 {
11197 plain_len++;
11198 plain_buf--;
11199 }
11200
11201 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11202
11203 if (parser_status < PARSER_GLOBAL_ZERO)
11204 {
11205 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11206
11207 continue;
11208 }
11209
11210 if (plain_len >= 255) continue;
11211
11212 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11213
11214 pot_ptr->plain_len = plain_len;
11215
11216 pot_cnt++;
11217 }
11218
11219 myfree (line_buf);
11220
11221 fclose (pot_fp);
11222
11223 SUPPRESS_OUTPUT = 0;
11224
11225 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11226 }
11227
11228 /**
11229 * word len
11230 */
11231
11232 uint pw_min = PW_MIN;
11233 uint pw_max = PW_MAX;
11234
11235 switch (hash_mode)
11236 {
11237 case 125: if (pw_max > 32) pw_max = 32;
11238 break;
11239 case 400: if (pw_max > 40) pw_max = 40;
11240 break;
11241 case 500: if (pw_max > 16) pw_max = 16;
11242 break;
11243 case 1500: if (pw_max > 8) pw_max = 8;
11244 break;
11245 case 1600: if (pw_max > 16) pw_max = 16;
11246 break;
11247 case 1800: if (pw_max > 16) pw_max = 16;
11248 break;
11249 case 2100: if (pw_max > 16) pw_max = 16;
11250 break;
11251 case 2500: if (pw_min < 8) pw_min = 8;
11252 break;
11253 case 3000: if (pw_max > 7) pw_max = 7;
11254 break;
11255 case 5200: if (pw_max > 24) pw_max = 24;
11256 break;
11257 case 5800: if (pw_max > 16) pw_max = 16;
11258 break;
11259 case 6300: if (pw_max > 16) pw_max = 16;
11260 break;
11261 case 7400: if (pw_max > 16) pw_max = 16;
11262 break;
11263 case 7500: if (pw_max > 8) pw_max = 8;
11264 break;
11265 case 7900: if (pw_max > 48) pw_max = 48;
11266 break;
11267 case 8500: if (pw_max > 8) pw_max = 8;
11268 break;
11269 case 8600: if (pw_max > 16) pw_max = 16;
11270 break;
11271 case 9710: pw_min = 5;
11272 pw_max = 5;
11273 break;
11274 case 9810: pw_min = 5;
11275 pw_max = 5;
11276 break;
11277 case 10410: pw_min = 5;
11278 pw_max = 5;
11279 break;
11280 case 10300: if (pw_max < 3) pw_min = 3;
11281 if (pw_max > 40) pw_max = 40;
11282 break;
11283 case 10500: if (pw_max < 3) pw_min = 3;
11284 if (pw_max > 40) pw_max = 40;
11285 break;
11286 case 10700: if (pw_max > 16) pw_max = 16;
11287 break;
11288 case 11300: if (pw_max > 40) pw_max = 40;
11289 break;
11290 case 11600: if (pw_max > 32) pw_max = 32;
11291 break;
11292 case 12500: if (pw_max > 20) pw_max = 20;
11293 break;
11294 case 12800: if (pw_max > 24) pw_max = 24;
11295 break;
11296 }
11297
11298 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11299 {
11300 switch (attack_kern)
11301 {
11302 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11303 break;
11304 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11305 break;
11306 }
11307 }
11308
11309 /**
11310 * charsets : keep them together for more easy maintainnce
11311 */
11312
11313 cs_t mp_sys[6] = { { { 0 }, 0 } };
11314 cs_t mp_usr[4] = { { { 0 }, 0 } };
11315
11316 mp_setup_sys (mp_sys);
11317
11318 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11319 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11320 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11321 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11322
11323 /**
11324 * load hashes, part I: find input mode, count hashes
11325 */
11326
11327 uint hashlist_mode = 0;
11328 uint hashlist_format = HLFMT_HASHCAT;
11329
11330 uint hashes_avail = 0;
11331
11332 if (benchmark == 0)
11333 {
11334 struct stat f;
11335
11336 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11337
11338 if ((hash_mode == 2500) ||
11339 (hash_mode == 5200) ||
11340 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11341 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11342 (hash_mode == 9000))
11343 {
11344 hashlist_mode = HL_MODE_ARG;
11345
11346 char *hashfile = myargv[optind];
11347
11348 data.hashfile = hashfile;
11349
11350 logfile_top_var_string ("target", hashfile);
11351 }
11352
11353 if (hashlist_mode == HL_MODE_ARG)
11354 {
11355 if (hash_mode == 2500)
11356 {
11357 struct stat st;
11358
11359 if (stat (data.hashfile, &st) == -1)
11360 {
11361 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11362
11363 return (-1);
11364 }
11365
11366 hashes_avail = st.st_size / sizeof (hccap_t);
11367 }
11368 else
11369 {
11370 hashes_avail = 1;
11371 }
11372 }
11373 else if (hashlist_mode == HL_MODE_FILE)
11374 {
11375 char *hashfile = myargv[optind];
11376
11377 data.hashfile = hashfile;
11378
11379 logfile_top_var_string ("target", hashfile);
11380
11381 FILE *fp = NULL;
11382
11383 if ((fp = fopen (hashfile, "rb")) == NULL)
11384 {
11385 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11386
11387 return (-1);
11388 }
11389
11390 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11391
11392 hashes_avail = count_lines (fp);
11393
11394 rewind (fp);
11395
11396 if (hashes_avail == 0)
11397 {
11398 log_error ("ERROR: hashfile is empty or corrupt");
11399
11400 fclose (fp);
11401
11402 return (-1);
11403 }
11404
11405 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11406
11407 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11408 {
11409 log_error ("ERROR: remove not supported in native hashfile-format mode");
11410
11411 fclose (fp);
11412
11413 return (-1);
11414 }
11415
11416 fclose (fp);
11417 }
11418 }
11419 else
11420 {
11421 hashlist_mode = HL_MODE_ARG;
11422
11423 hashes_avail = 1;
11424 }
11425
11426 if (hash_mode == 3000) hashes_avail *= 2;
11427
11428 data.hashlist_mode = hashlist_mode;
11429 data.hashlist_format = hashlist_format;
11430
11431 logfile_top_uint (hashlist_mode);
11432 logfile_top_uint (hashlist_format);
11433
11434 /**
11435 * load hashes, part II: allocate required memory, set pointers
11436 */
11437
11438 hash_t *hashes_buf = NULL;
11439 void *digests_buf = NULL;
11440 salt_t *salts_buf = NULL;
11441 void *esalts_buf = NULL;
11442
11443 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11444
11445 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11446
11447 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11448 {
11449 u32 hash_pos;
11450
11451 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11452 {
11453 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11454
11455 hashes_buf[hash_pos].hash_info = hash_info;
11456
11457 if (username && (remove || show || left))
11458 {
11459 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11460 }
11461
11462 if (benchmark)
11463 {
11464 hash_info->orighash = (char *) mymalloc (256);
11465 }
11466 }
11467 }
11468
11469 if (isSalted)
11470 {
11471 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11472
11473 if (esalt_size)
11474 {
11475 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11476 }
11477 }
11478 else
11479 {
11480 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11481 }
11482
11483 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11484 {
11485 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11486
11487 if (isSalted)
11488 {
11489 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11490
11491 if (esalt_size)
11492 {
11493 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11494 }
11495 }
11496 else
11497 {
11498 hashes_buf[hash_pos].salt = &salts_buf[0];
11499 }
11500 }
11501
11502 /**
11503 * load hashes, part III: parse hashes or generate them if benchmark
11504 */
11505
11506 uint hashes_cnt = 0;
11507
11508 if (benchmark == 0)
11509 {
11510 if (keyspace == 1)
11511 {
11512 // useless to read hash file for keyspace, cheat a little bit w/ optind
11513 }
11514 else if (hashes_avail == 0)
11515 {
11516 }
11517 else if (hashlist_mode == HL_MODE_ARG)
11518 {
11519 char *input_buf = myargv[optind];
11520
11521 uint input_len = strlen (input_buf);
11522
11523 logfile_top_var_string ("target", input_buf);
11524
11525 char *hash_buf = NULL;
11526 int hash_len = 0;
11527
11528 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11529
11530 bool hash_fmt_error = 0;
11531
11532 if (hash_len < 1) hash_fmt_error = 1;
11533 if (hash_buf == NULL) hash_fmt_error = 1;
11534
11535 if (hash_fmt_error)
11536 {
11537 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11538 }
11539 else
11540 {
11541 if (opts_type & OPTS_TYPE_HASH_COPY)
11542 {
11543 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11544
11545 hash_info_tmp->orighash = mystrdup (hash_buf);
11546 }
11547
11548 if (isSalted)
11549 {
11550 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11551 }
11552
11553 int parser_status = PARSER_OK;
11554
11555 if (hash_mode == 2500)
11556 {
11557 if (hash_len == 0)
11558 {
11559 log_error ("ERROR: hccap file not specified");
11560
11561 return (-1);
11562 }
11563
11564 hashlist_mode = HL_MODE_FILE;
11565
11566 data.hashlist_mode = hashlist_mode;
11567
11568 FILE *fp = fopen (hash_buf, "rb");
11569
11570 if (fp == NULL)
11571 {
11572 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11573
11574 return (-1);
11575 }
11576
11577 if (hashes_avail < 1)
11578 {
11579 log_error ("ERROR: hccap file is empty or corrupt");
11580
11581 fclose (fp);
11582
11583 return (-1);
11584 }
11585
11586 uint hccap_size = sizeof (hccap_t);
11587
11588 char *in = (char *) mymalloc (hccap_size);
11589
11590 while (!feof (fp))
11591 {
11592 int n = fread (in, hccap_size, 1, fp);
11593
11594 if (n != 1)
11595 {
11596 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11597
11598 break;
11599 }
11600
11601 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11602
11603 if (parser_status != PARSER_OK)
11604 {
11605 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11606
11607 continue;
11608 }
11609
11610 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11611
11612 if ((show == 1) || (left == 1))
11613 {
11614 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11615
11616 char *salt_ptr = (char *) tmp_salt->salt_buf;
11617
11618 int cur_pos = tmp_salt->salt_len;
11619 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11620
11621 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11622
11623 // do the appending task
11624
11625 snprintf (salt_ptr + cur_pos,
11626 rem_len,
11627 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11628 wpa->orig_mac1[0],
11629 wpa->orig_mac1[1],
11630 wpa->orig_mac1[2],
11631 wpa->orig_mac1[3],
11632 wpa->orig_mac1[4],
11633 wpa->orig_mac1[5],
11634 wpa->orig_mac2[0],
11635 wpa->orig_mac2[1],
11636 wpa->orig_mac2[2],
11637 wpa->orig_mac2[3],
11638 wpa->orig_mac2[4],
11639 wpa->orig_mac2[5]);
11640
11641 // memset () the remaining part of the salt
11642
11643 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11644 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11645
11646 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11647
11648 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11649 }
11650
11651 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);
11652 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);
11653
11654 hashes_cnt++;
11655 }
11656
11657 fclose (fp);
11658
11659 myfree (in);
11660 }
11661 else if (hash_mode == 3000)
11662 {
11663 if (hash_len == 32)
11664 {
11665 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11666
11667 hash_t *lm_hash_left = NULL;
11668
11669 if (parser_status == PARSER_OK)
11670 {
11671 lm_hash_left = &hashes_buf[hashes_cnt];
11672
11673 hashes_cnt++;
11674 }
11675 else
11676 {
11677 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11678 }
11679
11680 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11681
11682 hash_t *lm_hash_right = NULL;
11683
11684 if (parser_status == PARSER_OK)
11685 {
11686 lm_hash_right = &hashes_buf[hashes_cnt];
11687
11688 hashes_cnt++;
11689 }
11690 else
11691 {
11692 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11693 }
11694
11695 // show / left
11696
11697 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11698 {
11699 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);
11700 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);
11701 }
11702 }
11703 else
11704 {
11705 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11706
11707 if (parser_status == PARSER_OK)
11708 {
11709 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11710 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11711 }
11712
11713 if (parser_status == PARSER_OK)
11714 {
11715 hashes_cnt++;
11716 }
11717 else
11718 {
11719 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11720 }
11721 }
11722 }
11723 else
11724 {
11725 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11726
11727 if (parser_status == PARSER_OK)
11728 {
11729 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11730 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11731 }
11732
11733 if (parser_status == PARSER_OK)
11734 {
11735 hashes_cnt++;
11736 }
11737 else
11738 {
11739 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11740 }
11741 }
11742 }
11743 }
11744 else if (hashlist_mode == HL_MODE_FILE)
11745 {
11746 char *hashfile = data.hashfile;
11747
11748 FILE *fp;
11749
11750 if ((fp = fopen (hashfile, "rb")) == NULL)
11751 {
11752 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11753
11754 return (-1);
11755 }
11756
11757 uint line_num = 0;
11758
11759 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11760
11761 while (!feof (fp))
11762 {
11763 line_num++;
11764
11765 int line_len = fgetl (fp, line_buf);
11766
11767 if (line_len == 0) continue;
11768
11769 char *hash_buf = NULL;
11770 int hash_len = 0;
11771
11772 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11773
11774 bool hash_fmt_error = 0;
11775
11776 if (hash_len < 1) hash_fmt_error = 1;
11777 if (hash_buf == NULL) hash_fmt_error = 1;
11778
11779 if (hash_fmt_error)
11780 {
11781 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11782
11783 continue;
11784 }
11785
11786 if (username)
11787 {
11788 char *user_buf = NULL;
11789 int user_len = 0;
11790
11791 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11792
11793 if (remove || show)
11794 {
11795 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11796
11797 *user = (user_t *) mymalloc (sizeof (user_t));
11798
11799 user_t *user_ptr = *user;
11800
11801 if (user_buf != NULL)
11802 {
11803 user_ptr->user_name = mystrdup (user_buf);
11804 }
11805 else
11806 {
11807 user_ptr->user_name = mystrdup ("");
11808 }
11809
11810 user_ptr->user_len = user_len;
11811 }
11812 }
11813
11814 if (opts_type & OPTS_TYPE_HASH_COPY)
11815 {
11816 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11817
11818 hash_info_tmp->orighash = mystrdup (hash_buf);
11819 }
11820
11821 if (isSalted)
11822 {
11823 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11824 }
11825
11826 if (hash_mode == 3000)
11827 {
11828 if (hash_len == 32)
11829 {
11830 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11831
11832 if (parser_status < PARSER_GLOBAL_ZERO)
11833 {
11834 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11835
11836 continue;
11837 }
11838
11839 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11840
11841 hashes_cnt++;
11842
11843 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11844
11845 if (parser_status < PARSER_GLOBAL_ZERO)
11846 {
11847 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11848
11849 continue;
11850 }
11851
11852 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11853
11854 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);
11855
11856 hashes_cnt++;
11857
11858 // show / left
11859
11860 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);
11861 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);
11862 }
11863 else
11864 {
11865 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11866
11867 if (parser_status < PARSER_GLOBAL_ZERO)
11868 {
11869 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11870
11871 continue;
11872 }
11873
11874 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);
11875
11876 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11877 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11878
11879 hashes_cnt++;
11880 }
11881 }
11882 else
11883 {
11884 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11885
11886 if (parser_status < PARSER_GLOBAL_ZERO)
11887 {
11888 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11889
11890 continue;
11891 }
11892
11893 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);
11894
11895 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11896 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11897
11898 hashes_cnt++;
11899 }
11900 }
11901
11902 myfree (line_buf);
11903
11904 fclose (fp);
11905
11906 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11907
11908 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11909 }
11910 }
11911 else
11912 {
11913 if (isSalted)
11914 {
11915 hashes_buf[0].salt->salt_len = 8;
11916
11917 // special salt handling
11918
11919 switch (hash_mode)
11920 {
11921 case 1500: hashes_buf[0].salt->salt_len = 2;
11922 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11923 break;
11924 case 1731: hashes_buf[0].salt->salt_len = 4;
11925 break;
11926 case 2410: hashes_buf[0].salt->salt_len = 4;
11927 break;
11928 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11929 break;
11930 case 3100: hashes_buf[0].salt->salt_len = 1;
11931 break;
11932 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11933 break;
11934 case 5800: hashes_buf[0].salt->salt_len = 16;
11935 break;
11936 case 6800: hashes_buf[0].salt->salt_len = 32;
11937 break;
11938 case 8400: hashes_buf[0].salt->salt_len = 40;
11939 break;
11940 case 8800: hashes_buf[0].salt->salt_len = 16;
11941 break;
11942 case 8900: hashes_buf[0].salt->salt_len = 16;
11943 hashes_buf[0].salt->scrypt_N = 1024;
11944 hashes_buf[0].salt->scrypt_r = 1;
11945 hashes_buf[0].salt->scrypt_p = 1;
11946 break;
11947 case 9100: hashes_buf[0].salt->salt_len = 16;
11948 break;
11949 case 9300: hashes_buf[0].salt->salt_len = 14;
11950 hashes_buf[0].salt->scrypt_N = 16384;
11951 hashes_buf[0].salt->scrypt_r = 1;
11952 hashes_buf[0].salt->scrypt_p = 1;
11953 break;
11954 case 9400: hashes_buf[0].salt->salt_len = 16;
11955 break;
11956 case 9500: hashes_buf[0].salt->salt_len = 16;
11957 break;
11958 case 9600: hashes_buf[0].salt->salt_len = 16;
11959 break;
11960 case 9700: hashes_buf[0].salt->salt_len = 16;
11961 break;
11962 case 9710: hashes_buf[0].salt->salt_len = 16;
11963 break;
11964 case 9720: hashes_buf[0].salt->salt_len = 16;
11965 break;
11966 case 9800: hashes_buf[0].salt->salt_len = 16;
11967 break;
11968 case 9810: hashes_buf[0].salt->salt_len = 16;
11969 break;
11970 case 9820: hashes_buf[0].salt->salt_len = 16;
11971 break;
11972 case 10300: hashes_buf[0].salt->salt_len = 12;
11973 break;
11974 case 11500: hashes_buf[0].salt->salt_len = 4;
11975 break;
11976 case 11600: hashes_buf[0].salt->salt_len = 4;
11977 break;
11978 case 12400: hashes_buf[0].salt->salt_len = 4;
11979 break;
11980 case 12500: hashes_buf[0].salt->salt_len = 8;
11981 break;
11982 case 12600: hashes_buf[0].salt->salt_len = 64;
11983 break;
11984 }
11985
11986 // special esalt handling
11987
11988 switch (hash_mode)
11989 {
11990 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11991 break;
11992 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11993 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11994 break;
11995 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11996 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11997 break;
11998 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11999 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12000 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12001 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12002 break;
12003 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12004 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12005 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12006 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12007 break;
12008 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12009 break;
12010 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12011 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12012 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12013 break;
12014 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12015 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12016 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12017 break;
12018 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12019 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12020 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12021 break;
12022 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12023 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12024 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12025 break;
12026 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12027 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12028 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12029 break;
12030 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12031 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12032 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12033 break;
12034 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12035 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12036 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12037 break;
12038 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12039 break;
12040 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12041 break;
12042 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12043 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12044 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12045 break;
12046 }
12047 }
12048
12049 // set hashfile
12050
12051 switch (hash_mode)
12052 {
12053 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12054 break;
12055 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12056 break;
12057 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12058 break;
12059 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12060 break;
12061 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12062 break;
12063 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12064 break;
12065 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12066 break;
12067 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12068 break;
12069 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12070 break;
12071 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12072 break;
12073 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12074 break;
12075 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12076 break;
12077 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12078 break;
12079 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12080 break;
12081 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12082 break;
12083 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12084 break;
12085 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12086 break;
12087 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12088 break;
12089 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12090 break;
12091 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12092 break;
12093 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12094 break;
12095 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12096 break;
12097 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12098 break;
12099 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12100 break;
12101 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12102 break;
12103 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12104 break;
12105 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12106 break;
12107 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12108 break;
12109 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12110 break;
12111 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12112 break;
12113 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12114 break;
12115 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12116 break;
12117 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12118 break;
12119 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12120 break;
12121 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12122 break;
12123 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12124 break;
12125 }
12126
12127 // set default iterations
12128
12129 switch (hash_mode)
12130 {
12131 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12132 break;
12133 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12134 break;
12135 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12136 break;
12137 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12138 break;
12139 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12140 break;
12141 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12142 break;
12143 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12144 break;
12145 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12146 break;
12147 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12148 break;
12149 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12150 break;
12151 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12152 break;
12153 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12154 break;
12155 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12156 break;
12157 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12158 break;
12159 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12160 break;
12161 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12162 break;
12163 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12164 break;
12165 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12166 break;
12167 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12168 break;
12169 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12170 break;
12171 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12172 break;
12173 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12174 break;
12175 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12176 break;
12177 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12178 break;
12179 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12180 break;
12181 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12182 break;
12183 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12184 break;
12185 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12186 break;
12187 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12188 break;
12189 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12190 break;
12191 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12192 break;
12193 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12194 break;
12195 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12196 break;
12197 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12198 break;
12199 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12200 break;
12201 case 8900: hashes_buf[0].salt->salt_iter = 1;
12202 break;
12203 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12204 break;
12205 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12206 break;
12207 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12208 break;
12209 case 9300: hashes_buf[0].salt->salt_iter = 1;
12210 break;
12211 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12212 break;
12213 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12214 break;
12215 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12216 break;
12217 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12218 break;
12219 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12220 break;
12221 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12222 break;
12223 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12224 break;
12225 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12226 break;
12227 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12228 break;
12229 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12230 break;
12231 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12232 break;
12233 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12234 break;
12235 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12236 break;
12237 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12238 break;
12239 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12240 break;
12241 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12242 break;
12243 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12244 break;
12245 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12246 break;
12247 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12248 break;
12249 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12250 break;
12251 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12252 break;
12253 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12254 break;
12255 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12256 break;
12257 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12258 break;
12259 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12260 break;
12261 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12262 break;
12263 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12264 break;
12265 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12266 break;
12267 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12268 break;
12269 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12270 break;
12271 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12272 break;
12273 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12274 break;
12275 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12276 break;
12277 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12278 break;
12279 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12280 break;
12281 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12282 break;
12283 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12284 break;
12285 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12286 break;
12287 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12288 break;
12289 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12290 break;
12291 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12292 break;
12293 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12294 break;
12295 }
12296
12297 hashes_cnt = 1;
12298 }
12299
12300 if (show == 1 || left == 1)
12301 {
12302 for (uint i = 0; i < pot_cnt; i++)
12303 {
12304 pot_t *pot_ptr = &pot[i];
12305
12306 hash_t *hashes_buf = &pot_ptr->hash;
12307
12308 local_free (hashes_buf->digest);
12309
12310 if (isSalted)
12311 {
12312 local_free (hashes_buf->salt);
12313 }
12314 }
12315
12316 local_free (pot);
12317
12318 if (data.quiet == 0) log_info_nn ("");
12319
12320 return (0);
12321 }
12322
12323 if (keyspace == 0)
12324 {
12325 if (hashes_cnt == 0)
12326 {
12327 log_error ("ERROR: No hashes loaded");
12328
12329 return (-1);
12330 }
12331 }
12332
12333 /**
12334 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12335 */
12336
12337 if (data.outfile != NULL)
12338 {
12339 if (data.hashfile != NULL)
12340 {
12341 #ifdef _POSIX
12342 struct stat tmpstat_outfile;
12343 struct stat tmpstat_hashfile;
12344 #endif
12345
12346 #ifdef _WIN
12347 struct stat64 tmpstat_outfile;
12348 struct stat64 tmpstat_hashfile;
12349 #endif
12350
12351 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12352
12353 if (tmp_outfile_fp)
12354 {
12355 #ifdef _POSIX
12356 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12357 #endif
12358
12359 #ifdef _WIN
12360 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12361 #endif
12362
12363 fclose (tmp_outfile_fp);
12364 }
12365
12366 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12367
12368 if (tmp_hashfile_fp)
12369 {
12370 #ifdef _POSIX
12371 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12372 #endif
12373
12374 #ifdef _WIN
12375 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12376 #endif
12377
12378 fclose (tmp_hashfile_fp);
12379 }
12380
12381 if (tmp_outfile_fp && tmp_outfile_fp)
12382 {
12383 tmpstat_outfile.st_mode = 0;
12384 tmpstat_outfile.st_nlink = 0;
12385 tmpstat_outfile.st_uid = 0;
12386 tmpstat_outfile.st_gid = 0;
12387 tmpstat_outfile.st_rdev = 0;
12388 tmpstat_outfile.st_atime = 0;
12389
12390 tmpstat_hashfile.st_mode = 0;
12391 tmpstat_hashfile.st_nlink = 0;
12392 tmpstat_hashfile.st_uid = 0;
12393 tmpstat_hashfile.st_gid = 0;
12394 tmpstat_hashfile.st_rdev = 0;
12395 tmpstat_hashfile.st_atime = 0;
12396
12397 #ifdef _POSIX
12398 tmpstat_outfile.st_blksize = 0;
12399 tmpstat_outfile.st_blocks = 0;
12400
12401 tmpstat_hashfile.st_blksize = 0;
12402 tmpstat_hashfile.st_blocks = 0;
12403 #endif
12404
12405 #ifdef _POSIX
12406 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12407 {
12408 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12409
12410 return (-1);
12411 }
12412 #endif
12413
12414 #ifdef _WIN
12415 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12416 {
12417 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12418
12419 return (-1);
12420 }
12421 #endif
12422 }
12423 }
12424 }
12425
12426 /**
12427 * Remove duplicates
12428 */
12429
12430 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12431
12432 if (isSalted)
12433 {
12434 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12435 }
12436 else
12437 {
12438 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12439 }
12440
12441 uint hashes_cnt_orig = hashes_cnt;
12442
12443 hashes_cnt = 1;
12444
12445 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12446 {
12447 if (isSalted)
12448 {
12449 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12450 {
12451 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12452 }
12453 }
12454 else
12455 {
12456 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12457 }
12458
12459 if (hashes_pos > hashes_cnt)
12460 {
12461 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12462 }
12463
12464 hashes_cnt++;
12465 }
12466
12467 /**
12468 * Potfile removes
12469 */
12470
12471 uint potfile_remove_cracks = 0;
12472
12473 if (potfile_disable == 0)
12474 {
12475 hash_t hash_buf;
12476
12477 hash_buf.digest = mymalloc (dgst_size);
12478 hash_buf.salt = NULL;
12479 hash_buf.esalt = NULL;
12480 hash_buf.hash_info = NULL;
12481 hash_buf.cracked = 0;
12482
12483 if (isSalted)
12484 {
12485 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12486 }
12487
12488 if (esalt_size)
12489 {
12490 hash_buf.esalt = mymalloc (esalt_size);
12491 }
12492
12493 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12494
12495 // no solution for these special hash types (for instane because they use hashfile in output etc)
12496 if ((hash_mode != 5200) &&
12497 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12498 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12499 (hash_mode != 9000))
12500 {
12501 FILE *fp = fopen (potfile, "rb");
12502
12503 if (fp != NULL)
12504 {
12505 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12506
12507 // to be safe work with a copy (because of line_len loop, i etc)
12508 // moved up here because it's easier to handle continue case
12509 // it's just 64kb
12510
12511 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12512
12513 while (!feof (fp))
12514 {
12515 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12516
12517 if (ptr == NULL) break;
12518
12519 int line_len = strlen (line_buf);
12520
12521 if (line_len == 0) continue;
12522
12523 int iter = MAX_CUT_TRIES;
12524
12525 for (int i = line_len - 1; i && iter; i--, line_len--)
12526 {
12527 if (line_buf[i] != ':') continue;
12528
12529 if (isSalted)
12530 {
12531 memset (hash_buf.salt, 0, sizeof (salt_t));
12532 }
12533
12534 hash_t *found = NULL;
12535
12536 if (hash_mode == 6800)
12537 {
12538 if (i < 64) // 64 = 16 * uint in salt_buf[]
12539 {
12540 // manipulate salt_buf
12541 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12542
12543 hash_buf.salt->salt_len = i;
12544
12545 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12546 }
12547 }
12548 else if (hash_mode == 2500)
12549 {
12550 if (i < 64) // 64 = 16 * uint in salt_buf[]
12551 {
12552 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12553 // manipulate salt_buf
12554
12555 memcpy (line_buf_cpy, line_buf, i);
12556
12557 char *mac2_pos = strrchr (line_buf_cpy, ':');
12558
12559 if (mac2_pos == NULL) continue;
12560
12561 mac2_pos[0] = 0;
12562 mac2_pos++;
12563
12564 if (strlen (mac2_pos) != 12) continue;
12565
12566 char *mac1_pos = strrchr (line_buf_cpy, ':');
12567
12568 if (mac1_pos == NULL) continue;
12569
12570 mac1_pos[0] = 0;
12571 mac1_pos++;
12572
12573 if (strlen (mac1_pos) != 12) continue;
12574
12575 uint essid_length = mac1_pos - line_buf_cpy - 1;
12576
12577 // here we need the ESSID
12578 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12579
12580 hash_buf.salt->salt_len = essid_length;
12581
12582 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12583
12584 if (found)
12585 {
12586 wpa_t *wpa = (wpa_t *) found->esalt;
12587
12588 // compare hex string(s) vs binary MAC address(es)
12589
12590 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12591 {
12592 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12593 {
12594 found = NULL;
12595
12596 break;
12597 }
12598 }
12599
12600 // early skip ;)
12601 if (!found) continue;
12602
12603 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12604 {
12605 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12606 {
12607 found = NULL;
12608
12609 break;
12610 }
12611 }
12612 }
12613 }
12614 }
12615 else
12616 {
12617 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12618
12619 if (parser_status == PARSER_OK)
12620 {
12621 if (isSalted)
12622 {
12623 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12624 }
12625 else
12626 {
12627 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12628 }
12629 }
12630 }
12631
12632 if (found == NULL) continue;
12633
12634 if (!found->cracked) potfile_remove_cracks++;
12635
12636 found->cracked = 1;
12637
12638 if (found) break;
12639
12640 iter--;
12641 }
12642 }
12643
12644 myfree (line_buf_cpy);
12645
12646 myfree (line_buf);
12647
12648 fclose (fp);
12649 }
12650 }
12651
12652 if (esalt_size)
12653 {
12654 local_free (hash_buf.esalt);
12655 }
12656
12657 if (isSalted)
12658 {
12659 local_free (hash_buf.salt);
12660 }
12661
12662 local_free (hash_buf.digest);
12663 }
12664
12665 /**
12666 * Now generate all the buffers required for later
12667 */
12668
12669 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12670
12671 salt_t *salts_buf_new = NULL;
12672 void *esalts_buf_new = NULL;
12673
12674 if (isSalted)
12675 {
12676 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12677
12678 if (esalt_size)
12679 {
12680 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12681 }
12682 }
12683 else
12684 {
12685 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12686 }
12687
12688 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12689
12690 uint digests_cnt = hashes_cnt;
12691 uint digests_done = 0;
12692
12693 size_t size_digests = digests_cnt * dgst_size;
12694 size_t size_shown = digests_cnt * sizeof (uint);
12695
12696 uint *digests_shown = (uint *) mymalloc (size_shown);
12697 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12698
12699 uint salts_cnt = 0;
12700 uint salts_done = 0;
12701
12702 hashinfo_t **hash_info = NULL;
12703
12704 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12705 {
12706 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12707
12708 if (username && (remove || show))
12709 {
12710 uint user_pos;
12711
12712 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12713 {
12714 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12715
12716 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12717 }
12718 }
12719 }
12720
12721 uint *salts_shown = (uint *) mymalloc (size_shown);
12722
12723 salt_t *salt_buf;
12724
12725 {
12726 // copied from inner loop
12727
12728 salt_buf = &salts_buf_new[salts_cnt];
12729
12730 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12731
12732 if (esalt_size)
12733 {
12734 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12735 }
12736
12737 salt_buf->digests_cnt = 0;
12738 salt_buf->digests_done = 0;
12739 salt_buf->digests_offset = 0;
12740
12741 salts_cnt++;
12742 }
12743
12744 if (hashes_buf[0].cracked == 1)
12745 {
12746 digests_shown[0] = 1;
12747
12748 digests_done++;
12749
12750 salt_buf->digests_done++;
12751 }
12752
12753 salt_buf->digests_cnt++;
12754
12755 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12756
12757 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12758 {
12759 hash_info[0] = hashes_buf[0].hash_info;
12760 }
12761
12762 // copy from inner loop
12763
12764 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12765 {
12766 if (isSalted)
12767 {
12768 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12769 {
12770 salt_buf = &salts_buf_new[salts_cnt];
12771
12772 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12773
12774 if (esalt_size)
12775 {
12776 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12777 }
12778
12779 salt_buf->digests_cnt = 0;
12780 salt_buf->digests_done = 0;
12781 salt_buf->digests_offset = hashes_pos;
12782
12783 salts_cnt++;
12784 }
12785 }
12786
12787 if (hashes_buf[hashes_pos].cracked == 1)
12788 {
12789 digests_shown[hashes_pos] = 1;
12790
12791 digests_done++;
12792
12793 salt_buf->digests_done++;
12794 }
12795
12796 salt_buf->digests_cnt++;
12797
12798 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12799
12800 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12801 {
12802 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12803 }
12804 }
12805
12806 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12807 {
12808 salt_t *salt_buf = &salts_buf_new[salt_pos];
12809
12810 if (salt_buf->digests_done == salt_buf->digests_cnt)
12811 {
12812 salts_shown[salt_pos] = 1;
12813
12814 salts_done++;
12815 }
12816
12817 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12818 }
12819
12820 local_free (digests_buf);
12821 local_free (salts_buf);
12822 local_free (esalts_buf);
12823
12824 digests_buf = digests_buf_new;
12825 salts_buf = salts_buf_new;
12826 esalts_buf = esalts_buf_new;
12827
12828 local_free (hashes_buf);
12829
12830 /**
12831 * special modification not set from parser
12832 */
12833
12834 switch (hash_mode)
12835 {
12836 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12837 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12838 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12839 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12840 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12841 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12842 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12843 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12844 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12845 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12846 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12847 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12848 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12849 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12850 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12851 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12852 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12853 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12854 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12855 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12856 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12857 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12858 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12859 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12860 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12861 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12862 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12863 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12864 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12865 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12866 }
12867
12868 if (truecrypt_keyfiles)
12869 {
12870 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12871
12872 char *keyfiles = strdup (truecrypt_keyfiles);
12873
12874 char *keyfile = strtok (keyfiles, ",");
12875
12876 do
12877 {
12878 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12879
12880 } while ((keyfile = strtok (NULL, ",")) != NULL);
12881
12882 free (keyfiles);
12883 }
12884
12885 if (veracrypt_keyfiles)
12886 {
12887 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12888
12889 char *keyfiles = strdup (veracrypt_keyfiles);
12890
12891 char *keyfile = strtok (keyfiles, ",");
12892
12893 do
12894 {
12895 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12896
12897 } while ((keyfile = strtok (NULL, ",")) != NULL);
12898
12899 free (keyfiles);
12900 }
12901
12902 data.digests_cnt = digests_cnt;
12903 data.digests_done = digests_done;
12904 data.digests_buf = digests_buf;
12905 data.digests_shown = digests_shown;
12906 data.digests_shown_tmp = digests_shown_tmp;
12907
12908 data.salts_cnt = salts_cnt;
12909 data.salts_done = salts_done;
12910 data.salts_buf = salts_buf;
12911 data.salts_shown = salts_shown;
12912
12913 data.esalts_buf = esalts_buf;
12914 data.hash_info = hash_info;
12915
12916 /**
12917 * Automatic Optimizers
12918 */
12919
12920 if (salts_cnt == 1)
12921 opti_type |= OPTI_TYPE_SINGLE_SALT;
12922
12923 if (digests_cnt == 1)
12924 opti_type |= OPTI_TYPE_SINGLE_HASH;
12925
12926 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12927 opti_type |= OPTI_TYPE_NOT_ITERATED;
12928
12929 if (attack_mode == ATTACK_MODE_BF)
12930 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12931
12932 data.opti_type = opti_type;
12933
12934 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12935 {
12936 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12937 {
12938 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12939 {
12940 if (opts_type & OPTS_TYPE_ST_ADD80)
12941 {
12942 opts_type &= ~OPTS_TYPE_ST_ADD80;
12943 opts_type |= OPTS_TYPE_PT_ADD80;
12944 }
12945
12946 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12947 {
12948 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12949 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12950 }
12951
12952 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12953 {
12954 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12955 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12956 }
12957 }
12958 }
12959 }
12960
12961 /**
12962 * Some algorithm, like descrypt, can benefit from JIT compilation
12963 */
12964
12965 int force_jit_compilation = -1;
12966
12967 if (hash_mode == 8900)
12968 {
12969 force_jit_compilation = 8900;
12970 }
12971 else if (hash_mode == 9300)
12972 {
12973 force_jit_compilation = 8900;
12974 }
12975 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12976 {
12977 force_jit_compilation = 1500;
12978 }
12979
12980 /**
12981 * generate bitmap tables
12982 */
12983
12984 const uint bitmap_shift1 = 5;
12985 const uint bitmap_shift2 = 13;
12986
12987 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12988
12989 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12990 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12991 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12992 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12993 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12994 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12995 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12996 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12997
12998 uint bitmap_bits;
12999 uint bitmap_nums;
13000 uint bitmap_mask;
13001 uint bitmap_size;
13002
13003 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13004 {
13005 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13006
13007 bitmap_nums = 1 << bitmap_bits;
13008
13009 bitmap_mask = bitmap_nums - 1;
13010
13011 bitmap_size = bitmap_nums * sizeof (uint);
13012
13013 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13014
13015 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;
13016 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;
13017
13018 break;
13019 }
13020
13021 bitmap_nums = 1 << bitmap_bits;
13022
13023 bitmap_mask = bitmap_nums - 1;
13024
13025 bitmap_size = bitmap_nums * sizeof (uint);
13026
13027 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);
13028 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);
13029
13030 /**
13031 * prepare quick rule
13032 */
13033
13034 data.rule_buf_l = rule_buf_l;
13035 data.rule_buf_r = rule_buf_r;
13036
13037 int rule_len_l = (int) strlen (rule_buf_l);
13038 int rule_len_r = (int) strlen (rule_buf_r);
13039
13040 data.rule_len_l = rule_len_l;
13041 data.rule_len_r = rule_len_r;
13042
13043 /**
13044 * load rules
13045 */
13046
13047 uint *all_kernel_rules_cnt = NULL;
13048
13049 kernel_rule_t **all_kernel_rules_buf = NULL;
13050
13051 if (rp_files_cnt)
13052 {
13053 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13054
13055 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13056 }
13057
13058 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13059
13060 int rule_len = 0;
13061
13062 for (uint i = 0; i < rp_files_cnt; i++)
13063 {
13064 uint kernel_rules_avail = 0;
13065
13066 uint kernel_rules_cnt = 0;
13067
13068 kernel_rule_t *kernel_rules_buf = NULL;
13069
13070 char *rp_file = rp_files[i];
13071
13072 char in[BLOCK_SIZE] = { 0 };
13073 char out[BLOCK_SIZE] = { 0 };
13074
13075 FILE *fp = NULL;
13076
13077 uint rule_line = 0;
13078
13079 if ((fp = fopen (rp_file, "rb")) == NULL)
13080 {
13081 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13082
13083 return (-1);
13084 }
13085
13086 while (!feof (fp))
13087 {
13088 memset (rule_buf, 0, HCBUFSIZ);
13089
13090 rule_len = fgetl (fp, rule_buf);
13091
13092 rule_line++;
13093
13094 if (rule_len == 0) continue;
13095
13096 if (rule_buf[0] == '#') continue;
13097
13098 if (kernel_rules_avail == kernel_rules_cnt)
13099 {
13100 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13101
13102 kernel_rules_avail += INCR_RULES;
13103 }
13104
13105 memset (in, 0, BLOCK_SIZE);
13106 memset (out, 0, BLOCK_SIZE);
13107
13108 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13109
13110 if (result == -1)
13111 {
13112 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13113
13114 continue;
13115 }
13116
13117 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13118 {
13119 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13120
13121 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13122
13123 continue;
13124 }
13125
13126 /* its so slow
13127 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13128 {
13129 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13130
13131 continue;
13132 }
13133 */
13134
13135 kernel_rules_cnt++;
13136 }
13137
13138 fclose (fp);
13139
13140 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13141
13142 all_kernel_rules_buf[i] = kernel_rules_buf;
13143 }
13144
13145 /**
13146 * merge rules or automatic rule generator
13147 */
13148
13149 uint kernel_rules_cnt = 0;
13150
13151 kernel_rule_t *kernel_rules_buf = NULL;
13152
13153 if (attack_mode == ATTACK_MODE_STRAIGHT)
13154 {
13155 if (rp_files_cnt)
13156 {
13157 kernel_rules_cnt = 1;
13158
13159 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13160
13161 repeats[0] = kernel_rules_cnt;
13162
13163 for (uint i = 0; i < rp_files_cnt; i++)
13164 {
13165 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13166
13167 repeats[i + 1] = kernel_rules_cnt;
13168 }
13169
13170 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13171
13172 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13173
13174 for (uint i = 0; i < kernel_rules_cnt; i++)
13175 {
13176 uint out_pos = 0;
13177
13178 kernel_rule_t *out = &kernel_rules_buf[i];
13179
13180 for (uint j = 0; j < rp_files_cnt; j++)
13181 {
13182 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13183 uint in_pos;
13184
13185 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13186
13187 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13188 {
13189 if (out_pos == RULES_MAX - 1)
13190 {
13191 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13192
13193 break;
13194 }
13195
13196 out->cmds[out_pos] = in->cmds[in_pos];
13197 }
13198 }
13199 }
13200
13201 local_free (repeats);
13202 }
13203 else if (rp_gen)
13204 {
13205 uint kernel_rules_avail = 0;
13206
13207 while (kernel_rules_cnt < rp_gen)
13208 {
13209 if (kernel_rules_avail == kernel_rules_cnt)
13210 {
13211 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13212
13213 kernel_rules_avail += INCR_RULES;
13214 }
13215
13216 memset (rule_buf, 0, HCBUFSIZ);
13217
13218 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13219
13220 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13221
13222 kernel_rules_cnt++;
13223 }
13224 }
13225 }
13226
13227 myfree (rule_buf);
13228
13229 /**
13230 * generate NOP rules
13231 */
13232
13233 if (kernel_rules_cnt == 0)
13234 {
13235 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13236
13237 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13238
13239 kernel_rules_cnt++;
13240 }
13241
13242 data.kernel_rules_cnt = kernel_rules_cnt;
13243 data.kernel_rules_buf = kernel_rules_buf;
13244
13245 /**
13246 * OpenCL platforms: detect
13247 */
13248
13249 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13250 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13251
13252 cl_uint platforms_cnt = 0;
13253 cl_uint platform_devices_cnt = 0;
13254
13255 if (keyspace == 0)
13256 {
13257 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13258
13259 if (platforms_cnt == 0)
13260 {
13261 log_info ("");
13262 log_info ("ATTENTION! No OpenCL compatible platform found");
13263 log_info ("");
13264 log_info ("You're probably missing the OpenCL runtime installation");
13265 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13266 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13267 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13268 log_info ("");
13269
13270 return (-1);
13271 }
13272
13273 if (opencl_platforms_filter != (uint) -1)
13274 {
13275 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13276
13277 if (opencl_platforms_filter > platform_cnt_mask)
13278 {
13279 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13280
13281 return (-1);
13282 }
13283 }
13284 }
13285
13286 /**
13287 * OpenCL device types:
13288 * 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.
13289 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13290 */
13291
13292 if (opencl_device_types == NULL)
13293 {
13294 cl_device_type device_types_all = 0;
13295
13296 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13297 {
13298 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13299
13300 cl_platform_id platform = platforms[platform_id];
13301
13302 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13303
13304 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13305 {
13306 cl_device_id device = platform_devices[platform_devices_id];
13307
13308 cl_device_type device_type;
13309
13310 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13311
13312 device_types_all |= device_type;
13313 }
13314 }
13315
13316 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13317 {
13318 device_types_filter |= CL_DEVICE_TYPE_CPU;
13319 }
13320 }
13321
13322 /**
13323 * OpenCL devices: simply push all devices from all platforms into the same device array
13324 */
13325
13326 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13327
13328 data.devices_param = devices_param;
13329
13330 uint devices_cnt = 0;
13331
13332 uint devices_active = 0;
13333
13334 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13335 {
13336 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13337
13338 cl_platform_id platform = platforms[platform_id];
13339
13340 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13341
13342 char platform_vendor[INFOSZ] = { 0 };
13343
13344 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13345
13346 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13347 // this causes trouble with vendor id based macros
13348 // we'll assign generic to those without special optimization available
13349
13350 cl_uint platform_vendor_id = 0;
13351
13352 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13353 {
13354 platform_vendor_id = VENDOR_ID_AMD;
13355 }
13356 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13357 {
13358 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13359 }
13360 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13361 {
13362 platform_vendor_id = VENDOR_ID_APPLE;
13363 }
13364 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13365 {
13366 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13367 }
13368 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13369 {
13370 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13371 }
13372 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13373 {
13374 platform_vendor_id = VENDOR_ID_MESA;
13375 }
13376 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13377 {
13378 platform_vendor_id = VENDOR_ID_NV;
13379 }
13380 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13381 {
13382 platform_vendor_id = VENDOR_ID_POCL;
13383 }
13384 else
13385 {
13386 platform_vendor_id = VENDOR_ID_GENERIC;
13387 }
13388
13389 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13390 {
13391 size_t param_value_size = 0;
13392
13393 const uint device_id = devices_cnt;
13394
13395 hc_device_param_t *device_param = &data.devices_param[device_id];
13396
13397 device_param->platform_vendor_id = platform_vendor_id;
13398
13399 device_param->device = platform_devices[platform_devices_id];
13400
13401 device_param->device_id = device_id;
13402
13403 device_param->platform_devices_id = platform_devices_id;
13404
13405 // device_type
13406
13407 cl_device_type device_type;
13408
13409 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13410
13411 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13412
13413 device_param->device_type = device_type;
13414
13415 // device_name
13416
13417 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13418
13419 char *device_name = (char *) mymalloc (param_value_size);
13420
13421 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13422
13423 device_param->device_name = device_name;
13424
13425 // device_vendor
13426
13427 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13428
13429 char *device_vendor = (char *) mymalloc (param_value_size);
13430
13431 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13432
13433 device_param->device_vendor = device_vendor;
13434
13435 cl_uint device_vendor_id = 0;
13436
13437 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13438 {
13439 device_vendor_id = VENDOR_ID_AMD;
13440 }
13441 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13442 {
13443 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13444 }
13445 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13446 {
13447 device_vendor_id = VENDOR_ID_APPLE;
13448 }
13449 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13450 {
13451 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13452 }
13453 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13454 {
13455 device_vendor_id = VENDOR_ID_INTEL_SDK;
13456 }
13457 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13458 {
13459 device_vendor_id = VENDOR_ID_MESA;
13460 }
13461 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13462 {
13463 device_vendor_id = VENDOR_ID_NV;
13464 }
13465 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13466 {
13467 device_vendor_id = VENDOR_ID_POCL;
13468 }
13469 else
13470 {
13471 device_vendor_id = VENDOR_ID_GENERIC;
13472 }
13473
13474 device_param->device_vendor_id = device_vendor_id;
13475
13476 // tuning db
13477
13478 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13479
13480 // device_version
13481
13482 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13483
13484 char *device_version = (char *) mymalloc (param_value_size);
13485
13486 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13487
13488 device_param->device_version = device_version;
13489
13490 // device_opencl_version
13491
13492 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13493
13494 char *device_opencl_version = (char *) mymalloc (param_value_size);
13495
13496 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13497
13498 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13499
13500 myfree (device_opencl_version);
13501
13502 // vector_width
13503
13504 cl_uint vector_width;
13505
13506 if (opencl_vector_width_chgd == 0)
13507 {
13508 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13509 {
13510 if (opti_type & OPTI_TYPE_USES_BITS_64)
13511 {
13512 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13513 }
13514 else
13515 {
13516 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13517 }
13518 }
13519 else
13520 {
13521 vector_width = (cl_uint) tuningdb_entry->vector_width;
13522 }
13523 }
13524 else
13525 {
13526 vector_width = opencl_vector_width;
13527 }
13528
13529 if (vector_width > 16) vector_width = 16;
13530
13531 device_param->vector_width = vector_width;
13532
13533 // max_compute_units
13534
13535 cl_uint device_processors;
13536
13537 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13538
13539 device_param->device_processors = device_processors;
13540
13541 // device_maxmem_alloc
13542 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13543
13544 cl_ulong device_maxmem_alloc;
13545
13546 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13547
13548 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13549
13550 // device_global_mem
13551
13552 cl_ulong device_global_mem;
13553
13554 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13555
13556 device_param->device_global_mem = device_global_mem;
13557
13558 // max_work_group_size
13559
13560 size_t device_maxworkgroup_size;
13561
13562 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13563
13564 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13565
13566 // max_clock_frequency
13567
13568 cl_uint device_maxclock_frequency;
13569
13570 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13571
13572 device_param->device_maxclock_frequency = device_maxclock_frequency;
13573
13574 // device_endian_little
13575
13576 cl_bool device_endian_little;
13577
13578 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13579
13580 if (device_endian_little == CL_FALSE)
13581 {
13582 if (data.quiet == 0) log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13583
13584 device_param->skipped = 1;
13585 }
13586
13587 // device_available
13588
13589 cl_bool device_available;
13590
13591 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13592
13593 if (device_available == CL_FALSE)
13594 {
13595 if (data.quiet == 0) log_info ("Device #%u: WARNING: device not available", device_id + 1);
13596
13597 device_param->skipped = 1;
13598 }
13599
13600 // device_compiler_available
13601
13602 cl_bool device_compiler_available;
13603
13604 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13605
13606 if (device_compiler_available == CL_FALSE)
13607 {
13608 if (data.quiet == 0) log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13609
13610 device_param->skipped = 1;
13611 }
13612
13613 // device_execution_capabilities
13614
13615 cl_device_exec_capabilities device_execution_capabilities;
13616
13617 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13618
13619 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13620 {
13621 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13622
13623 device_param->skipped = 1;
13624 }
13625
13626 // device_extensions
13627
13628 size_t device_extensions_size;
13629
13630 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13631
13632 char *device_extensions = mymalloc (device_extensions_size + 1);
13633
13634 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13635
13636 if (strstr (device_extensions, "base_atomics") == 0)
13637 {
13638 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13639
13640 device_param->skipped = 1;
13641 }
13642
13643 if (strstr (device_extensions, "byte_addressable_store") == 0)
13644 {
13645 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13646
13647 device_param->skipped = 1;
13648 }
13649
13650 myfree (device_extensions);
13651
13652 // device_local_mem_size
13653
13654 cl_ulong device_local_mem_size;
13655
13656 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13657
13658 if (device_local_mem_size < 32768)
13659 {
13660 if (data.quiet == 0) log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13661
13662 device_param->skipped = 1;
13663 }
13664
13665 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13666 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13667 // This results in both utilizing it for 50%
13668 // However, Intel has much better SIMD control over their own hardware
13669 // It makes sense to give them full control over their own hardware
13670
13671 if (device_type & CL_DEVICE_TYPE_CPU)
13672 {
13673 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13674 {
13675 if (data.quiet == 0) log_info ("Device #%u: WARNING: not native intel opencl platform", device_id + 1);
13676
13677 device_param->skipped = 1;
13678 }
13679 }
13680
13681 // skipped
13682
13683 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13684 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13685
13686 // driver_version
13687
13688 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13689
13690 char *driver_version = (char *) mymalloc (param_value_size);
13691
13692 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13693
13694 device_param->driver_version = driver_version;
13695
13696 // device_name_chksum
13697
13698 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13699
13700 #if __x86_64__
13701 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);
13702 #else
13703 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);
13704 #endif
13705
13706 uint device_name_digest[4] = { 0 };
13707
13708 md5_64 ((uint *) device_name_chksum, device_name_digest);
13709
13710 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13711
13712 device_param->device_name_chksum = device_name_chksum;
13713
13714 // device_processor_cores
13715
13716 if (device_type & CL_DEVICE_TYPE_CPU)
13717 {
13718 cl_uint device_processor_cores = 1;
13719
13720 device_param->device_processor_cores = device_processor_cores;
13721 }
13722
13723 if (device_type & CL_DEVICE_TYPE_GPU)
13724 {
13725 if (device_vendor_id == VENDOR_ID_AMD)
13726 {
13727 cl_uint device_processor_cores = 0;
13728
13729 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13730
13731 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13732
13733 device_param->device_processor_cores = device_processor_cores;
13734 }
13735 else if (device_vendor_id == VENDOR_ID_NV)
13736 {
13737 cl_uint kernel_exec_timeout = 0;
13738
13739 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13740
13741 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13742
13743 device_param->kernel_exec_timeout = kernel_exec_timeout;
13744
13745 cl_uint device_processor_cores = 0;
13746
13747 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13748
13749 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13750
13751 device_param->device_processor_cores = device_processor_cores;
13752
13753 cl_uint sm_minor = 0;
13754 cl_uint sm_major = 0;
13755
13756 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13757 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13758
13759 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13760 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13761
13762 device_param->sm_minor = sm_minor;
13763 device_param->sm_major = sm_major;
13764 }
13765 else
13766 {
13767 cl_uint device_processor_cores = 1;
13768
13769 device_param->device_processor_cores = device_processor_cores;
13770 }
13771 }
13772
13773 // display results
13774
13775 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13776 {
13777 if (machine_readable == 0)
13778 {
13779 if (device_param->skipped == 0)
13780 {
13781 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13782 device_id + 1,
13783 device_name,
13784 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13785 (unsigned int) (device_global_mem / 1024 / 1024),
13786 (unsigned int) device_processors);
13787 }
13788 else
13789 {
13790 log_info ("Device #%u: %s, skipped",
13791 device_id + 1,
13792 device_name);
13793 }
13794 }
13795 }
13796
13797 // common driver check
13798
13799 if (device_param->skipped == 0)
13800 {
13801 if (device_type & CL_DEVICE_TYPE_GPU)
13802 {
13803 if (platform_vendor_id == VENDOR_ID_AMD)
13804 {
13805 int catalyst_check = (force == 1) ? 0 : 1;
13806
13807 int catalyst_warn = 0;
13808
13809 int catalyst_broken = 0;
13810
13811 if (catalyst_check == 1)
13812 {
13813 catalyst_warn = 1;
13814
13815 // v14.9 and higher
13816 if (atoi (device_param->driver_version) >= 1573)
13817 {
13818 catalyst_warn = 0;
13819 }
13820
13821 catalyst_check = 0;
13822 }
13823
13824 if (catalyst_broken == 1)
13825 {
13826 log_info ("");
13827 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13828 log_info ("It will pass over cracked hashes and does not report them as cracked");
13829 log_info ("You are STRONGLY encouraged not to use it");
13830 log_info ("You can use --force to override this but do not post error reports if you do so");
13831 log_info ("");
13832
13833 return (-1);
13834 }
13835
13836 if (catalyst_warn == 1)
13837 {
13838 log_info ("");
13839 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13840 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13841 log_info ("See hashcat's homepage for official supported catalyst drivers");
13842 #ifdef _WIN
13843 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13844 #endif
13845 log_info ("You can use --force to override this but do not post error reports if you do so");
13846 log_info ("");
13847
13848 return (-1);
13849 }
13850 }
13851 else if (platform_vendor_id == VENDOR_ID_NV)
13852 {
13853 if (device_param->kernel_exec_timeout != 0)
13854 {
13855 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);
13856 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13857 }
13858 }
13859 }
13860
13861 /* turns out pocl still creates segfaults (because of llvm)
13862 if (device_type & CL_DEVICE_TYPE_CPU)
13863 {
13864 if (platform_vendor_id == VENDOR_ID_AMD)
13865 {
13866 if (force == 0)
13867 {
13868 log_info ("");
13869 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13870 log_info ("You are STRONGLY encouraged not to use it");
13871 log_info ("You can use --force to override this but do not post error reports if you do so");
13872 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13873 log_info ("");
13874
13875 return (-1);
13876 }
13877 }
13878 }
13879 */
13880
13881 /**
13882 * kernel accel and loops tuning db adjustment
13883 */
13884
13885 device_param->kernel_accel_min = 1;
13886 device_param->kernel_accel_max = 1024;
13887
13888 device_param->kernel_loops_min = 1;
13889 device_param->kernel_loops_max = 1024;
13890
13891 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13892
13893 if (tuningdb_entry)
13894 {
13895 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13896 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13897
13898 if (_kernel_accel)
13899 {
13900 device_param->kernel_accel_min = _kernel_accel;
13901 device_param->kernel_accel_max = _kernel_accel;
13902 }
13903
13904 if (_kernel_loops)
13905 {
13906 if (workload_profile == 1)
13907 {
13908 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13909 }
13910 else if (workload_profile == 2)
13911 {
13912 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13913 }
13914
13915 device_param->kernel_loops_min = _kernel_loops;
13916 device_param->kernel_loops_max = _kernel_loops;
13917 }
13918 }
13919
13920 // commandline parameters overwrite tuningdb entries
13921
13922 if (kernel_accel)
13923 {
13924 device_param->kernel_accel_min = kernel_accel;
13925 device_param->kernel_accel_max = kernel_accel;
13926 }
13927
13928 if (kernel_loops)
13929 {
13930 device_param->kernel_loops_min = kernel_loops;
13931 device_param->kernel_loops_max = kernel_loops;
13932 }
13933
13934 /**
13935 * activate device
13936 */
13937
13938 devices_active++;
13939 }
13940
13941 // next please
13942
13943 devices_cnt++;
13944 }
13945 }
13946
13947 if (keyspace == 0 && devices_active == 0)
13948 {
13949 log_error ("ERROR: No devices found/left");
13950
13951 return (-1);
13952 }
13953
13954 // 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)
13955
13956 if (devices_filter != (uint) -1)
13957 {
13958 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13959
13960 if (devices_filter > devices_cnt_mask)
13961 {
13962 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13963
13964 return (-1);
13965 }
13966 }
13967
13968 data.devices_cnt = devices_cnt;
13969
13970 data.devices_active = devices_active;
13971
13972 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13973 {
13974 if (machine_readable == 0)
13975 {
13976 log_info ("");
13977 }
13978 }
13979
13980 /**
13981 * HM devices: init
13982 */
13983
13984 #ifdef HAVE_HWMON
13985 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
13986 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
13987 #endif
13988
13989 if (gpu_temp_disable == 0)
13990 {
13991 #if defined(WIN)
13992 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13993
13994 if (nvapi_init (nvapi) == 0)
13995 data.hm_nv = nvapi;
13996
13997 if (data.hm_nv)
13998 {
13999 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
14000 {
14001 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
14002
14003 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
14004
14005 int tmp_out = 0;
14006
14007 for (int i = 0; i < tmp_in; i++)
14008 {
14009 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
14010 }
14011
14012 for (int i = 0; i < tmp_out; i++)
14013 {
14014 NV_GPU_COOLER_SETTINGS pCoolerSettings;
14015
14016 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
14017
14018 if (hm_NvAPI_GPU_GetCoolerSettings (data.hm_nv, hm_adapters_nv[i].adapter_index.nv, 0, &pCoolerSettings) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_get_supported = 1;
14019 }
14020 }
14021 }
14022 #endif // WIN
14023
14024 #if defined(LINUX)
14025 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14026
14027 if (nvml_init (nvml) == 0)
14028 data.hm_nv = nvml;
14029
14030 if (data.hm_nv)
14031 {
14032 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
14033 {
14034 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
14035
14036 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
14037
14038 int tmp_out = 0;
14039
14040 for (int i = 0; i < tmp_in; i++)
14041 {
14042 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
14043 }
14044
14045 for (int i = 0; i < tmp_out; i++)
14046 {
14047 unsigned int speed;
14048
14049 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;
14050 }
14051 }
14052 }
14053 #endif // LINUX
14054
14055 data.hm_amd = NULL;
14056
14057 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14058
14059 if (adl_init (adl) == 0)
14060 data.hm_amd = adl;
14061
14062 if (data.hm_amd)
14063 {
14064 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14065 {
14066 // total number of adapters
14067
14068 int hm_adapters_num;
14069
14070 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
14071
14072 // adapter info
14073
14074 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
14075
14076 if (lpAdapterInfo == NULL) return (-1);
14077
14078 // get a list (of ids of) valid/usable adapters
14079
14080 int num_adl_adapters = 0;
14081
14082 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14083
14084 if (num_adl_adapters > 0)
14085 {
14086 hc_thread_mutex_lock (mux_adl);
14087
14088 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
14089
14090 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14091
14092 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14093 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14094
14095 hc_thread_mutex_unlock (mux_adl);
14096 }
14097
14098 myfree (valid_adl_device_list);
14099 myfree (lpAdapterInfo);
14100 }
14101 }
14102
14103 if (data.hm_amd == NULL && data.hm_nv == NULL)
14104 {
14105 gpu_temp_disable = 1;
14106 }
14107 }
14108
14109 /**
14110 * OpenCL devices: allocate buffer for device specific information
14111 */
14112
14113 #ifdef HAVE_HWMON
14114 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14115 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14116
14117 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14118
14119 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
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 * User-defined GPU temp handling
14137 */
14138
14139 #ifdef HAVE_HWMON
14140 if (gpu_temp_disable == 1)
14141 {
14142 gpu_temp_abort = 0;
14143 gpu_temp_retain = 0;
14144 }
14145
14146 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14147 {
14148 if (gpu_temp_abort < gpu_temp_retain)
14149 {
14150 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14151
14152 return (-1);
14153 }
14154 }
14155
14156 data.gpu_temp_disable = gpu_temp_disable;
14157 data.gpu_temp_abort = gpu_temp_abort;
14158 data.gpu_temp_retain = gpu_temp_retain;
14159 #endif
14160
14161 /**
14162 * inform the user
14163 */
14164
14165 if (data.quiet == 0)
14166 {
14167 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14168
14169 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);
14170
14171 if (attack_mode == ATTACK_MODE_STRAIGHT)
14172 {
14173 log_info ("Rules: %u", kernel_rules_cnt);
14174 }
14175
14176 if (opti_type)
14177 {
14178 log_info ("Applicable Optimizers:");
14179
14180 for (uint i = 0; i < 32; i++)
14181 {
14182 const uint opti_bit = 1u << i;
14183
14184 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14185 }
14186 }
14187
14188 /**
14189 * Watchdog and Temperature balance
14190 */
14191
14192 #ifdef HAVE_HWMON
14193 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
14194 {
14195 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14196 }
14197
14198 if (gpu_temp_abort == 0)
14199 {
14200 log_info ("Watchdog: Temperature abort trigger disabled");
14201 }
14202 else
14203 {
14204 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14205 }
14206
14207 if (gpu_temp_retain == 0)
14208 {
14209 log_info ("Watchdog: Temperature retain trigger disabled");
14210 }
14211 else
14212 {
14213 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14214 }
14215
14216 if (data.quiet == 0) log_info ("");
14217 #endif
14218 }
14219
14220 #ifdef HAVE_HWMON
14221
14222 /**
14223 * HM devices: copy
14224 */
14225
14226 if (gpu_temp_disable == 0)
14227 {
14228 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14229 {
14230 hc_device_param_t *device_param = &data.devices_param[device_id];
14231
14232 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14233
14234 if (device_param->skipped) continue;
14235
14236 const uint platform_devices_id = device_param->platform_devices_id;
14237
14238 if (device_param->device_vendor_id == VENDOR_ID_NV)
14239 {
14240 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14241 }
14242
14243 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14244 {
14245 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14246 }
14247 }
14248 }
14249
14250 /**
14251 * Temporary fix:
14252 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14253 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14254 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14255 * Driver / ADL bug?
14256 */
14257
14258 if (powertune_enable == 1)
14259 {
14260 hc_thread_mutex_lock (mux_adl);
14261
14262 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14263 {
14264 hc_device_param_t *device_param = &data.devices_param[device_id];
14265
14266 if (device_param->skipped) continue;
14267
14268 if (data.hm_device[device_id].od_version == 6)
14269 {
14270 // set powertune value only
14271
14272 int powertune_supported = 0;
14273
14274 int ADL_rc = 0;
14275
14276 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14277 {
14278 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14279
14280 return (-1);
14281 }
14282
14283 if (powertune_supported != 0)
14284 {
14285 // powertune set
14286 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14287
14288 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14289 {
14290 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14291
14292 return (-1);
14293 }
14294
14295 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14296 {
14297 log_error ("ERROR: Failed to set new ADL PowerControl values");
14298
14299 return (-1);
14300 }
14301 }
14302 }
14303 }
14304
14305 hc_thread_mutex_unlock (mux_adl);
14306 }
14307
14308 #endif // HAVE_HWMON
14309
14310 #ifdef DEBUG
14311 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14312 #endif
14313
14314 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14315
14316 uint kernel_power_all = 0;
14317
14318 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14319 {
14320 /**
14321 * host buffer
14322 */
14323
14324 hc_device_param_t *device_param = &data.devices_param[device_id];
14325
14326 if (device_param->skipped) continue;
14327
14328 /**
14329 * device properties
14330 */
14331
14332 const char *device_name_chksum = device_param->device_name_chksum;
14333 const u32 device_processors = device_param->device_processors;
14334 const u32 device_processor_cores = device_param->device_processor_cores;
14335
14336 /**
14337 * create context for each device
14338 */
14339
14340 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14341
14342 /**
14343 * create command-queue
14344 */
14345
14346 // not supported with NV
14347 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14348
14349 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14350
14351 /**
14352 * kernel threads: some algorithms need a fixed kernel-threads count
14353 * because of shared memory usage or bitslice
14354 * there needs to be some upper limit, otherwise there's too much overhead
14355 */
14356
14357 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14358
14359 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14360 {
14361 kernel_threads = KERNEL_THREADS_MAX_CPU;
14362 }
14363
14364 if (hash_mode == 1500) kernel_threads = 64; // DES
14365 if (hash_mode == 3000) kernel_threads = 64; // DES
14366 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14367 if (hash_mode == 7500) kernel_threads = 64; // RC4
14368 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14369 if (hash_mode == 9700) kernel_threads = 64; // RC4
14370 if (hash_mode == 9710) kernel_threads = 64; // RC4
14371 if (hash_mode == 9800) kernel_threads = 64; // RC4
14372 if (hash_mode == 9810) kernel_threads = 64; // RC4
14373 if (hash_mode == 10400) kernel_threads = 64; // RC4
14374 if (hash_mode == 10410) kernel_threads = 64; // RC4
14375 if (hash_mode == 10500) kernel_threads = 64; // RC4
14376 if (hash_mode == 13100) kernel_threads = 64; // RC4
14377
14378 /**
14379 * create input buffers on device : calculate size of fixed memory buffers
14380 */
14381
14382 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14383 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14384
14385 device_param->size_root_css = size_root_css;
14386 device_param->size_markov_css = size_markov_css;
14387
14388 size_t size_results = sizeof (uint);
14389
14390 device_param->size_results = size_results;
14391
14392 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14393 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14394
14395 size_t size_plains = digests_cnt * sizeof (plain_t);
14396 size_t size_salts = salts_cnt * sizeof (salt_t);
14397 size_t size_esalts = salts_cnt * esalt_size;
14398
14399 device_param->size_plains = size_plains;
14400 device_param->size_digests = size_digests;
14401 device_param->size_shown = size_shown;
14402 device_param->size_salts = size_salts;
14403
14404 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14405 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14406 size_t size_tm = 32 * sizeof (bs_word_t);
14407
14408 // scryptV stuff
14409
14410 size_t size_scryptV = 1;
14411
14412 if ((hash_mode == 8900) || (hash_mode == 9300))
14413 {
14414 uint tmto_start = 0;
14415 uint tmto_stop = 10;
14416
14417 if (scrypt_tmto)
14418 {
14419 tmto_start = scrypt_tmto;
14420 }
14421 else
14422 {
14423 // in case the user did not specify the tmto manually
14424 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14425 // but set the lower end only in case the user has a device with too less memory
14426
14427 if (hash_mode == 8900)
14428 {
14429 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14430 {
14431 tmto_start = 1;
14432 }
14433 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14434 {
14435 tmto_start = 2;
14436 }
14437 }
14438 else if (hash_mode == 9300)
14439 {
14440 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14441 {
14442 tmto_start = 2;
14443 }
14444 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14445 {
14446 tmto_start = 2;
14447 }
14448 }
14449 }
14450
14451 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14452 {
14453 // TODO: in theory the following calculation needs to be done per salt, not global
14454 // we assume all hashes have the same scrypt settings
14455
14456 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14457
14458 size_scryptV /= 1 << tmto;
14459
14460 size_scryptV *= device_processors * device_processor_cores;
14461
14462 if (size_scryptV > device_param->device_maxmem_alloc)
14463 {
14464 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14465
14466 continue;
14467 }
14468
14469 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14470 {
14471 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14472 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14473 }
14474
14475 break;
14476 }
14477
14478 if (data.salts_buf[0].scrypt_phy == 0)
14479 {
14480 log_error ("ERROR: can't allocate enough device memory");
14481
14482 return -1;
14483 }
14484
14485 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14486 }
14487
14488 /**
14489 * some algorithms need a fixed kernel-loops count
14490 */
14491
14492 if (hash_mode == 1500)
14493 {
14494 const u32 kernel_loops_fixed = 1024;
14495
14496 device_param->kernel_loops_min = kernel_loops_fixed;
14497 device_param->kernel_loops_max = kernel_loops_fixed;
14498 }
14499
14500 if (hash_mode == 3000)
14501 {
14502 const u32 kernel_loops_fixed = 1024;
14503
14504 device_param->kernel_loops_min = kernel_loops_fixed;
14505 device_param->kernel_loops_max = kernel_loops_fixed;
14506 }
14507
14508 if (hash_mode == 8900)
14509 {
14510 const u32 kernel_loops_fixed = 1;
14511
14512 device_param->kernel_loops_min = kernel_loops_fixed;
14513 device_param->kernel_loops_max = kernel_loops_fixed;
14514 }
14515
14516 if (hash_mode == 9300)
14517 {
14518 const u32 kernel_loops_fixed = 1;
14519
14520 device_param->kernel_loops_min = kernel_loops_fixed;
14521 device_param->kernel_loops_max = kernel_loops_fixed;
14522 }
14523
14524 if (hash_mode == 12500)
14525 {
14526 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14527
14528 device_param->kernel_loops_min = kernel_loops_fixed;
14529 device_param->kernel_loops_max = kernel_loops_fixed;
14530 }
14531
14532 /**
14533 * some algorithms have a maximum kernel-loops count
14534 */
14535
14536 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14537 {
14538 u32 innerloop_cnt = 0;
14539
14540 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14541 {
14542 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14543 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14544 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14545 }
14546 else
14547 {
14548 innerloop_cnt = data.salts_buf[0].salt_iter;
14549 }
14550
14551 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14552 (innerloop_cnt <= device_param->kernel_loops_max))
14553 {
14554 device_param->kernel_loops_max = innerloop_cnt;
14555 }
14556 }
14557
14558 u32 kernel_accel_min = device_param->kernel_accel_min;
14559 u32 kernel_accel_max = device_param->kernel_accel_max;
14560
14561 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14562
14563 size_t size_pws = 4;
14564 size_t size_tmps = 4;
14565 size_t size_hooks = 4;
14566
14567 while (kernel_accel_max >= kernel_accel_min)
14568 {
14569 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14570
14571 // size_pws
14572
14573 size_pws = kernel_power_max * sizeof (pw_t);
14574
14575 // size_tmps
14576
14577 switch (hash_mode)
14578 {
14579 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14580 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14581 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14582 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14583 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14584 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14585 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14586 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14587 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14588 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14589 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14590 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14591 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14592 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14593 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14594 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14595 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14596 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14597 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14598 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14599 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14600 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14601 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14602 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14603 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14604 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14605 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14606 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14607 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14608 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14609 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14610 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14611 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14612 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14613 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14614 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14615 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14616 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14617 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14618 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14619 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14620 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14621 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14622 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14623 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14624 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14625 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14626 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14627 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14628 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14629 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14630 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14631 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14632 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14633 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14634 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14635 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14636 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14637 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14638 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14639 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14640 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14641 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14642 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14643 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14644 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14645 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14646 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14647 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14648 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14649 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14650 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14651 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14652 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14653 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14654 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14655 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14656 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14657 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14658 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14659 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14660 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14661 };
14662
14663 // size_hooks
14664
14665 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14666 {
14667 // none yet
14668 }
14669
14670 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14671 // if not, decrease amplifier and try again
14672
14673 int skip = 0;
14674
14675 const u64 size_total
14676 = bitmap_size
14677 + bitmap_size
14678 + bitmap_size
14679 + bitmap_size
14680 + bitmap_size
14681 + bitmap_size
14682 + bitmap_size
14683 + bitmap_size
14684 + size_bfs
14685 + size_combs
14686 + size_digests
14687 + size_esalts
14688 + size_hooks
14689 + size_markov_css
14690 + size_plains
14691 + size_pws
14692 + size_pws // not a bug
14693 + size_results
14694 + size_root_css
14695 + size_rules
14696 + size_rules_c
14697 + size_salts
14698 + size_scryptV
14699 + size_shown
14700 + size_tm
14701 + size_tmps;
14702
14703 // Don't ask me, ask AMD!
14704
14705 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14706 if (size_total > device_param->device_global_mem) skip = 1;
14707
14708 if (skip == 1)
14709 {
14710 kernel_accel_max--;
14711
14712 continue;
14713 }
14714
14715 break;
14716 }
14717
14718 /*
14719 if (kernel_accel_max == 0)
14720 {
14721 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14722
14723 return -1;
14724 }
14725 */
14726
14727 device_param->kernel_accel_min = kernel_accel_min;
14728 device_param->kernel_accel_max = kernel_accel_max;
14729
14730 /*
14731 if (kernel_accel_max < kernel_accel)
14732 {
14733 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14734
14735 device_param->kernel_accel = kernel_accel_max;
14736 }
14737 */
14738
14739 device_param->size_bfs = size_bfs;
14740 device_param->size_combs = size_combs;
14741 device_param->size_rules = size_rules;
14742 device_param->size_rules_c = size_rules_c;
14743 device_param->size_pws = size_pws;
14744 device_param->size_tmps = size_tmps;
14745 device_param->size_hooks = size_hooks;
14746
14747 // do not confuse kernel_accel_max with kernel_accel here
14748
14749 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14750
14751 device_param->kernel_threads = kernel_threads;
14752 device_param->kernel_power_user = kernel_power;
14753
14754 kernel_power_all += kernel_power;
14755
14756 /**
14757 * default building options
14758 */
14759
14760 char build_opts[1024] = { 0 };
14761
14762 // we don't have sm_* on vendors not NV but it doesn't matter
14763
14764 #if _WIN
14765 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);
14766 #else
14767 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);
14768 #endif
14769
14770 char build_opts_new[1024] = { 0 };
14771
14772 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);
14773
14774 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14775
14776 /*
14777 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14778 {
14779 // we do vectorizing much better than the auto-vectorizer
14780
14781 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14782
14783 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14784 }
14785 */
14786
14787 #ifdef DEBUG
14788 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14789 #endif
14790
14791 /**
14792 * main kernel
14793 */
14794
14795 {
14796 /**
14797 * kernel source filename
14798 */
14799
14800 char source_file[256] = { 0 };
14801
14802 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14803
14804 struct stat sst;
14805
14806 if (stat (source_file, &sst) == -1)
14807 {
14808 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14809
14810 return -1;
14811 }
14812
14813 /**
14814 * kernel cached filename
14815 */
14816
14817 char cached_file[256] = { 0 };
14818
14819 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14820
14821 int cached = 1;
14822
14823 struct stat cst;
14824
14825 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14826 {
14827 cached = 0;
14828 }
14829
14830 /**
14831 * kernel compile or load
14832 */
14833
14834 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14835
14836 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14837
14838 if (force_jit_compilation == -1)
14839 {
14840 if (cached == 0)
14841 {
14842 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14843
14844 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14845
14846 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14847
14848 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14849
14850 #ifdef DEBUG
14851 size_t build_log_size = 0;
14852
14853 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14854
14855 if (build_log_size > 1)
14856 {
14857 char *build_log = (char *) malloc (build_log_size + 1);
14858
14859 memset (build_log, 0, build_log_size + 1);
14860
14861 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14862
14863 puts (build_log);
14864
14865 free (build_log);
14866 }
14867 #endif
14868
14869 if (rc != 0)
14870 {
14871 device_param->skipped = true;
14872
14873 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14874
14875 continue;
14876 }
14877
14878 size_t binary_size;
14879
14880 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14881
14882 u8 *binary = (u8 *) mymalloc (binary_size);
14883
14884 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14885
14886 writeProgramBin (cached_file, binary, binary_size);
14887
14888 local_free (binary);
14889 }
14890 else
14891 {
14892 #ifdef DEBUG
14893 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14894 #endif
14895
14896 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14897
14898 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14899
14900 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14901 }
14902 }
14903 else
14904 {
14905 #ifdef DEBUG
14906 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14907 #endif
14908
14909 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14910
14911 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14912
14913 char build_opts_update[1024] = { 0 };
14914
14915 if (force_jit_compilation == 1500)
14916 {
14917 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14918 }
14919 else if (force_jit_compilation == 8900)
14920 {
14921 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);
14922 }
14923 else
14924 {
14925 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14926 }
14927
14928 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14929
14930 #ifdef DEBUG
14931 size_t build_log_size = 0;
14932
14933 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14934
14935 if (build_log_size > 1)
14936 {
14937 char *build_log = (char *) malloc (build_log_size + 1);
14938
14939 memset (build_log, 0, build_log_size + 1);
14940
14941 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14942
14943 puts (build_log);
14944
14945 free (build_log);
14946 }
14947 #endif
14948
14949 if (rc != 0)
14950 {
14951 device_param->skipped = true;
14952
14953 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14954 }
14955 }
14956
14957 local_free (kernel_lengths);
14958 local_free (kernel_sources[0]);
14959 local_free (kernel_sources);
14960 }
14961
14962 /**
14963 * word generator kernel
14964 */
14965
14966 if (attack_mode != ATTACK_MODE_STRAIGHT)
14967 {
14968 /**
14969 * kernel mp source filename
14970 */
14971
14972 char source_file[256] = { 0 };
14973
14974 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14975
14976 struct stat sst;
14977
14978 if (stat (source_file, &sst) == -1)
14979 {
14980 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14981
14982 return -1;
14983 }
14984
14985 /**
14986 * kernel mp cached filename
14987 */
14988
14989 char cached_file[256] = { 0 };
14990
14991 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14992
14993 int cached = 1;
14994
14995 struct stat cst;
14996
14997 if (stat (cached_file, &cst) == -1)
14998 {
14999 cached = 0;
15000 }
15001
15002 /**
15003 * kernel compile or load
15004 */
15005
15006 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15007
15008 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15009
15010 if (cached == 0)
15011 {
15012 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15013 if (quiet == 0) log_info ("");
15014
15015 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15016
15017 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15018
15019 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15020
15021 if (rc != 0)
15022 {
15023 device_param->skipped = true;
15024
15025 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15026
15027 continue;
15028 }
15029
15030 size_t binary_size;
15031
15032 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15033
15034 u8 *binary = (u8 *) mymalloc (binary_size);
15035
15036 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15037
15038 writeProgramBin (cached_file, binary, binary_size);
15039
15040 local_free (binary);
15041 }
15042 else
15043 {
15044 #ifdef DEBUG
15045 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15046 #endif
15047
15048 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15049
15050 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15051
15052 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15053 }
15054
15055 local_free (kernel_lengths);
15056 local_free (kernel_sources[0]);
15057 local_free (kernel_sources);
15058 }
15059
15060 /**
15061 * amplifier kernel
15062 */
15063
15064 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15065 {
15066
15067 }
15068 else
15069 {
15070 /**
15071 * kernel amp source filename
15072 */
15073
15074 char source_file[256] = { 0 };
15075
15076 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15077
15078 struct stat sst;
15079
15080 if (stat (source_file, &sst) == -1)
15081 {
15082 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15083
15084 return -1;
15085 }
15086
15087 /**
15088 * kernel amp cached filename
15089 */
15090
15091 char cached_file[256] = { 0 };
15092
15093 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15094
15095 int cached = 1;
15096
15097 struct stat cst;
15098
15099 if (stat (cached_file, &cst) == -1)
15100 {
15101 cached = 0;
15102 }
15103
15104 /**
15105 * kernel compile or load
15106 */
15107
15108 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15109
15110 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15111
15112 if (cached == 0)
15113 {
15114 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15115 if (quiet == 0) log_info ("");
15116
15117 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15118
15119 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15120
15121 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15122
15123 if (rc != 0)
15124 {
15125 device_param->skipped = true;
15126
15127 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15128
15129 continue;
15130 }
15131
15132 size_t binary_size;
15133
15134 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15135
15136 u8 *binary = (u8 *) mymalloc (binary_size);
15137
15138 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15139
15140 writeProgramBin (cached_file, binary, binary_size);
15141
15142 local_free (binary);
15143 }
15144 else
15145 {
15146 #ifdef DEBUG
15147 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15148 #endif
15149
15150 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15151
15152 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15153
15154 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15155 }
15156
15157 local_free (kernel_lengths);
15158 local_free (kernel_sources[0]);
15159 local_free (kernel_sources);
15160 }
15161
15162 // some algorithm collide too fast, make that impossible
15163
15164 if (benchmark == 1)
15165 {
15166 ((uint *) digests_buf)[0] = -1;
15167 ((uint *) digests_buf)[1] = -1;
15168 ((uint *) digests_buf)[2] = -1;
15169 ((uint *) digests_buf)[3] = -1;
15170 }
15171
15172 /**
15173 * global buffers
15174 */
15175
15176 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15177 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15178 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15179 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15180 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15181 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15182 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15183 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15184 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15185 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15186 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15187 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15188 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15189 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15190 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15191 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15192 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15193 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15194
15195 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);
15196 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);
15197 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);
15198 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);
15199 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);
15200 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);
15201 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);
15202 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);
15203 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15204 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15205 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15206
15207 /**
15208 * special buffers
15209 */
15210
15211 if (attack_kern == ATTACK_KERN_STRAIGHT)
15212 {
15213 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15214 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15215
15216 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15217 }
15218 else if (attack_kern == ATTACK_KERN_COMBI)
15219 {
15220 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15221 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15222 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15223 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15224 }
15225 else if (attack_kern == ATTACK_KERN_BF)
15226 {
15227 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15228 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15229 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15230 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15231 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15232 }
15233
15234 if (size_esalts)
15235 {
15236 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15237
15238 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15239 }
15240
15241 /**
15242 * main host data
15243 */
15244
15245 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15246
15247 device_param->pws_buf = pws_buf;
15248
15249 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15250
15251 device_param->combs_buf = combs_buf;
15252
15253 void *hooks_buf = mymalloc (size_hooks);
15254
15255 device_param->hooks_buf = hooks_buf;
15256
15257 /**
15258 * kernel args
15259 */
15260
15261 device_param->kernel_params_buf32[21] = bitmap_mask;
15262 device_param->kernel_params_buf32[22] = bitmap_shift1;
15263 device_param->kernel_params_buf32[23] = bitmap_shift2;
15264 device_param->kernel_params_buf32[24] = 0; // salt_pos
15265 device_param->kernel_params_buf32[25] = 0; // loop_pos
15266 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15267 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15268 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15269 device_param->kernel_params_buf32[29] = 0; // digests_offset
15270 device_param->kernel_params_buf32[30] = 0; // combs_mode
15271 device_param->kernel_params_buf32[31] = 0; // gid_max
15272
15273 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15274 ? &device_param->d_pws_buf
15275 : &device_param->d_pws_amp_buf;
15276 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15277 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15278 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15279 device_param->kernel_params[ 4] = &device_param->d_tmps;
15280 device_param->kernel_params[ 5] = &device_param->d_hooks;
15281 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15282 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15283 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15284 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15285 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15286 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15287 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15288 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15289 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15290 device_param->kernel_params[15] = &device_param->d_digests_buf;
15291 device_param->kernel_params[16] = &device_param->d_digests_shown;
15292 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15293 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15294 device_param->kernel_params[19] = &device_param->d_result;
15295 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15296 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15297 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15298 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15299 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15300 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15301 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15302 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15303 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15304 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15305 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15306 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15307
15308 device_param->kernel_params_mp_buf64[3] = 0;
15309 device_param->kernel_params_mp_buf32[4] = 0;
15310 device_param->kernel_params_mp_buf32[5] = 0;
15311 device_param->kernel_params_mp_buf32[6] = 0;
15312 device_param->kernel_params_mp_buf32[7] = 0;
15313 device_param->kernel_params_mp_buf32[8] = 0;
15314
15315 device_param->kernel_params_mp[0] = NULL;
15316 device_param->kernel_params_mp[1] = NULL;
15317 device_param->kernel_params_mp[2] = NULL;
15318 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15319 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15320 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15321 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15322 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15323 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15324
15325 device_param->kernel_params_mp_l_buf64[3] = 0;
15326 device_param->kernel_params_mp_l_buf32[4] = 0;
15327 device_param->kernel_params_mp_l_buf32[5] = 0;
15328 device_param->kernel_params_mp_l_buf32[6] = 0;
15329 device_param->kernel_params_mp_l_buf32[7] = 0;
15330 device_param->kernel_params_mp_l_buf32[8] = 0;
15331 device_param->kernel_params_mp_l_buf32[9] = 0;
15332
15333 device_param->kernel_params_mp_l[0] = NULL;
15334 device_param->kernel_params_mp_l[1] = NULL;
15335 device_param->kernel_params_mp_l[2] = NULL;
15336 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15337 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15338 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15339 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15340 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15341 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15342 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15343
15344 device_param->kernel_params_mp_r_buf64[3] = 0;
15345 device_param->kernel_params_mp_r_buf32[4] = 0;
15346 device_param->kernel_params_mp_r_buf32[5] = 0;
15347 device_param->kernel_params_mp_r_buf32[6] = 0;
15348 device_param->kernel_params_mp_r_buf32[7] = 0;
15349 device_param->kernel_params_mp_r_buf32[8] = 0;
15350
15351 device_param->kernel_params_mp_r[0] = NULL;
15352 device_param->kernel_params_mp_r[1] = NULL;
15353 device_param->kernel_params_mp_r[2] = NULL;
15354 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15355 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15356 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15357 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15358 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15359 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15360
15361 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15362 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15363
15364 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15365 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15366 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15367 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15368 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15369 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15370 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15371
15372 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15373 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15374
15375 device_param->kernel_params_memset_buf32[1] = 0; // value
15376 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15377
15378 device_param->kernel_params_memset[0] = NULL;
15379 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15380 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15381
15382 /**
15383 * kernel name
15384 */
15385
15386 size_t kernel_wgs_tmp;
15387
15388 char kernel_name[64] = { 0 };
15389
15390 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15391 {
15392 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15393 {
15394 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15395
15396 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15397
15398 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15399
15400 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15401
15402 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15403
15404 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15405 }
15406 else
15407 {
15408 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15409
15410 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15411
15412 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15413
15414 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15415
15416 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15417
15418 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15419 }
15420
15421 if (data.attack_mode == ATTACK_MODE_BF)
15422 {
15423 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15424 {
15425 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15426
15427 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15428
15429 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);
15430 }
15431 }
15432 }
15433 else
15434 {
15435 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15436
15437 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15438
15439 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15440
15441 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15442
15443 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15444
15445 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15446
15447 if (opts_type & OPTS_TYPE_HOOK12)
15448 {
15449 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15450
15451 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15452
15453 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);
15454 }
15455
15456 if (opts_type & OPTS_TYPE_HOOK23)
15457 {
15458 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15459
15460 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15461
15462 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);
15463 }
15464 }
15465
15466 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);
15467 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);
15468 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);
15469
15470 for (uint i = 0; i <= 20; i++)
15471 {
15472 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15473 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15474 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15475
15476 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15477 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15478 }
15479
15480 for (uint i = 21; i <= 31; i++)
15481 {
15482 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15483 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15484 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15485
15486 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15487 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15488 }
15489
15490 // GPU memset
15491
15492 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15493
15494 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);
15495
15496 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15497 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15498 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15499
15500 // MP start
15501
15502 if (attack_mode == ATTACK_MODE_BF)
15503 {
15504 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15505 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15506
15507 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);
15508 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);
15509
15510 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15511 {
15512 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15513 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15514 }
15515 }
15516 else if (attack_mode == ATTACK_MODE_HYBRID1)
15517 {
15518 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15519
15520 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);
15521 }
15522 else if (attack_mode == ATTACK_MODE_HYBRID2)
15523 {
15524 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15525
15526 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);
15527 }
15528
15529 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15530 {
15531 // nothing to do
15532 }
15533 else
15534 {
15535 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15536
15537 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);
15538 }
15539
15540 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15541 {
15542 // nothing to do
15543 }
15544 else
15545 {
15546 for (uint i = 0; i < 5; i++)
15547 {
15548 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15549 }
15550
15551 for (uint i = 5; i < 7; i++)
15552 {
15553 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15554 }
15555 }
15556
15557 // maybe this has been updated by clGetKernelWorkGroupInfo()
15558 // value can only be decreased, so we don't need to reallocate buffers
15559
15560 device_param->kernel_threads = kernel_threads;
15561
15562 // zero some data buffers
15563
15564 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15565 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15566 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15567 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15568 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15569 run_kernel_bzero (device_param, device_param->d_result, size_results);
15570
15571 /**
15572 * special buffers
15573 */
15574
15575 if (attack_kern == ATTACK_KERN_STRAIGHT)
15576 {
15577 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15578 }
15579 else if (attack_kern == ATTACK_KERN_COMBI)
15580 {
15581 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15582 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15583 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15584 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15585 }
15586 else if (attack_kern == ATTACK_KERN_BF)
15587 {
15588 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15589 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15590 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15591 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15592 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15593 }
15594
15595 #if defined(HAVE_HWMON)
15596
15597 /**
15598 * Store thermal target temperature so we can send a notice to user
15599 */
15600
15601 if (gpu_temp_disable == 0)
15602 {
15603 const int gpu_temp_threshold_slowdown = hm_get_threshold_slowdown_with_device_id (device_id);
15604
15605 data.hm_device[device_id].gpu_temp_threshold_slowdown = (gpu_temp_threshold_slowdown == -1) ? 100000 : gpu_temp_threshold_slowdown;
15606 }
15607
15608 /**
15609 * Store initial fanspeed if gpu_temp_retain is enabled
15610 */
15611
15612 if (gpu_temp_disable == 0)
15613 {
15614 if (gpu_temp_retain != 0)
15615 {
15616 hc_thread_mutex_lock (mux_adl);
15617
15618 if (data.hm_device[device_id].fan_get_supported == 1)
15619 {
15620 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
15621 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
15622
15623 temp_retain_fanspeed_value[device_id] = fanspeed;
15624 temp_retain_fanpolicy_value[device_id] = fanpolicy;
15625
15626 // we also set it to tell the OS we take control over the fan and it's automatic controller
15627 // if it was set to automatic. we do not control user-defined fanspeeds.
15628
15629 if (fanpolicy == 1)
15630 {
15631 data.hm_device[device_id].fan_set_supported = 1;
15632
15633 int rc = -1;
15634
15635 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15636 {
15637 rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed, 1);
15638 }
15639 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15640 {
15641 #ifdef _WIN
15642 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
15643 #endif
15644 }
15645
15646 if (rc == 0)
15647 {
15648 data.hm_device[device_id].fan_set_supported = 1;
15649 }
15650 else
15651 {
15652 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
15653
15654 data.hm_device[device_id].fan_set_supported = 0;
15655 }
15656 }
15657 else
15658 {
15659 data.hm_device[device_id].fan_set_supported = 0;
15660 }
15661 }
15662
15663 hc_thread_mutex_unlock (mux_adl);
15664 }
15665 }
15666
15667 /**
15668 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15669 */
15670
15671 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15672 {
15673 hc_thread_mutex_lock (mux_adl);
15674
15675 if (data.hm_device[device_id].od_version == 6)
15676 {
15677 int ADL_rc;
15678
15679 // check powertune capabilities first, if not available then skip device
15680
15681 int powertune_supported = 0;
15682
15683 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15684 {
15685 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15686
15687 return (-1);
15688 }
15689
15690 if (powertune_supported != 0)
15691 {
15692 // powercontrol settings
15693
15694 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15695
15696 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15697 {
15698 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15699 }
15700
15701 if (ADL_rc != ADL_OK)
15702 {
15703 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15704
15705 return (-1);
15706 }
15707
15708 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15709 {
15710 log_error ("ERROR: Failed to set new ADL PowerControl values");
15711
15712 return (-1);
15713 }
15714
15715 // clocks
15716
15717 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15718
15719 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15720
15721 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)
15722 {
15723 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15724
15725 return (-1);
15726 }
15727
15728 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15729
15730 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15731
15732 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15733 {
15734 log_error ("ERROR: Failed to get ADL device capabilities");
15735
15736 return (-1);
15737 }
15738
15739 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15740 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15741
15742 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15743 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15744
15745 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15746 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15747
15748 // warning if profile has too low max values
15749
15750 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15751 {
15752 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15753 }
15754
15755 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15756 {
15757 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15758 }
15759
15760 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15761
15762 performance_state->iNumberOfPerformanceLevels = 2;
15763
15764 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15765 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15766 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15767 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15768
15769 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)
15770 {
15771 log_info ("ERROR: Failed to set ADL performance state");
15772
15773 return (-1);
15774 }
15775
15776 local_free (performance_state);
15777 }
15778 }
15779
15780 hc_thread_mutex_unlock (mux_adl);
15781 }
15782
15783 #endif // HAVE_HWMON
15784 }
15785
15786 data.kernel_power_all = kernel_power_all;
15787
15788 if (data.quiet == 0) log_info_nn ("");
15789
15790 /**
15791 * In benchmark-mode, inform user which algorithm is checked
15792 */
15793
15794 if (benchmark == 1)
15795 {
15796 if (machine_readable == 0)
15797 {
15798 quiet = 0;
15799
15800 data.quiet = quiet;
15801
15802 char *hash_type = strhashtype (data.hash_mode); // not a bug
15803
15804 log_info ("Hashtype: %s", hash_type);
15805 log_info ("");
15806 }
15807 }
15808
15809 /**
15810 * keep track of the progress
15811 */
15812
15813 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15814 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15815 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15816
15817 /**
15818 * open filehandles
15819 */
15820
15821 #if _WIN
15822 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15823 {
15824 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15825
15826 return (-1);
15827 }
15828
15829 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15830 {
15831 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15832
15833 return (-1);
15834 }
15835
15836 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15837 {
15838 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15839
15840 return (-1);
15841 }
15842 #endif
15843
15844 /**
15845 * dictionary pad
15846 */
15847
15848 segment_size *= (1024 * 1024);
15849
15850 data.segment_size = segment_size;
15851
15852 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15853
15854 wl_data->buf = (char *) mymalloc (segment_size);
15855 wl_data->avail = segment_size;
15856 wl_data->incr = segment_size;
15857 wl_data->cnt = 0;
15858 wl_data->pos = 0;
15859
15860 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15861
15862 data.wordlist_mode = wordlist_mode;
15863
15864 cs_t *css_buf = NULL;
15865 uint css_cnt = 0;
15866 uint dictcnt = 0;
15867 uint maskcnt = 1;
15868 char **masks = NULL;
15869 char **dictfiles = NULL;
15870
15871 uint mask_from_file = 0;
15872
15873 if (attack_mode == ATTACK_MODE_STRAIGHT)
15874 {
15875 if (wordlist_mode == WL_MODE_FILE)
15876 {
15877 int wls_left = myargc - (optind + 1);
15878
15879 for (int i = 0; i < wls_left; i++)
15880 {
15881 char *l0_filename = myargv[optind + 1 + i];
15882
15883 struct stat l0_stat;
15884
15885 if (stat (l0_filename, &l0_stat) == -1)
15886 {
15887 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15888
15889 return (-1);
15890 }
15891
15892 uint is_dir = S_ISDIR (l0_stat.st_mode);
15893
15894 if (is_dir == 0)
15895 {
15896 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15897
15898 dictcnt++;
15899
15900 dictfiles[dictcnt - 1] = l0_filename;
15901 }
15902 else
15903 {
15904 // do not allow --keyspace w/ a directory
15905
15906 if (keyspace == 1)
15907 {
15908 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15909
15910 return (-1);
15911 }
15912
15913 char **dictionary_files = NULL;
15914
15915 dictionary_files = scan_directory (l0_filename);
15916
15917 if (dictionary_files != NULL)
15918 {
15919 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15920
15921 for (int d = 0; dictionary_files[d] != NULL; d++)
15922 {
15923 char *l1_filename = dictionary_files[d];
15924
15925 struct stat l1_stat;
15926
15927 if (stat (l1_filename, &l1_stat) == -1)
15928 {
15929 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15930
15931 return (-1);
15932 }
15933
15934 if (S_ISREG (l1_stat.st_mode))
15935 {
15936 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15937
15938 dictcnt++;
15939
15940 dictfiles[dictcnt - 1] = strdup (l1_filename);
15941 }
15942 }
15943 }
15944
15945 local_free (dictionary_files);
15946 }
15947 }
15948
15949 if (dictcnt < 1)
15950 {
15951 log_error ("ERROR: No usable dictionary file found.");
15952
15953 return (-1);
15954 }
15955 }
15956 else if (wordlist_mode == WL_MODE_STDIN)
15957 {
15958 dictcnt = 1;
15959 }
15960 }
15961 else if (attack_mode == ATTACK_MODE_COMBI)
15962 {
15963 // display
15964
15965 char *dictfile1 = myargv[optind + 1 + 0];
15966 char *dictfile2 = myargv[optind + 1 + 1];
15967
15968 // find the bigger dictionary and use as base
15969
15970 FILE *fp1 = NULL;
15971 FILE *fp2 = NULL;
15972
15973 struct stat tmp_stat;
15974
15975 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15976 {
15977 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15978
15979 return (-1);
15980 }
15981
15982 if (stat (dictfile1, &tmp_stat) == -1)
15983 {
15984 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15985
15986 fclose (fp1);
15987
15988 return (-1);
15989 }
15990
15991 if (S_ISDIR (tmp_stat.st_mode))
15992 {
15993 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15994
15995 fclose (fp1);
15996
15997 return (-1);
15998 }
15999
16000 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16001 {
16002 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16003
16004 fclose (fp1);
16005
16006 return (-1);
16007 }
16008
16009 if (stat (dictfile2, &tmp_stat) == -1)
16010 {
16011 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16012
16013 fclose (fp1);
16014 fclose (fp2);
16015
16016 return (-1);
16017 }
16018
16019 if (S_ISDIR (tmp_stat.st_mode))
16020 {
16021 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16022
16023 fclose (fp1);
16024 fclose (fp2);
16025
16026 return (-1);
16027 }
16028
16029 data.combs_cnt = 1;
16030
16031 data.quiet = 1;
16032
16033 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16034
16035 data.quiet = quiet;
16036
16037 if (words1_cnt == 0)
16038 {
16039 log_error ("ERROR: %s: empty file", dictfile1);
16040
16041 fclose (fp1);
16042 fclose (fp2);
16043
16044 return (-1);
16045 }
16046
16047 data.combs_cnt = 1;
16048
16049 data.quiet = 1;
16050
16051 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16052
16053 data.quiet = quiet;
16054
16055 if (words2_cnt == 0)
16056 {
16057 log_error ("ERROR: %s: empty file", dictfile2);
16058
16059 fclose (fp1);
16060 fclose (fp2);
16061
16062 return (-1);
16063 }
16064
16065 fclose (fp1);
16066 fclose (fp2);
16067
16068 data.dictfile = dictfile1;
16069 data.dictfile2 = dictfile2;
16070
16071 if (words1_cnt >= words2_cnt)
16072 {
16073 data.combs_cnt = words2_cnt;
16074 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16075
16076 dictfiles = &data.dictfile;
16077
16078 dictcnt = 1;
16079 }
16080 else
16081 {
16082 data.combs_cnt = words1_cnt;
16083 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16084
16085 dictfiles = &data.dictfile2;
16086
16087 dictcnt = 1;
16088
16089 // we also have to switch wordlist related rules!
16090
16091 char *tmpc = data.rule_buf_l;
16092
16093 data.rule_buf_l = data.rule_buf_r;
16094 data.rule_buf_r = tmpc;
16095
16096 int tmpi = data.rule_len_l;
16097
16098 data.rule_len_l = data.rule_len_r;
16099 data.rule_len_r = tmpi;
16100 }
16101 }
16102 else if (attack_mode == ATTACK_MODE_BF)
16103 {
16104 char *mask = NULL;
16105
16106 maskcnt = 0;
16107
16108 if (benchmark == 0)
16109 {
16110 mask = myargv[optind + 1];
16111
16112 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16113
16114 if ((optind + 2) <= myargc)
16115 {
16116 struct stat file_stat;
16117
16118 if (stat (mask, &file_stat) == -1)
16119 {
16120 maskcnt = 1;
16121
16122 masks[maskcnt - 1] = mystrdup (mask);
16123 }
16124 else
16125 {
16126 int wls_left = myargc - (optind + 1);
16127
16128 uint masks_avail = INCR_MASKS;
16129
16130 for (int i = 0; i < wls_left; i++)
16131 {
16132 if (i != 0)
16133 {
16134 mask = myargv[optind + 1 + i];
16135
16136 if (stat (mask, &file_stat) == -1)
16137 {
16138 log_error ("ERROR: %s: %s", mask, strerror (errno));
16139
16140 return (-1);
16141 }
16142 }
16143
16144 uint is_file = S_ISREG (file_stat.st_mode);
16145
16146 if (is_file == 1)
16147 {
16148 FILE *mask_fp;
16149
16150 if ((mask_fp = fopen (mask, "r")) == NULL)
16151 {
16152 log_error ("ERROR: %s: %s", mask, strerror (errno));
16153
16154 return (-1);
16155 }
16156
16157 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16158
16159 while (!feof (mask_fp))
16160 {
16161 memset (line_buf, 0, HCBUFSIZ);
16162
16163 int line_len = fgetl (mask_fp, line_buf);
16164
16165 if (line_len == 0) continue;
16166
16167 if (line_buf[0] == '#') continue;
16168
16169 if (masks_avail == maskcnt)
16170 {
16171 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16172
16173 masks_avail += INCR_MASKS;
16174 }
16175
16176 masks[maskcnt] = mystrdup (line_buf);
16177
16178 maskcnt++;
16179 }
16180
16181 myfree (line_buf);
16182
16183 fclose (mask_fp);
16184 }
16185 else
16186 {
16187 log_error ("ERROR: %s: unsupported file-type", mask);
16188
16189 return (-1);
16190 }
16191 }
16192
16193 mask_from_file = 1;
16194 }
16195 }
16196 else
16197 {
16198 custom_charset_1 = (char *) "?l?d?u";
16199 custom_charset_2 = (char *) "?l?d";
16200 custom_charset_3 = (char *) "?l?d*!$@_";
16201
16202 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16203 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16204 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16205
16206 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16207
16208 wordlist_mode = WL_MODE_MASK;
16209
16210 data.wordlist_mode = wordlist_mode;
16211
16212 increment = 1;
16213
16214 maskcnt = 1;
16215 }
16216 }
16217 else
16218 {
16219 /**
16220 * generate full masks and charsets
16221 */
16222
16223 masks = (char **) mymalloc (sizeof (char *));
16224
16225 switch (hash_mode)
16226 {
16227 case 1731: pw_min = 5;
16228 pw_max = 5;
16229 mask = mystrdup ("?b?b?b?b?b");
16230 break;
16231 case 12500: pw_min = 5;
16232 pw_max = 5;
16233 mask = mystrdup ("?b?b?b?b?b");
16234 break;
16235 default: pw_min = 7;
16236 pw_max = 7;
16237 mask = mystrdup ("?b?b?b?b?b?b?b");
16238 break;
16239 }
16240
16241 maskcnt = 1;
16242
16243 masks[maskcnt - 1] = mystrdup (mask);
16244
16245 wordlist_mode = WL_MODE_MASK;
16246
16247 data.wordlist_mode = wordlist_mode;
16248
16249 increment = 1;
16250 }
16251
16252 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16253
16254 if (increment)
16255 {
16256 if (increment_min > pw_min) pw_min = increment_min;
16257
16258 if (increment_max < pw_max) pw_max = increment_max;
16259 }
16260 }
16261 else if (attack_mode == ATTACK_MODE_HYBRID1)
16262 {
16263 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16264
16265 // display
16266
16267 char *mask = myargv[myargc - 1];
16268
16269 maskcnt = 0;
16270
16271 masks = (char **) mymalloc (1 * sizeof (char *));
16272
16273 // mod
16274
16275 struct stat file_stat;
16276
16277 if (stat (mask, &file_stat) == -1)
16278 {
16279 maskcnt = 1;
16280
16281 masks[maskcnt - 1] = mystrdup (mask);
16282 }
16283 else
16284 {
16285 uint is_file = S_ISREG (file_stat.st_mode);
16286
16287 if (is_file == 1)
16288 {
16289 FILE *mask_fp;
16290
16291 if ((mask_fp = fopen (mask, "r")) == NULL)
16292 {
16293 log_error ("ERROR: %s: %s", mask, strerror (errno));
16294
16295 return (-1);
16296 }
16297
16298 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16299
16300 uint masks_avail = 1;
16301
16302 while (!feof (mask_fp))
16303 {
16304 memset (line_buf, 0, HCBUFSIZ);
16305
16306 int line_len = fgetl (mask_fp, line_buf);
16307
16308 if (line_len == 0) continue;
16309
16310 if (line_buf[0] == '#') continue;
16311
16312 if (masks_avail == maskcnt)
16313 {
16314 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16315
16316 masks_avail += INCR_MASKS;
16317 }
16318
16319 masks[maskcnt] = mystrdup (line_buf);
16320
16321 maskcnt++;
16322 }
16323
16324 myfree (line_buf);
16325
16326 fclose (mask_fp);
16327
16328 mask_from_file = 1;
16329 }
16330 else
16331 {
16332 maskcnt = 1;
16333
16334 masks[maskcnt - 1] = mystrdup (mask);
16335 }
16336 }
16337
16338 // base
16339
16340 int wls_left = myargc - (optind + 2);
16341
16342 for (int i = 0; i < wls_left; i++)
16343 {
16344 char *filename = myargv[optind + 1 + i];
16345
16346 struct stat file_stat;
16347
16348 if (stat (filename, &file_stat) == -1)
16349 {
16350 log_error ("ERROR: %s: %s", filename, strerror (errno));
16351
16352 return (-1);
16353 }
16354
16355 uint is_dir = S_ISDIR (file_stat.st_mode);
16356
16357 if (is_dir == 0)
16358 {
16359 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16360
16361 dictcnt++;
16362
16363 dictfiles[dictcnt - 1] = filename;
16364 }
16365 else
16366 {
16367 // do not allow --keyspace w/ a directory
16368
16369 if (keyspace == 1)
16370 {
16371 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16372
16373 return (-1);
16374 }
16375
16376 char **dictionary_files = NULL;
16377
16378 dictionary_files = scan_directory (filename);
16379
16380 if (dictionary_files != NULL)
16381 {
16382 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16383
16384 for (int d = 0; dictionary_files[d] != NULL; d++)
16385 {
16386 char *l1_filename = dictionary_files[d];
16387
16388 struct stat l1_stat;
16389
16390 if (stat (l1_filename, &l1_stat) == -1)
16391 {
16392 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16393
16394 return (-1);
16395 }
16396
16397 if (S_ISREG (l1_stat.st_mode))
16398 {
16399 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16400
16401 dictcnt++;
16402
16403 dictfiles[dictcnt - 1] = strdup (l1_filename);
16404 }
16405 }
16406 }
16407
16408 local_free (dictionary_files);
16409 }
16410 }
16411
16412 if (dictcnt < 1)
16413 {
16414 log_error ("ERROR: No usable dictionary file found.");
16415
16416 return (-1);
16417 }
16418
16419 if (increment)
16420 {
16421 maskcnt = 0;
16422
16423 uint mask_min = increment_min; // we can't reject smaller masks here
16424 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16425
16426 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16427 {
16428 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16429
16430 if (cur_mask == NULL) break;
16431
16432 masks[maskcnt] = cur_mask;
16433
16434 maskcnt++;
16435
16436 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16437 }
16438 }
16439 }
16440 else if (attack_mode == ATTACK_MODE_HYBRID2)
16441 {
16442 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16443
16444 // display
16445
16446 char *mask = myargv[optind + 1 + 0];
16447
16448 maskcnt = 0;
16449
16450 masks = (char **) mymalloc (1 * sizeof (char *));
16451
16452 // mod
16453
16454 struct stat file_stat;
16455
16456 if (stat (mask, &file_stat) == -1)
16457 {
16458 maskcnt = 1;
16459
16460 masks[maskcnt - 1] = mystrdup (mask);
16461 }
16462 else
16463 {
16464 uint is_file = S_ISREG (file_stat.st_mode);
16465
16466 if (is_file == 1)
16467 {
16468 FILE *mask_fp;
16469
16470 if ((mask_fp = fopen (mask, "r")) == NULL)
16471 {
16472 log_error ("ERROR: %s: %s", mask, strerror (errno));
16473
16474 return (-1);
16475 }
16476
16477 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16478
16479 uint masks_avail = 1;
16480
16481 while (!feof (mask_fp))
16482 {
16483 memset (line_buf, 0, HCBUFSIZ);
16484
16485 int line_len = fgetl (mask_fp, line_buf);
16486
16487 if (line_len == 0) continue;
16488
16489 if (line_buf[0] == '#') continue;
16490
16491 if (masks_avail == maskcnt)
16492 {
16493 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16494
16495 masks_avail += INCR_MASKS;
16496 }
16497
16498 masks[maskcnt] = mystrdup (line_buf);
16499
16500 maskcnt++;
16501 }
16502
16503 myfree (line_buf);
16504
16505 fclose (mask_fp);
16506
16507 mask_from_file = 1;
16508 }
16509 else
16510 {
16511 maskcnt = 1;
16512
16513 masks[maskcnt - 1] = mystrdup (mask);
16514 }
16515 }
16516
16517 // base
16518
16519 int wls_left = myargc - (optind + 2);
16520
16521 for (int i = 0; i < wls_left; i++)
16522 {
16523 char *filename = myargv[optind + 2 + i];
16524
16525 struct stat file_stat;
16526
16527 if (stat (filename, &file_stat) == -1)
16528 {
16529 log_error ("ERROR: %s: %s", filename, strerror (errno));
16530
16531 return (-1);
16532 }
16533
16534 uint is_dir = S_ISDIR (file_stat.st_mode);
16535
16536 if (is_dir == 0)
16537 {
16538 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16539
16540 dictcnt++;
16541
16542 dictfiles[dictcnt - 1] = filename;
16543 }
16544 else
16545 {
16546 // do not allow --keyspace w/ a directory
16547
16548 if (keyspace == 1)
16549 {
16550 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16551
16552 return (-1);
16553 }
16554
16555 char **dictionary_files = NULL;
16556
16557 dictionary_files = scan_directory (filename);
16558
16559 if (dictionary_files != NULL)
16560 {
16561 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16562
16563 for (int d = 0; dictionary_files[d] != NULL; d++)
16564 {
16565 char *l1_filename = dictionary_files[d];
16566
16567 struct stat l1_stat;
16568
16569 if (stat (l1_filename, &l1_stat) == -1)
16570 {
16571 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16572
16573 return (-1);
16574 }
16575
16576 if (S_ISREG (l1_stat.st_mode))
16577 {
16578 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16579
16580 dictcnt++;
16581
16582 dictfiles[dictcnt - 1] = strdup (l1_filename);
16583 }
16584 }
16585 }
16586
16587 local_free (dictionary_files);
16588 }
16589 }
16590
16591 if (dictcnt < 1)
16592 {
16593 log_error ("ERROR: No usable dictionary file found.");
16594
16595 return (-1);
16596 }
16597
16598 if (increment)
16599 {
16600 maskcnt = 0;
16601
16602 uint mask_min = increment_min; // we can't reject smaller masks here
16603 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16604
16605 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16606 {
16607 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16608
16609 if (cur_mask == NULL) break;
16610
16611 masks[maskcnt] = cur_mask;
16612
16613 maskcnt++;
16614
16615 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16616 }
16617 }
16618 }
16619
16620 data.pw_min = pw_min;
16621 data.pw_max = pw_max;
16622
16623 /**
16624 * weak hash check
16625 */
16626
16627 if (weak_hash_threshold >= salts_cnt)
16628 {
16629 hc_device_param_t *device_param = NULL;
16630
16631 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16632 {
16633 device_param = &data.devices_param[device_id];
16634
16635 if (device_param->skipped) continue;
16636
16637 break;
16638 }
16639
16640 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16641
16642 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16643 {
16644 weak_hash_check (device_param, salt_pos);
16645 }
16646
16647 // Display hack, guarantee that there is at least one \r before real start
16648
16649 //if (data.quiet == 0) log_info ("");
16650 }
16651
16652 /**
16653 * status and monitor threads
16654 */
16655
16656 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16657
16658 hc_thread_t i_thread = 0;
16659
16660 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16661 {
16662 hc_thread_create (i_thread, thread_keypress, &benchmark);
16663 }
16664
16665 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16666
16667 uint ni_threads_cnt = 0;
16668
16669 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16670
16671 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16672
16673 ni_threads_cnt++;
16674
16675 /**
16676 * Outfile remove
16677 */
16678
16679 if (keyspace == 0)
16680 {
16681 if (outfile_check_timer != 0)
16682 {
16683 if (data.outfile_check_directory != NULL)
16684 {
16685 if ((hash_mode != 5200) &&
16686 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16687 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16688 (hash_mode != 9000))
16689 {
16690 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16691
16692 ni_threads_cnt++;
16693 }
16694 else
16695 {
16696 outfile_check_timer = 0;
16697 }
16698 }
16699 else
16700 {
16701 outfile_check_timer = 0;
16702 }
16703 }
16704 }
16705
16706 /**
16707 * Inform the user if we got some hashes remove because of the pot file remove feature
16708 */
16709
16710 if (data.quiet == 0)
16711 {
16712 if (potfile_remove_cracks > 0)
16713 {
16714 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16715 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16716 }
16717 }
16718
16719 data.outfile_check_timer = outfile_check_timer;
16720
16721 /**
16722 * main loop
16723 */
16724
16725 char **induction_dictionaries = NULL;
16726
16727 int induction_dictionaries_cnt = 0;
16728
16729 hcstat_table_t *root_table_buf = NULL;
16730 hcstat_table_t *markov_table_buf = NULL;
16731
16732 uint initial_restore_done = 0;
16733
16734 data.maskcnt = maskcnt;
16735
16736 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16737 {
16738 if (data.devices_status == STATUS_CRACKED) break;
16739
16740 data.devices_status = STATUS_INIT;
16741
16742 if (maskpos > rd->maskpos)
16743 {
16744 rd->dictpos = 0;
16745 }
16746
16747 rd->maskpos = maskpos;
16748 data.maskpos = maskpos;
16749
16750 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16751 {
16752 char *mask = masks[maskpos];
16753
16754 if (mask_from_file == 1)
16755 {
16756 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16757
16758 char *str_ptr;
16759 uint str_pos;
16760
16761 uint mask_offset = 0;
16762
16763 uint separator_cnt;
16764
16765 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16766 {
16767 str_ptr = strstr (mask + mask_offset, ",");
16768
16769 if (str_ptr == NULL) break;
16770
16771 str_pos = str_ptr - mask;
16772
16773 // escaped separator, i.e. "\,"
16774
16775 if (str_pos > 0)
16776 {
16777 if (mask[str_pos - 1] == '\\')
16778 {
16779 separator_cnt --;
16780
16781 mask_offset = str_pos + 1;
16782
16783 continue;
16784 }
16785 }
16786
16787 // reset the offset
16788
16789 mask_offset = 0;
16790
16791 mask[str_pos] = '\0';
16792
16793 switch (separator_cnt)
16794 {
16795 case 0:
16796 mp_reset_usr (mp_usr, 0);
16797
16798 custom_charset_1 = mask;
16799 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16800 break;
16801
16802 case 1:
16803 mp_reset_usr (mp_usr, 1);
16804
16805 custom_charset_2 = mask;
16806 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16807 break;
16808
16809 case 2:
16810 mp_reset_usr (mp_usr, 2);
16811
16812 custom_charset_3 = mask;
16813 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16814 break;
16815
16816 case 3:
16817 mp_reset_usr (mp_usr, 3);
16818
16819 custom_charset_4 = mask;
16820 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16821 break;
16822 }
16823
16824 mask = mask + str_pos + 1;
16825 }
16826 }
16827
16828 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16829 {
16830 if (maskpos > 0)
16831 {
16832 local_free (css_buf);
16833 local_free (data.root_css_buf);
16834 local_free (data.markov_css_buf);
16835
16836 local_free (masks[maskpos - 1]);
16837 }
16838
16839 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16840
16841 data.mask = mask;
16842 data.css_cnt = css_cnt;
16843 data.css_buf = css_buf;
16844
16845 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16846
16847 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16848
16849 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16850 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16851
16852 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16853
16854 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16855
16856 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16857 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16858
16859 data.root_css_buf = root_css_buf;
16860 data.markov_css_buf = markov_css_buf;
16861
16862 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16863
16864 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16865
16866 local_free (root_table_buf);
16867 local_free (markov_table_buf);
16868
16869 // args
16870
16871 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16872 {
16873 hc_device_param_t *device_param = &data.devices_param[device_id];
16874
16875 if (device_param->skipped) continue;
16876
16877 device_param->kernel_params_mp[0] = &device_param->d_combs;
16878 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16879 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16880
16881 device_param->kernel_params_mp_buf64[3] = 0;
16882 device_param->kernel_params_mp_buf32[4] = css_cnt;
16883 device_param->kernel_params_mp_buf32[5] = 0;
16884 device_param->kernel_params_mp_buf32[6] = 0;
16885 device_param->kernel_params_mp_buf32[7] = 0;
16886
16887 if (attack_mode == ATTACK_MODE_HYBRID1)
16888 {
16889 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16890 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16891 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16892 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16893 }
16894 else if (attack_mode == ATTACK_MODE_HYBRID2)
16895 {
16896 device_param->kernel_params_mp_buf32[5] = 0;
16897 device_param->kernel_params_mp_buf32[6] = 0;
16898 device_param->kernel_params_mp_buf32[7] = 0;
16899 }
16900
16901 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]);
16902 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]);
16903 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]);
16904
16905 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);
16906 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);
16907 }
16908 }
16909 else if (attack_mode == ATTACK_MODE_BF)
16910 {
16911 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16912
16913 if (increment)
16914 {
16915 for (uint i = 0; i < dictcnt; i++)
16916 {
16917 local_free (dictfiles[i]);
16918 }
16919
16920 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16921 {
16922 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16923
16924 if (l1_filename == NULL) break;
16925
16926 dictcnt++;
16927
16928 dictfiles[dictcnt - 1] = l1_filename;
16929 }
16930 }
16931 else
16932 {
16933 dictcnt++;
16934
16935 dictfiles[dictcnt - 1] = mask;
16936 }
16937
16938 if (dictcnt == 0)
16939 {
16940 log_error ("ERROR: Mask is too small");
16941
16942 return (-1);
16943 }
16944 }
16945 }
16946
16947 free (induction_dictionaries);
16948
16949 // induction_dictionaries_cnt = 0; // implied
16950
16951 if (attack_mode != ATTACK_MODE_BF)
16952 {
16953 if (keyspace == 0)
16954 {
16955 induction_dictionaries = scan_directory (induction_directory);
16956
16957 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16958 }
16959 }
16960
16961 if (induction_dictionaries_cnt)
16962 {
16963 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16964 }
16965
16966 /**
16967 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16968 */
16969 if (keyspace == 1)
16970 {
16971 if ((maskcnt > 1) || (dictcnt > 1))
16972 {
16973 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16974
16975 return (-1);
16976 }
16977 }
16978
16979 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16980 {
16981 char *subid = logfile_generate_subid ();
16982
16983 data.subid = subid;
16984
16985 logfile_sub_msg ("START");
16986
16987 data.devices_status = STATUS_INIT;
16988
16989 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16990 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16991 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16992
16993 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16994
16995 data.cpt_pos = 0;
16996
16997 data.cpt_start = time (NULL);
16998
16999 data.cpt_total = 0;
17000
17001 if (data.restore == 0)
17002 {
17003 rd->words_cur = skip;
17004
17005 skip = 0;
17006
17007 data.skip = 0;
17008 }
17009
17010 data.ms_paused = 0;
17011
17012 data.words_cur = rd->words_cur;
17013
17014 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17015 {
17016 hc_device_param_t *device_param = &data.devices_param[device_id];
17017
17018 if (device_param->skipped) continue;
17019
17020 device_param->speed_pos = 0;
17021
17022 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17023 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17024
17025 device_param->exec_pos = 0;
17026
17027 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17028
17029 device_param->kernel_power = device_param->kernel_power_user;
17030
17031 device_param->outerloop_pos = 0;
17032 device_param->outerloop_left = 0;
17033 device_param->innerloop_pos = 0;
17034 device_param->innerloop_left = 0;
17035
17036 // some more resets:
17037
17038 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17039
17040 device_param->pws_cnt = 0;
17041
17042 device_param->words_off = 0;
17043 device_param->words_done = 0;
17044 }
17045
17046 data.kernel_power_div = 0;
17047
17048 // figure out some workload
17049
17050 if (attack_mode == ATTACK_MODE_STRAIGHT)
17051 {
17052 if (data.wordlist_mode == WL_MODE_FILE)
17053 {
17054 char *dictfile = NULL;
17055
17056 if (induction_dictionaries_cnt)
17057 {
17058 dictfile = induction_dictionaries[0];
17059 }
17060 else
17061 {
17062 dictfile = dictfiles[dictpos];
17063 }
17064
17065 data.dictfile = dictfile;
17066
17067 logfile_sub_string (dictfile);
17068
17069 for (uint i = 0; i < rp_files_cnt; i++)
17070 {
17071 logfile_sub_var_string ("rulefile", rp_files[i]);
17072 }
17073
17074 FILE *fd2 = fopen (dictfile, "rb");
17075
17076 if (fd2 == NULL)
17077 {
17078 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17079
17080 return (-1);
17081 }
17082
17083 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17084
17085 fclose (fd2);
17086
17087 if (data.words_cnt == 0)
17088 {
17089 if (data.devices_status == STATUS_CRACKED) break;
17090 if (data.devices_status == STATUS_ABORTED) break;
17091
17092 dictpos++;
17093
17094 continue;
17095 }
17096 }
17097 }
17098 else if (attack_mode == ATTACK_MODE_COMBI)
17099 {
17100 char *dictfile = data.dictfile;
17101 char *dictfile2 = data.dictfile2;
17102
17103 logfile_sub_string (dictfile);
17104 logfile_sub_string (dictfile2);
17105
17106 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17107 {
17108 FILE *fd2 = fopen (dictfile, "rb");
17109
17110 if (fd2 == NULL)
17111 {
17112 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17113
17114 return (-1);
17115 }
17116
17117 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17118
17119 fclose (fd2);
17120 }
17121 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17122 {
17123 FILE *fd2 = fopen (dictfile2, "rb");
17124
17125 if (fd2 == NULL)
17126 {
17127 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17128
17129 return (-1);
17130 }
17131
17132 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17133
17134 fclose (fd2);
17135 }
17136
17137 if (data.words_cnt == 0)
17138 {
17139 if (data.devices_status == STATUS_CRACKED) break;
17140 if (data.devices_status == STATUS_ABORTED) break;
17141
17142 dictpos++;
17143
17144 continue;
17145 }
17146 }
17147 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17148 {
17149 char *dictfile = NULL;
17150
17151 if (induction_dictionaries_cnt)
17152 {
17153 dictfile = induction_dictionaries[0];
17154 }
17155 else
17156 {
17157 dictfile = dictfiles[dictpos];
17158 }
17159
17160 data.dictfile = dictfile;
17161
17162 char *mask = data.mask;
17163
17164 logfile_sub_string (dictfile);
17165 logfile_sub_string (mask);
17166
17167 FILE *fd2 = fopen (dictfile, "rb");
17168
17169 if (fd2 == NULL)
17170 {
17171 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17172
17173 return (-1);
17174 }
17175
17176 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17177
17178 fclose (fd2);
17179
17180 if (data.words_cnt == 0)
17181 {
17182 if (data.devices_status == STATUS_CRACKED) break;
17183 if (data.devices_status == STATUS_ABORTED) break;
17184
17185 dictpos++;
17186
17187 continue;
17188 }
17189 }
17190 else if (attack_mode == ATTACK_MODE_BF)
17191 {
17192 local_free (css_buf);
17193 local_free (data.root_css_buf);
17194 local_free (data.markov_css_buf);
17195
17196 char *mask = dictfiles[dictpos];
17197
17198 logfile_sub_string (mask);
17199
17200 // base
17201
17202 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17203
17204 if (opts_type & OPTS_TYPE_PT_UNICODE)
17205 {
17206 uint css_cnt_unicode = css_cnt * 2;
17207
17208 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17209
17210 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17211 {
17212 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17213
17214 css_buf_unicode[j + 1].cs_buf[0] = 0;
17215 css_buf_unicode[j + 1].cs_len = 1;
17216 }
17217
17218 free (css_buf);
17219
17220 css_buf = css_buf_unicode;
17221 css_cnt = css_cnt_unicode;
17222 }
17223
17224 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17225
17226 uint mask_min = pw_min;
17227 uint mask_max = pw_max;
17228
17229 if (opts_type & OPTS_TYPE_PT_UNICODE)
17230 {
17231 mask_min *= 2;
17232 mask_max *= 2;
17233 }
17234
17235 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17236 {
17237 if (css_cnt < mask_min)
17238 {
17239 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17240 }
17241
17242 if (css_cnt > mask_max)
17243 {
17244 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17245 }
17246
17247 // skip to next mask
17248
17249 dictpos++;
17250
17251 rd->dictpos = dictpos;
17252
17253 logfile_sub_msg ("STOP");
17254
17255 continue;
17256 }
17257
17258 uint save_css_cnt = css_cnt;
17259
17260 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17261 {
17262 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17263 {
17264 uint salt_len = (uint) data.salts_buf[0].salt_len;
17265 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17266
17267 uint css_cnt_salt = css_cnt + salt_len;
17268
17269 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17270
17271 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17272
17273 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17274 {
17275 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17276 css_buf_salt[j].cs_len = 1;
17277 }
17278
17279 free (css_buf);
17280
17281 css_buf = css_buf_salt;
17282 css_cnt = css_cnt_salt;
17283 }
17284 }
17285
17286 data.mask = mask;
17287 data.css_cnt = css_cnt;
17288 data.css_buf = css_buf;
17289
17290 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17291
17292 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17293
17294 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17295
17296 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17297 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17298
17299 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17300
17301 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17302
17303 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17304 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17305
17306 data.root_css_buf = root_css_buf;
17307 data.markov_css_buf = markov_css_buf;
17308
17309 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17310
17311 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17312
17313 local_free (root_table_buf);
17314 local_free (markov_table_buf);
17315
17316 // copy + args
17317
17318 uint css_cnt_l = css_cnt;
17319 uint css_cnt_r;
17320
17321 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17322 {
17323 if (save_css_cnt < 6)
17324 {
17325 css_cnt_r = 1;
17326 }
17327 else if (save_css_cnt == 6)
17328 {
17329 css_cnt_r = 2;
17330 }
17331 else
17332 {
17333 if (opts_type & OPTS_TYPE_PT_UNICODE)
17334 {
17335 if (save_css_cnt == 8 || save_css_cnt == 10)
17336 {
17337 css_cnt_r = 2;
17338 }
17339 else
17340 {
17341 css_cnt_r = 4;
17342 }
17343 }
17344 else
17345 {
17346 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17347 {
17348 css_cnt_r = 3;
17349 }
17350 else
17351 {
17352 css_cnt_r = 4;
17353 }
17354 }
17355 }
17356 }
17357 else
17358 {
17359 css_cnt_r = 1;
17360
17361 /* unfinished code?
17362 int sum = css_buf[css_cnt_r - 1].cs_len;
17363
17364 for (uint i = 1; i < 4 && i < css_cnt; i++)
17365 {
17366 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17367
17368 css_cnt_r++;
17369
17370 sum *= css_buf[css_cnt_r - 1].cs_len;
17371 }
17372 */
17373 }
17374
17375 css_cnt_l -= css_cnt_r;
17376
17377 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17378
17379 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17380 {
17381 hc_device_param_t *device_param = &data.devices_param[device_id];
17382
17383 if (device_param->skipped) continue;
17384
17385 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17386 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17387 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17388
17389 device_param->kernel_params_mp_l_buf64[3] = 0;
17390 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17391 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17392 device_param->kernel_params_mp_l_buf32[6] = 0;
17393 device_param->kernel_params_mp_l_buf32[7] = 0;
17394 device_param->kernel_params_mp_l_buf32[8] = 0;
17395
17396 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17397 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17398 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17399 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17400
17401 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17402 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17403 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17404
17405 device_param->kernel_params_mp_r_buf64[3] = 0;
17406 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17407 device_param->kernel_params_mp_r_buf32[5] = 0;
17408 device_param->kernel_params_mp_r_buf32[6] = 0;
17409 device_param->kernel_params_mp_r_buf32[7] = 0;
17410
17411 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]);
17412 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]);
17413 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]);
17414
17415 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]);
17416 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]);
17417 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]);
17418
17419 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);
17420 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);
17421 }
17422 }
17423
17424 u64 words_base = data.words_cnt;
17425
17426 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17427 {
17428 if (data.kernel_rules_cnt)
17429 {
17430 words_base /= data.kernel_rules_cnt;
17431 }
17432 }
17433 else if (data.attack_kern == ATTACK_KERN_COMBI)
17434 {
17435 if (data.combs_cnt)
17436 {
17437 words_base /= data.combs_cnt;
17438 }
17439 }
17440 else if (data.attack_kern == ATTACK_KERN_BF)
17441 {
17442 if (data.bfs_cnt)
17443 {
17444 words_base /= data.bfs_cnt;
17445 }
17446 }
17447
17448 data.words_base = words_base;
17449
17450 if (keyspace == 1)
17451 {
17452 log_info ("%llu", (unsigned long long int) words_base);
17453
17454 return (0);
17455 }
17456
17457 if (data.words_cur > data.words_base)
17458 {
17459 log_error ("ERROR: restore value greater keyspace");
17460
17461 return (-1);
17462 }
17463
17464 if (data.words_cur)
17465 {
17466 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17467 {
17468 for (uint i = 0; i < data.salts_cnt; i++)
17469 {
17470 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17471 }
17472 }
17473 else if (data.attack_kern == ATTACK_KERN_COMBI)
17474 {
17475 for (uint i = 0; i < data.salts_cnt; i++)
17476 {
17477 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17478 }
17479 }
17480 else if (data.attack_kern == ATTACK_KERN_BF)
17481 {
17482 for (uint i = 0; i < data.salts_cnt; i++)
17483 {
17484 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17485 }
17486 }
17487 }
17488
17489 /*
17490 * Inform user about possible slow speeds
17491 */
17492
17493 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17494 {
17495 if (data.words_base < kernel_power_all)
17496 {
17497 if (quiet == 0)
17498 {
17499 log_info ("ATTENTION!");
17500 log_info (" The wordlist or mask you are using is too small.");
17501 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17502 log_info (" The cracking speed will drop.");
17503 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17504 log_info ("");
17505 }
17506 }
17507 }
17508
17509 /*
17510 * Update loopback file
17511 */
17512
17513 if (loopback == 1)
17514 {
17515 time_t now;
17516
17517 time (&now);
17518
17519 uint random_num = get_random_num (0, 9999);
17520
17521 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17522
17523 data.loopback_file = loopback_file;
17524 }
17525
17526 /*
17527 * Update dictionary statistic
17528 */
17529
17530 if (keyspace == 0)
17531 {
17532 dictstat_fp = fopen (dictstat, "wb");
17533
17534 if (dictstat_fp)
17535 {
17536 lock_file (dictstat_fp);
17537
17538 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17539
17540 fclose (dictstat_fp);
17541 }
17542 }
17543
17544 data.devices_status = STATUS_RUNNING;
17545
17546 if (initial_restore_done == 0)
17547 {
17548 if (data.restore_disable == 0) cycle_restore ();
17549
17550 initial_restore_done = 1;
17551 }
17552
17553 hc_timer_set (&data.timer_running);
17554
17555 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17556 {
17557 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17558 {
17559 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17560 if (quiet == 0) fflush (stdout);
17561 }
17562 }
17563 else if (wordlist_mode == WL_MODE_STDIN)
17564 {
17565 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17566 if (data.quiet == 0) log_info ("");
17567 }
17568
17569 time_t runtime_start;
17570
17571 time (&runtime_start);
17572
17573 data.runtime_start = runtime_start;
17574
17575 /**
17576 * create cracker threads
17577 */
17578
17579 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17580
17581 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17582 {
17583 hc_device_param_t *device_param = &devices_param[device_id];
17584
17585 if (wordlist_mode == WL_MODE_STDIN)
17586 {
17587 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17588 }
17589 else
17590 {
17591 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17592 }
17593 }
17594
17595 // wait for crack threads to exit
17596
17597 hc_thread_wait (data.devices_cnt, c_threads);
17598
17599 local_free (c_threads);
17600
17601 data.restore = 0;
17602
17603 // finalize task
17604
17605 logfile_sub_var_uint ("status-after-work", data.devices_status);
17606
17607 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17608
17609 if (data.devices_status == STATUS_CRACKED) break;
17610 if (data.devices_status == STATUS_ABORTED) break;
17611
17612 if (data.devices_status == STATUS_BYPASS)
17613 {
17614 data.devices_status = STATUS_RUNNING;
17615 }
17616
17617 if (induction_dictionaries_cnt)
17618 {
17619 unlink (induction_dictionaries[0]);
17620 }
17621
17622 free (induction_dictionaries);
17623
17624 if (attack_mode != ATTACK_MODE_BF)
17625 {
17626 induction_dictionaries = scan_directory (induction_directory);
17627
17628 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17629 }
17630
17631 if (benchmark == 0)
17632 {
17633 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17634 {
17635 if (quiet == 0) clear_prompt ();
17636
17637 if (quiet == 0) log_info ("");
17638
17639 if (status == 1)
17640 {
17641 status_display ();
17642 }
17643 else
17644 {
17645 if (quiet == 0) status_display ();
17646 }
17647
17648 if (quiet == 0) log_info ("");
17649 }
17650 }
17651
17652 if (attack_mode == ATTACK_MODE_BF)
17653 {
17654 dictpos++;
17655
17656 rd->dictpos = dictpos;
17657 }
17658 else
17659 {
17660 if (induction_dictionaries_cnt)
17661 {
17662 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17663 }
17664 else
17665 {
17666 dictpos++;
17667
17668 rd->dictpos = dictpos;
17669 }
17670 }
17671
17672 time_t runtime_stop;
17673
17674 time (&runtime_stop);
17675
17676 data.runtime_stop = runtime_stop;
17677
17678 logfile_sub_uint (runtime_start);
17679 logfile_sub_uint (runtime_stop);
17680
17681 logfile_sub_msg ("STOP");
17682
17683 global_free (subid);
17684 }
17685
17686 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17687
17688 if (data.devices_status == STATUS_CRACKED) break;
17689 if (data.devices_status == STATUS_ABORTED) break;
17690 if (data.devices_status == STATUS_QUIT) break;
17691
17692 if (data.devices_status == STATUS_BYPASS)
17693 {
17694 data.devices_status = STATUS_RUNNING;
17695 }
17696 }
17697
17698 // 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
17699
17700 if (attack_mode == ATTACK_MODE_STRAIGHT)
17701 {
17702 if (data.wordlist_mode == WL_MODE_FILE)
17703 {
17704 if (data.dictfile == NULL)
17705 {
17706 if (dictfiles != NULL)
17707 {
17708 data.dictfile = dictfiles[0];
17709
17710 hc_timer_set (&data.timer_running);
17711 }
17712 }
17713 }
17714 }
17715 // NOTE: combi is okay because it is already set beforehand
17716 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17717 {
17718 if (data.dictfile == NULL)
17719 {
17720 if (dictfiles != NULL)
17721 {
17722 hc_timer_set (&data.timer_running);
17723
17724 data.dictfile = dictfiles[0];
17725 }
17726 }
17727 }
17728 else if (attack_mode == ATTACK_MODE_BF)
17729 {
17730 if (data.mask == NULL)
17731 {
17732 hc_timer_set (&data.timer_running);
17733
17734 data.mask = masks[0];
17735 }
17736 }
17737
17738 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17739 {
17740 data.devices_status = STATUS_EXHAUSTED;
17741 }
17742
17743 // if cracked / aborted remove last induction dictionary
17744
17745 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17746 {
17747 struct stat induct_stat;
17748
17749 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17750 {
17751 unlink (induction_dictionaries[file_pos]);
17752 }
17753 }
17754
17755 // wait for non-interactive threads
17756
17757 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17758 {
17759 hc_thread_wait (1, &ni_threads[thread_idx]);
17760 }
17761
17762 local_free (ni_threads);
17763
17764 // wait for interactive threads
17765
17766 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17767 {
17768 hc_thread_wait (1, &i_thread);
17769 }
17770
17771 // we dont need restore file anymore
17772 if (data.restore_disable == 0)
17773 {
17774 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17775 {
17776 unlink (eff_restore_file);
17777 unlink (new_restore_file);
17778 }
17779 else
17780 {
17781 cycle_restore ();
17782 }
17783 }
17784
17785 // finally save left hashes
17786
17787 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17788 {
17789 save_hash ();
17790 }
17791
17792 /**
17793 * Clean up
17794 */
17795
17796 if (benchmark == 1)
17797 {
17798 status_benchmark ();
17799
17800 if (machine_readable == 0)
17801 {
17802 log_info ("");
17803 }
17804 }
17805 else
17806 {
17807 if (quiet == 0) clear_prompt ();
17808
17809 if (quiet == 0) log_info ("");
17810
17811 if (status == 1)
17812 {
17813 status_display ();
17814 }
17815 else
17816 {
17817 if (quiet == 0) status_display ();
17818 }
17819
17820 if (quiet == 0) log_info ("");
17821 }
17822
17823 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17824 {
17825 hc_device_param_t *device_param = &data.devices_param[device_id];
17826
17827 if (device_param->skipped) continue;
17828
17829 local_free (device_param->combs_buf);
17830
17831 local_free (device_param->hooks_buf);
17832
17833 local_free (device_param->device_name);
17834
17835 local_free (device_param->device_name_chksum);
17836
17837 local_free (device_param->device_version);
17838
17839 local_free (device_param->driver_version);
17840
17841 if (device_param->pws_buf) myfree (device_param->pws_buf);
17842 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17843 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17844 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17845 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17846 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17847 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17848 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17849 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17850 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17851 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17852 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17853 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17854 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17855 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17856 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17857 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17858 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17859 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17860 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17861 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17862 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17863 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17864 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17865 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17866 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17867 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17868 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17869 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17870
17871 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17872 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17873 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17874 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17875 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17876 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17877 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17878 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17879 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17880 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17881 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17882
17883 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17884 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17885 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17886
17887 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17888 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17889 }
17890
17891 // reset default fan speed
17892
17893 #ifdef HAVE_HWMON
17894 if (gpu_temp_disable == 0)
17895 {
17896 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17897 {
17898 hc_thread_mutex_lock (mux_adl);
17899
17900 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17901 {
17902 hc_device_param_t *device_param = &data.devices_param[device_id];
17903
17904 if (device_param->skipped) continue;
17905
17906 if (data.hm_device[device_id].fan_set_supported == 1)
17907 {
17908 int fanspeed = temp_retain_fanspeed_value[device_id];
17909 int fanpolicy = temp_retain_fanpolicy_value[device_id];
17910
17911 if (fanpolicy == 1)
17912 {
17913 int rc = -1;
17914
17915 if (device_param->device_vendor_id == VENDOR_ID_AMD)
17916 {
17917 rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed, 0);
17918 }
17919 else if (device_param->device_vendor_id == VENDOR_ID_NV)
17920 {
17921 #ifdef _WIN
17922 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 16);
17923 #endif
17924 }
17925
17926 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
17927 }
17928 }
17929 }
17930
17931 hc_thread_mutex_unlock (mux_adl);
17932 }
17933 }
17934
17935 // reset power tuning
17936
17937 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17938 {
17939 hc_thread_mutex_lock (mux_adl);
17940
17941 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17942 {
17943 hc_device_param_t *device_param = &data.devices_param[device_id];
17944
17945 if (device_param->skipped) continue;
17946
17947 if (data.hm_device[device_id].od_version == 6)
17948 {
17949 // check powertune capabilities first, if not available then skip device
17950
17951 int powertune_supported = 0;
17952
17953 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17954 {
17955 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17956
17957 return (-1);
17958 }
17959
17960 if (powertune_supported != 0)
17961 {
17962 // powercontrol settings
17963
17964 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)
17965 {
17966 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17967
17968 return (-1);
17969 }
17970
17971 // clocks
17972
17973 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17974
17975 performance_state->iNumberOfPerformanceLevels = 2;
17976
17977 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17978 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17979 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17980 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17981
17982 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)
17983 {
17984 log_info ("ERROR: Failed to restore ADL performance state");
17985
17986 return (-1);
17987 }
17988
17989 local_free (performance_state);
17990 }
17991 }
17992 }
17993
17994 hc_thread_mutex_unlock (mux_adl);
17995 }
17996
17997 if (gpu_temp_disable == 0)
17998 {
17999 if (data.hm_nv)
18000 {
18001 #if defined(LINUX)
18002
18003 hm_NVML_nvmlShutdown (data.hm_nv);
18004
18005 nvml_close (data.hm_nv);
18006
18007 #elif defined(WIN)
18008
18009 hm_NvAPI_Unload (data.hm_nv);
18010
18011 nvapi_close (data.hm_nv);
18012
18013 #endif
18014
18015 data.hm_nv = NULL;
18016 }
18017
18018 if (data.hm_amd)
18019 {
18020 hm_ADL_Main_Control_Destroy (data.hm_amd);
18021
18022 adl_close (data.hm_amd);
18023
18024 data.hm_amd = NULL;
18025 }
18026 }
18027 #endif // HAVE_HWMON
18028
18029 // free memory
18030
18031 local_free (masks);
18032
18033 local_free (dictstat_base);
18034
18035 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18036 {
18037 pot_t *pot_ptr = &pot[pot_pos];
18038
18039 hash_t *hash = &pot_ptr->hash;
18040
18041 local_free (hash->digest);
18042
18043 if (isSalted)
18044 {
18045 local_free (hash->salt);
18046 }
18047 }
18048
18049 local_free (pot);
18050
18051 local_free (all_kernel_rules_cnt);
18052 local_free (all_kernel_rules_buf);
18053
18054 local_free (wl_data->buf);
18055 local_free (wl_data);
18056
18057 local_free (bitmap_s1_a);
18058 local_free (bitmap_s1_b);
18059 local_free (bitmap_s1_c);
18060 local_free (bitmap_s1_d);
18061 local_free (bitmap_s2_a);
18062 local_free (bitmap_s2_b);
18063 local_free (bitmap_s2_c);
18064 local_free (bitmap_s2_d);
18065
18066 #ifdef HAVE_HWMON
18067 local_free (temp_retain_fanspeed_value);
18068 local_free (od_clock_mem_status);
18069 local_free (od_power_control_status);
18070 #endif
18071
18072 global_free (devices_param);
18073
18074 global_free (kernel_rules_buf);
18075
18076 global_free (root_css_buf);
18077 global_free (markov_css_buf);
18078
18079 global_free (digests_buf);
18080 global_free (digests_shown);
18081 global_free (digests_shown_tmp);
18082
18083 global_free (salts_buf);
18084 global_free (salts_shown);
18085
18086 global_free (esalts_buf);
18087
18088 global_free (words_progress_done);
18089 global_free (words_progress_rejected);
18090 global_free (words_progress_restored);
18091
18092 if (pot_fp) fclose (pot_fp);
18093
18094 if (data.devices_status == STATUS_QUIT) break;
18095 }
18096
18097 // destroy others mutex
18098
18099 hc_thread_mutex_delete (mux_dispatcher);
18100 hc_thread_mutex_delete (mux_counter);
18101 hc_thread_mutex_delete (mux_display);
18102 hc_thread_mutex_delete (mux_adl);
18103
18104 // free memory
18105
18106 local_free (eff_restore_file);
18107 local_free (new_restore_file);
18108
18109 local_free (rd);
18110
18111 // tuning db
18112
18113 tuning_db_destroy (tuning_db);
18114
18115 // loopback
18116
18117 local_free (loopback_file);
18118
18119 if (loopback == 1) unlink (loopback_file);
18120
18121 // induction directory
18122
18123 if (induction_dir == NULL)
18124 {
18125 if (attack_mode != ATTACK_MODE_BF)
18126 {
18127 if (rmdir (induction_directory) == -1)
18128 {
18129 if (errno == ENOENT)
18130 {
18131 // good, we can ignore
18132 }
18133 else if (errno == ENOTEMPTY)
18134 {
18135 // good, we can ignore
18136 }
18137 else
18138 {
18139 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18140
18141 return (-1);
18142 }
18143 }
18144
18145 local_free (induction_directory);
18146 }
18147 }
18148
18149 // outfile-check directory
18150
18151 if (outfile_check_dir == NULL)
18152 {
18153 if (rmdir (outfile_check_directory) == -1)
18154 {
18155 if (errno == ENOENT)
18156 {
18157 // good, we can ignore
18158 }
18159 else if (errno == ENOTEMPTY)
18160 {
18161 // good, we can ignore
18162 }
18163 else
18164 {
18165 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18166
18167 return (-1);
18168 }
18169 }
18170
18171 local_free (outfile_check_directory);
18172 }
18173
18174 time_t proc_stop;
18175
18176 time (&proc_stop);
18177
18178 logfile_top_uint (proc_start);
18179 logfile_top_uint (proc_stop);
18180
18181 logfile_top_msg ("STOP");
18182
18183 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18184 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18185
18186 if (data.ocl) ocl_close (data.ocl);
18187
18188 if (data.devices_status == STATUS_ABORTED) return 2;
18189 if (data.devices_status == STATUS_QUIT) return 2;
18190 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18191 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18192 if (data.devices_status == STATUS_CRACKED) return 0;
18193
18194 return -1;
18195 }
Hashcat additions to support pwdhash