projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Only show Hardware-Monitor information we have, do not show N/A any longer
[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 70
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 #ifdef HAVE_ADL
415 " --powertune-enable | | Enable automatic power tuning (AMD OverDrive 6 only) |",
416 #endif
417 #endif
418 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
419 " -s, --skip | Num | Skip X words from the start | -s 1000000",
420 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
421 " --keyspace | | Show keyspace base:mod values and quit |",
422 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
423 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
424 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
425 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
426 " --generate-rules-func-min | Num | Force min X funcs per rule |",
427 " --generate-rules-func-max | Num | Force max X funcs per rule |",
428 " --generate-rules-seed | Num | Force RNG seed set to X |",
429 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
430 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
431 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
432 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
433 " -i, --increment | | Enable mask increment mode |",
434 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
435 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
436 "",
437 "- [ Hash modes ] -",
438 "",
439 " # | Name | Category",
440 " ======+==================================================+======================================",
441 " 900 | MD4 | Raw Hash",
442 " 0 | MD5 | Raw Hash",
443 " 5100 | Half MD5 | Raw Hash",
444 " 100 | SHA1 | Raw Hash",
445 " 10800 | SHA-384 | Raw Hash",
446 " 1400 | SHA-256 | Raw Hash",
447 " 1700 | SHA-512 | Raw Hash",
448 " 5000 | SHA-3(Keccak) | Raw Hash",
449 " 10100 | SipHash | Raw Hash",
450 " 6000 | RipeMD160 | Raw Hash",
451 " 6100 | Whirlpool | Raw Hash",
452 " 6900 | GOST R 34.11-94 | Raw Hash",
453 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
454 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
455 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
456 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
457 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
458 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
459 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
460 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
461 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
462 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
463 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
464 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
465 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
466 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
467 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
468 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
469 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
470 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
471 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
472 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
473 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
474 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
475 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
476 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
477 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
478 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
479 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
480 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
481 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
482 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
483 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
484 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
485 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
486 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
487 " 400 | phpass | Generic KDF",
488 " 8900 | scrypt | Generic KDF",
489 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
490 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
491 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
492 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
493 " 23 | Skype | Network protocols",
494 " 2500 | WPA/WPA2 | Network protocols",
495 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
496 " 5300 | IKE-PSK MD5 | Network protocols",
497 " 5400 | IKE-PSK SHA1 | Network protocols",
498 " 5500 | NetNTLMv1 | Network protocols",
499 " 5500 | NetNTLMv1 + ESS | Network protocols",
500 " 5600 | NetNTLMv2 | Network protocols",
501 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
502 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
503 " 8300 | DNSSEC (NSEC3) | Network protocols",
504 " 10200 | Cram MD5 | Network protocols",
505 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
506 " 11200 | MySQL CRAM (SHA1) | Network protocols",
507 " 11400 | SIP digest authentication (MD5) | Network protocols",
508 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
509 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
510 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
511 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
512 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
513 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
514 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
515 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
516 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
517 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
518 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
519 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
520 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
521 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
522 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
523 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
524 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
525 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
526 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
527 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
528 " 12 | PostgreSQL | Database Server",
529 " 131 | MSSQL(2000) | Database Server",
530 " 132 | MSSQL(2005) | Database Server",
531 " 1731 | MSSQL(2012) | Database Server",
532 " 1731 | MSSQL(2014) | Database Server",
533 " 200 | MySQL323 | Database Server",
534 " 300 | MySQL4.1/MySQL5 | Database Server",
535 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
536 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
537 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
538 " 8000 | Sybase ASE | Database Server",
539 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
540 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
541 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
542 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
543 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
544 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
545 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
546 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
547 " 11500 | CRC32 | Checksums",
548 " 3000 | LM | Operating-Systems",
549 " 1000 | NTLM | Operating-Systems",
550 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
551 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
552 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
553 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
554 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
555 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
556 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
557 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
558 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
559 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
560 " 1722 | OSX v10.7 | Operating-Systems",
561 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
562 " 6300 | AIX {smd5} | Operating-Systems",
563 " 6700 | AIX {ssha1} | Operating-Systems",
564 " 6400 | AIX {ssha256} | Operating-Systems",
565 " 6500 | AIX {ssha512} | Operating-Systems",
566 " 2400 | Cisco-PIX | Operating-Systems",
567 " 2410 | Cisco-ASA | Operating-Systems",
568 " 500 | Cisco-IOS $1$ | Operating-Systems",
569 " 5700 | Cisco-IOS $4$ | Operating-Systems",
570 " 9200 | Cisco-IOS $8$ | Operating-Systems",
571 " 9300 | Cisco-IOS $9$ | Operating-Systems",
572 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
573 " 501 | Juniper IVE | Operating-Systems",
574 " 5800 | Android PIN | Operating-Systems",
575 " 8100 | Citrix Netscaler | Operating-Systems",
576 " 8500 | RACF | Operating-Systems",
577 " 7200 | GRUB 2 | Operating-Systems",
578 " 9900 | Radmin2 | Operating-Systems",
579 " 125 | ArubaOS | Operating-Systems",
580 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
581 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
582 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
583 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
584 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
585 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
586 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
587 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
588 " 11600 | 7-Zip | Archives",
589 " 12500 | RAR3-hp | Archives",
590 " 13000 | RAR5 | Archives",
591 " 13200 | AxCrypt | Archives",
592 " 13300 | AxCrypt in memory SHA1 | Archives",
593 " 13600 | WinZip | Archives",
594 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
595 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
596 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
597 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
598 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
599 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
600 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
601 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
602 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
603 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
604 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
605 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
606 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
607 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
608 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
609 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
610 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
611 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
612 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
613 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
614 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
615 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
616 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
617 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
618 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
619 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
620 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
621 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
622 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
623 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
624 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
625 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
626 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
627 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
628 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
629 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
630 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
631 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
632 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
633 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
634 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
635 " 9400 | MS Office 2007 | Documents",
636 " 9500 | MS Office 2010 | Documents",
637 " 9600 | MS Office 2013 | Documents",
638 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
639 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
640 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
641 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
642 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
643 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
644 " 9000 | Password Safe v2 | Password Managers",
645 " 5200 | Password Safe v3 | Password Managers",
646 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
647 " 6600 | 1Password, agilekeychain | Password Managers",
648 " 8200 | 1Password, cloudkeychain | Password Managers",
649 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
650 " 12700 | Blockchain, My Wallet | Password Managers",
651 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
652 "",
653 "- [ Outfile Formats ] -",
654 "",
655 " # | Format",
656 " ===+========",
657 " 1 | hash[:salt]",
658 " 2 | plain",
659 " 3 | hash[:salt]:plain",
660 " 4 | hex_plain",
661 " 5 | hash[:salt]:hex_plain",
662 " 6 | plain:hex_plain",
663 " 7 | hash[:salt]:plain:hex_plain",
664 " 8 | crackpos",
665 " 9 | hash[:salt]:crack_pos",
666 " 10 | plain:crack_pos",
667 " 11 | hash[:salt]:plain:crack_pos",
668 " 12 | hex_plain:crack_pos",
669 " 13 | hash[:salt]:hex_plain:crack_pos",
670 " 14 | plain:hex_plain:crack_pos",
671 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
672 "",
673 "- [ Rule Debugging Modes ] -",
674 "",
675 " # | Format",
676 " ===+========",
677 " 1 | Finding-Rule",
678 " 2 | Original-Word",
679 " 3 | Original-Word:Finding-Rule",
680 " 4 | Original-Word:Finding-Rule:Processed-Word",
681 "",
682 "- [ Attack Modes ] -",
683 "",
684 " # | Mode",
685 " ===+======",
686 " 0 | Straight",
687 " 1 | Combination",
688 " 3 | Brute-force",
689 " 6 | Hybrid Wordlist + Mask",
690 " 7 | Hybrid Mask + Wordlist",
691 "",
692 "- [ Built-in Charsets ] -",
693 "",
694 " ? | Charset",
695 " ===+=========",
696 " l | abcdefghijklmnopqrstuvwxyz",
697 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
698 " d | 0123456789",
699 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
700 " a | ?l?u?d?s",
701 " b | 0x00 - 0xff",
702 "",
703 "- [ OpenCL Device Types ] -",
704 "",
705 " # | Device Type",
706 " ===+=============",
707 " 1 | CPU",
708 " 2 | GPU",
709 " 3 | FPGA, DSP, Co-Processor",
710 "",
711 "- [ Workload Profiles ] -",
712 "",
713 " # | Performance | Runtime | Power Consumption | Desktop Impact",
714 " ===+=============+=========+===================+=================",
715 " 1 | Low | 2 ms | Low | Minimal",
716 " 2 | Default | 12 ms | Economic | Noticeable",
717 " 3 | High | 96 ms | High | Unresponsive",
718 " 4 | Nightmare | 480 ms | Insane | Headless",
719 "",
720 "If you have no idea what just happened then visit the following pages:",
721 "",
722 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
723 "* https://hashcat.net/wiki/#frequently_asked_questions",
724 "",
725 NULL
726 };
727
728 /**
729 * hashcat specific functions
730 */
731
732 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
733 {
734 int exec_pos = (int) device_param->exec_pos - last_num_entries;
735
736 if (exec_pos < 0) exec_pos += EXEC_CACHE;
737
738 double exec_ms_sum = 0;
739
740 int exec_ms_cnt = 0;
741
742 for (int i = 0; i < last_num_entries; i++)
743 {
744 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
745
746 if (exec_ms)
747 {
748 exec_ms_sum += exec_ms;
749
750 exec_ms_cnt++;
751 }
752 }
753
754 if (exec_ms_cnt == 0) return 0;
755
756 return exec_ms_sum / exec_ms_cnt;
757 }
758
759 void status_display_machine_readable ()
760 {
761 FILE *out = stdout;
762
763 fprintf (out, "STATUS\t%u\t", data.devices_status);
764
765 /**
766 * speed new
767 */
768
769 fprintf (out, "SPEED\t");
770
771 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
772 {
773 hc_device_param_t *device_param = &data.devices_param[device_id];
774
775 if (device_param->skipped) continue;
776
777 u64 speed_cnt = 0;
778 double speed_ms = 0;
779
780 for (int i = 0; i < SPEED_CACHE; i++)
781 {
782 speed_cnt += device_param->speed_cnt[i];
783 speed_ms += device_param->speed_ms[i];
784 }
785
786 speed_cnt /= SPEED_CACHE;
787 speed_ms /= SPEED_CACHE;
788
789 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
790 }
791
792 /**
793 * exec time
794 */
795
796 fprintf (out, "EXEC_RUNTIME\t");
797
798 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
799 {
800 hc_device_param_t *device_param = &data.devices_param[device_id];
801
802 if (device_param->skipped) continue;
803
804 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
805
806 fprintf (out, "%f\t", exec_ms_avg);
807 }
808
809 /**
810 * words_cur
811 */
812
813 u64 words_cur = get_lowest_words_done ();
814
815 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
816
817 /**
818 * counter
819 */
820
821 u64 progress_total = data.words_cnt * data.salts_cnt;
822
823 u64 all_done = 0;
824 u64 all_rejected = 0;
825 u64 all_restored = 0;
826
827 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
828 {
829 all_done += data.words_progress_done[salt_pos];
830 all_rejected += data.words_progress_rejected[salt_pos];
831 all_restored += data.words_progress_restored[salt_pos];
832 }
833
834 u64 progress_cur = all_restored + all_done + all_rejected;
835 u64 progress_end = progress_total;
836
837 u64 progress_skip = 0;
838
839 if (data.skip)
840 {
841 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
842
843 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
844 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
845 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
846 }
847
848 if (data.limit)
849 {
850 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
851
852 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
853 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
854 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
855 }
856
857 u64 progress_cur_relative_skip = progress_cur - progress_skip;
858 u64 progress_end_relative_skip = progress_end - progress_skip;
859
860 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
861
862 /**
863 * cracks
864 */
865
866 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
867 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
868
869 /**
870 * temperature
871 */
872
873 #ifdef HAVE_HWMON
874 if (data.gpu_temp_disable == 0)
875 {
876 fprintf (out, "TEMP\t");
877
878 hc_thread_mutex_lock (mux_adl);
879
880 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
881 {
882 hc_device_param_t *device_param = &data.devices_param[device_id];
883
884 if (device_param->skipped) continue;
885
886 int temp = hm_get_temperature_with_device_id (device_id);
887
888 fprintf (out, "%d\t", temp);
889 }
890
891 hc_thread_mutex_unlock (mux_adl);
892 }
893 #endif // HAVE_HWMON
894
895 /**
896 * flush
897 */
898
899 #ifdef _WIN
900 fputc ('\r', out);
901 fputc ('\n', out);
902 #endif
903
904 #ifdef _POSIX
905 fputc ('\n', out);
906 #endif
907
908 fflush (out);
909 }
910
911 void status_display ()
912 {
913 if (data.devices_status == STATUS_INIT) return;
914 if (data.devices_status == STATUS_STARTING) return;
915 if (data.devices_status == STATUS_BYPASS) return;
916
917 if (data.machine_readable == 1)
918 {
919 status_display_machine_readable ();
920
921 return;
922 }
923
924 char tmp_buf[1000] = { 0 };
925
926 uint tmp_len = 0;
927
928 log_info ("Session.Name...: %s", data.session);
929
930 char *status_type = strstatus (data.devices_status);
931
932 uint hash_mode = data.hash_mode;
933
934 char *hash_type = strhashtype (hash_mode); // not a bug
935
936 log_info ("Status.........: %s", status_type);
937
938 /**
939 * show rules
940 */
941
942 if (data.rp_files_cnt)
943 {
944 uint i;
945
946 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
947 {
948 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
949 }
950
951 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
952
953 log_info ("Rules.Type.....: %s", tmp_buf);
954
955 tmp_len = 0;
956 }
957
958 if (data.rp_gen)
959 {
960 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
961
962 if (data.rp_gen_seed)
963 {
964 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
965 }
966 }
967
968 /**
969 * show input
970 */
971
972 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
973 {
974 if (data.wordlist_mode == WL_MODE_FILE)
975 {
976 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
977 }
978 else if (data.wordlist_mode == WL_MODE_STDIN)
979 {
980 log_info ("Input.Mode.....: Pipe");
981 }
982 }
983 else if (data.attack_mode == ATTACK_MODE_COMBI)
984 {
985 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
986 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
987 }
988 else if (data.attack_mode == ATTACK_MODE_BF)
989 {
990 char *mask = data.mask;
991
992 if (mask != NULL)
993 {
994 uint mask_len = data.css_cnt;
995
996 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
997
998 if (mask_len > 0)
999 {
1000 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1001 {
1002 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1003 {
1004 mask_len -= data.salts_buf[0].salt_len;
1005 }
1006 }
1007
1008 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1009
1010 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1011 }
1012
1013 if (data.maskcnt > 1)
1014 {
1015 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1016
1017 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1018 }
1019
1020 log_info ("Input.Mode.....: %s", tmp_buf);
1021 }
1022
1023 tmp_len = 0;
1024 }
1025 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1026 {
1027 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1028 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1029 }
1030 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1031 {
1032 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1033 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1034 }
1035
1036 if (data.digests_cnt == 1)
1037 {
1038 if (data.hash_mode == 2500)
1039 {
1040 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1041
1042 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1043 (char *) data.salts_buf[0].salt_buf,
1044 wpa->orig_mac1[0],
1045 wpa->orig_mac1[1],
1046 wpa->orig_mac1[2],
1047 wpa->orig_mac1[3],
1048 wpa->orig_mac1[4],
1049 wpa->orig_mac1[5],
1050 wpa->orig_mac2[0],
1051 wpa->orig_mac2[1],
1052 wpa->orig_mac2[2],
1053 wpa->orig_mac2[3],
1054 wpa->orig_mac2[4],
1055 wpa->orig_mac2[5]);
1056 }
1057 else if (data.hash_mode == 5200)
1058 {
1059 log_info ("Hash.Target....: File (%s)", data.hashfile);
1060 }
1061 else if (data.hash_mode == 9000)
1062 {
1063 log_info ("Hash.Target....: File (%s)", data.hashfile);
1064 }
1065 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1066 {
1067 log_info ("Hash.Target....: File (%s)", data.hashfile);
1068 }
1069 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1070 {
1071 log_info ("Hash.Target....: File (%s)", data.hashfile);
1072 }
1073 else
1074 {
1075 char out_buf[HCBUFSIZ] = { 0 };
1076
1077 ascii_digest (out_buf, 0, 0);
1078
1079 // limit length
1080 if (strlen (out_buf) > 40)
1081 {
1082 out_buf[41] = '.';
1083 out_buf[42] = '.';
1084 out_buf[43] = '.';
1085 out_buf[44] = 0;
1086 }
1087
1088 log_info ("Hash.Target....: %s", out_buf);
1089 }
1090 }
1091 else
1092 {
1093 if (data.hash_mode == 3000)
1094 {
1095 char out_buf1[32] = { 0 };
1096 char out_buf2[32] = { 0 };
1097
1098 ascii_digest (out_buf1, 0, 0);
1099 ascii_digest (out_buf2, 0, 1);
1100
1101 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1102 }
1103 else
1104 {
1105 log_info ("Hash.Target....: File (%s)", data.hashfile);
1106 }
1107 }
1108
1109 log_info ("Hash.Type......: %s", hash_type);
1110
1111 /**
1112 * speed new
1113 */
1114
1115 u64 speed_cnt[DEVICES_MAX] = { 0 };
1116 double speed_ms[DEVICES_MAX] = { 0 };
1117
1118 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1119 {
1120 hc_device_param_t *device_param = &data.devices_param[device_id];
1121
1122 if (device_param->skipped) continue;
1123
1124 speed_cnt[device_id] = 0;
1125 speed_ms[device_id] = 0;
1126
1127 for (int i = 0; i < SPEED_CACHE; i++)
1128 {
1129 speed_cnt[device_id] += device_param->speed_cnt[i];
1130 speed_ms[device_id] += device_param->speed_ms[i];
1131 }
1132
1133 speed_cnt[device_id] /= SPEED_CACHE;
1134 speed_ms[device_id] /= SPEED_CACHE;
1135 }
1136
1137 double hashes_all_ms = 0;
1138
1139 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1140
1141 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1142 {
1143 hc_device_param_t *device_param = &data.devices_param[device_id];
1144
1145 if (device_param->skipped) continue;
1146
1147 hashes_dev_ms[device_id] = 0;
1148
1149 if (speed_ms[device_id])
1150 {
1151 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1152
1153 hashes_all_ms += hashes_dev_ms[device_id];
1154 }
1155 }
1156
1157 /**
1158 * exec time
1159 */
1160
1161 double exec_all_ms[DEVICES_MAX] = { 0 };
1162
1163 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1164 {
1165 hc_device_param_t *device_param = &data.devices_param[device_id];
1166
1167 if (device_param->skipped) continue;
1168
1169 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1170
1171 exec_all_ms[device_id] = exec_ms_avg;
1172 }
1173
1174 /**
1175 * timers
1176 */
1177
1178 double ms_running = 0;
1179
1180 hc_timer_get (data.timer_running, ms_running);
1181
1182 double ms_paused = data.ms_paused;
1183
1184 if (data.devices_status == STATUS_PAUSED)
1185 {
1186 double ms_paused_tmp = 0;
1187
1188 hc_timer_get (data.timer_paused, ms_paused_tmp);
1189
1190 ms_paused += ms_paused_tmp;
1191 }
1192
1193 #ifdef WIN
1194
1195 __time64_t sec_run = ms_running / 1000;
1196
1197 #else
1198
1199 time_t sec_run = ms_running / 1000;
1200
1201 #endif
1202
1203 if (sec_run)
1204 {
1205 char display_run[32] = { 0 };
1206
1207 struct tm tm_run;
1208
1209 struct tm *tmp = NULL;
1210
1211 #ifdef WIN
1212
1213 tmp = _gmtime64 (&sec_run);
1214
1215 #else
1216
1217 tmp = gmtime (&sec_run);
1218
1219 #endif
1220
1221 if (tmp != NULL)
1222 {
1223 memset (&tm_run, 0, sizeof (tm_run));
1224
1225 memcpy (&tm_run, tmp, sizeof (tm_run));
1226
1227 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1228
1229 char *start = ctime (&data.proc_start);
1230
1231 size_t start_len = strlen (start);
1232
1233 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1234 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1235
1236 log_info ("Time.Started...: %s (%s)", start, display_run);
1237 }
1238 }
1239 else
1240 {
1241 log_info ("Time.Started...: 0 secs");
1242 }
1243
1244 /**
1245 * counters
1246 */
1247
1248 u64 progress_total = data.words_cnt * data.salts_cnt;
1249
1250 u64 all_done = 0;
1251 u64 all_rejected = 0;
1252 u64 all_restored = 0;
1253
1254 u64 progress_noneed = 0;
1255
1256 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1257 {
1258 all_done += data.words_progress_done[salt_pos];
1259 all_rejected += data.words_progress_rejected[salt_pos];
1260 all_restored += data.words_progress_restored[salt_pos];
1261
1262 // Important for ETA only
1263
1264 if (data.salts_shown[salt_pos] == 1)
1265 {
1266 const u64 all = data.words_progress_done[salt_pos]
1267 + data.words_progress_rejected[salt_pos]
1268 + data.words_progress_restored[salt_pos];
1269
1270 const u64 left = data.words_cnt - all;
1271
1272 progress_noneed += left;
1273 }
1274 }
1275
1276 u64 progress_cur = all_restored + all_done + all_rejected;
1277 u64 progress_end = progress_total;
1278
1279 u64 progress_skip = 0;
1280
1281 if (data.skip)
1282 {
1283 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1284
1285 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1286 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1287 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1288 }
1289
1290 if (data.limit)
1291 {
1292 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1293
1294 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1295 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1296 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1297 }
1298
1299 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1300 u64 progress_end_relative_skip = progress_end - progress_skip;
1301
1302 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1303 {
1304 if (data.devices_status != STATUS_CRACKED)
1305 {
1306 #ifdef WIN
1307 __time64_t sec_etc = 0;
1308 #else
1309 time_t sec_etc = 0;
1310 #endif
1311
1312 if (hashes_all_ms)
1313 {
1314 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1315
1316 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1317
1318 sec_etc = ms_left / 1000;
1319 }
1320
1321 if (sec_etc == 0)
1322 {
1323 //log_info ("Time.Estimated.: 0 secs");
1324 }
1325 else if ((u64) sec_etc > ETC_MAX)
1326 {
1327 log_info ("Time.Estimated.: > 10 Years");
1328 }
1329 else
1330 {
1331 char display_etc[32] = { 0 };
1332
1333 struct tm tm_etc;
1334
1335 struct tm *tmp = NULL;
1336
1337 #ifdef WIN
1338
1339 tmp = _gmtime64 (&sec_etc);
1340
1341 #else
1342
1343 tmp = gmtime (&sec_etc);
1344
1345 #endif
1346
1347 if (tmp != NULL)
1348 {
1349 memset (&tm_etc, 0, sizeof (tm_etc));
1350
1351 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1352
1353 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1354
1355 time_t now;
1356
1357 time (&now);
1358
1359 now += sec_etc;
1360
1361 char *etc = ctime (&now);
1362
1363 size_t etc_len = strlen (etc);
1364
1365 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1366 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1367
1368 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1369 }
1370 }
1371 }
1372 }
1373
1374 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1375 {
1376 hc_device_param_t *device_param = &data.devices_param[device_id];
1377
1378 if (device_param->skipped) continue;
1379
1380 char display_dev_cur[16] = { 0 };
1381
1382 strncpy (display_dev_cur, "0.00", 4);
1383
1384 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1385
1386 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1387 }
1388
1389 char display_all_cur[16] = { 0 };
1390
1391 strncpy (display_all_cur, "0.00", 4);
1392
1393 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1394
1395 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1396
1397 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1398 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1399
1400 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);
1401
1402 // crack-per-time
1403
1404 if (data.digests_cnt > 100)
1405 {
1406 time_t now = time (NULL);
1407
1408 int cpt_cur_min = 0;
1409 int cpt_cur_hour = 0;
1410 int cpt_cur_day = 0;
1411
1412 for (int i = 0; i < CPT_BUF; i++)
1413 {
1414 const uint cracked = data.cpt_buf[i].cracked;
1415 const time_t timestamp = data.cpt_buf[i].timestamp;
1416
1417 if ((timestamp + 60) > now)
1418 {
1419 cpt_cur_min += cracked;
1420 }
1421
1422 if ((timestamp + 3600) > now)
1423 {
1424 cpt_cur_hour += cracked;
1425 }
1426
1427 if ((timestamp + 86400) > now)
1428 {
1429 cpt_cur_day += cracked;
1430 }
1431 }
1432
1433 double ms_real = ms_running - ms_paused;
1434
1435 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1436 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1437 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1438
1439 if ((data.cpt_start + 86400) < now)
1440 {
1441 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1442 cpt_cur_min,
1443 cpt_cur_hour,
1444 cpt_cur_day,
1445 cpt_avg_min,
1446 cpt_avg_hour,
1447 cpt_avg_day);
1448 }
1449 else if ((data.cpt_start + 3600) < now)
1450 {
1451 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1452 cpt_cur_min,
1453 cpt_cur_hour,
1454 cpt_avg_min,
1455 cpt_avg_hour,
1456 cpt_avg_day);
1457 }
1458 else if ((data.cpt_start + 60) < now)
1459 {
1460 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1461 cpt_cur_min,
1462 cpt_avg_min,
1463 cpt_avg_hour,
1464 cpt_avg_day);
1465 }
1466 else
1467 {
1468 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1469 cpt_avg_min,
1470 cpt_avg_hour,
1471 cpt_avg_day);
1472 }
1473 }
1474
1475 // Restore point
1476
1477 u64 restore_point = get_lowest_words_done ();
1478
1479 u64 restore_total = data.words_base;
1480
1481 float percent_restore = 0;
1482
1483 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1484
1485 if (progress_end_relative_skip)
1486 {
1487 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1488 {
1489 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1490 float percent_rejected = 0.0;
1491
1492 if (progress_cur)
1493 {
1494 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1495 }
1496
1497 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);
1498 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1499
1500 if (data.restore_disable == 0)
1501 {
1502 if (percent_finished != 1)
1503 {
1504 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1505 }
1506 }
1507 }
1508 }
1509 else
1510 {
1511 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1512 {
1513 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1514 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1515
1516 if (data.restore_disable == 0)
1517 {
1518 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1519 }
1520 }
1521 else
1522 {
1523 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1524 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1525
1526 // --restore not allowed if stdin is used -- really? why?
1527
1528 //if (data.restore_disable == 0)
1529 //{
1530 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1531 //}
1532 }
1533 }
1534
1535 #ifdef HAVE_HWMON
1536 if (data.gpu_temp_disable == 0)
1537 {
1538 hc_thread_mutex_lock (mux_adl);
1539
1540 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1541 {
1542 hc_device_param_t *device_param = &data.devices_param[device_id];
1543
1544 if (device_param->skipped) continue;
1545
1546 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1547 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1548 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1549 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1550 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1551 const int num_buslanes = hm_get_buslanes_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:%uc", 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:%u%%", 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:%u%%", 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:%uMhz", 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:%uMhz", 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 if (output_len == 0)
1600 {
1601 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1602
1603 output_len = strlen (output_buf);
1604 }
1605
1606 log_info ("HWMon.GPU.#%d...:%s", device_id + 1, output_buf);
1607 }
1608
1609 hc_thread_mutex_unlock (mux_adl);
1610 }
1611 #endif // HAVE_HWMON
1612 }
1613
1614 static void status_benchmark_automate ()
1615 {
1616 u64 speed_cnt[DEVICES_MAX] = { 0 };
1617 double speed_ms[DEVICES_MAX] = { 0 };
1618
1619 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1620 {
1621 hc_device_param_t *device_param = &data.devices_param[device_id];
1622
1623 if (device_param->skipped) continue;
1624
1625 speed_cnt[device_id] = device_param->speed_cnt[0];
1626 speed_ms[device_id] = device_param->speed_ms[0];
1627 }
1628
1629 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1630
1631 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1632 {
1633 hc_device_param_t *device_param = &data.devices_param[device_id];
1634
1635 if (device_param->skipped) continue;
1636
1637 hashes_dev_ms[device_id] = 0;
1638
1639 if (speed_ms[device_id])
1640 {
1641 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1642 }
1643 }
1644
1645 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1646 {
1647 hc_device_param_t *device_param = &data.devices_param[device_id];
1648
1649 if (device_param->skipped) continue;
1650
1651 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1652 }
1653 }
1654
1655 static void status_benchmark ()
1656 {
1657 if (data.devices_status == STATUS_INIT) return;
1658 if (data.devices_status == STATUS_STARTING) return;
1659 if (data.devices_status == STATUS_BYPASS) return;
1660
1661 if (data.machine_readable == 1)
1662 {
1663 status_benchmark_automate ();
1664
1665 return;
1666 }
1667
1668 u64 speed_cnt[DEVICES_MAX] = { 0 };
1669 double speed_ms[DEVICES_MAX] = { 0 };
1670
1671 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1672 {
1673 hc_device_param_t *device_param = &data.devices_param[device_id];
1674
1675 if (device_param->skipped) continue;
1676
1677 speed_cnt[device_id] = device_param->speed_cnt[0];
1678 speed_ms[device_id] = device_param->speed_ms[0];
1679 }
1680
1681 double hashes_all_ms = 0;
1682
1683 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1684
1685 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1686 {
1687 hc_device_param_t *device_param = &data.devices_param[device_id];
1688
1689 if (device_param->skipped) continue;
1690
1691 hashes_dev_ms[device_id] = 0;
1692
1693 if (speed_ms[device_id])
1694 {
1695 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1696
1697 hashes_all_ms += hashes_dev_ms[device_id];
1698 }
1699 }
1700
1701 /**
1702 * exec time
1703 */
1704
1705 double exec_all_ms[DEVICES_MAX] = { 0 };
1706
1707 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1708 {
1709 hc_device_param_t *device_param = &data.devices_param[device_id];
1710
1711 if (device_param->skipped) continue;
1712
1713 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1714
1715 exec_all_ms[device_id] = exec_ms_avg;
1716 }
1717
1718 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1719 {
1720 hc_device_param_t *device_param = &data.devices_param[device_id];
1721
1722 if (device_param->skipped) continue;
1723
1724 char display_dev_cur[16] = { 0 };
1725
1726 strncpy (display_dev_cur, "0.00", 4);
1727
1728 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1729
1730 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1731 }
1732
1733 char display_all_cur[16] = { 0 };
1734
1735 strncpy (display_all_cur, "0.00", 4);
1736
1737 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1738
1739 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1740 }
1741
1742 /**
1743 * hashcat -only- functions
1744 */
1745
1746 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1747 {
1748 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1749 {
1750 if (attack_kern == ATTACK_KERN_STRAIGHT)
1751 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1752 else if (attack_kern == ATTACK_KERN_COMBI)
1753 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1754 else if (attack_kern == ATTACK_KERN_BF)
1755 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1756 }
1757 else
1758 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1759 }
1760
1761 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)
1762 {
1763 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1764 {
1765 if (attack_kern == ATTACK_KERN_STRAIGHT)
1766 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1767 else if (attack_kern == ATTACK_KERN_COMBI)
1768 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1769 else if (attack_kern == ATTACK_KERN_BF)
1770 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1771 }
1772 else
1773 {
1774 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1775 }
1776 }
1777
1778 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1779 {
1780 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1781 {
1782 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1783 }
1784 else
1785 {
1786 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1787 }
1788 }
1789
1790 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)
1791 {
1792 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1793 {
1794 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1795 }
1796 else
1797 {
1798 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1799 }
1800 }
1801
1802 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1803 {
1804 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1805 }
1806
1807 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1808 {
1809 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1810 }
1811
1812 static uint convert_from_hex (char *line_buf, const uint line_len)
1813 {
1814 if (line_len & 1) return (line_len); // not in hex
1815
1816 if (data.hex_wordlist == 1)
1817 {
1818 uint i;
1819 uint j;
1820
1821 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1822 {
1823 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1824 }
1825
1826 memset (line_buf + i, 0, line_len - i);
1827
1828 return (i);
1829 }
1830 else if (line_len >= 6) // $HEX[] = 6
1831 {
1832 if (line_buf[0] != '$') return (line_len);
1833 if (line_buf[1] != 'H') return (line_len);
1834 if (line_buf[2] != 'E') return (line_len);
1835 if (line_buf[3] != 'X') return (line_len);
1836 if (line_buf[4] != '[') return (line_len);
1837 if (line_buf[line_len - 1] != ']') return (line_len);
1838
1839 uint i;
1840 uint j;
1841
1842 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1843 {
1844 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1845 }
1846
1847 memset (line_buf + i, 0, line_len - i);
1848
1849 return (i);
1850 }
1851
1852 return (line_len);
1853 }
1854
1855 static void clear_prompt ()
1856 {
1857 fputc ('\r', stdout);
1858
1859 for (size_t i = 0; i < strlen (PROMPT); i++)
1860 {
1861 fputc (' ', stdout);
1862 }
1863
1864 fputc ('\r', stdout);
1865
1866 fflush (stdout);
1867 }
1868
1869 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1870 {
1871 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);
1872 }
1873
1874 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1875 {
1876 char *outfile = data.outfile;
1877 uint quiet = data.quiet;
1878 FILE *pot_fp = data.pot_fp;
1879 uint loopback = data.loopback;
1880 uint debug_mode = data.debug_mode;
1881 char *debug_file = data.debug_file;
1882
1883 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1884 int debug_rule_len = 0; // -1 error
1885 uint debug_plain_len = 0;
1886
1887 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1888
1889 // hash
1890
1891 char out_buf[HCBUFSIZ] = { 0 };
1892
1893 const u32 salt_pos = plain->salt_pos;
1894 const u32 digest_pos = plain->digest_pos; // relative
1895 const u32 gidvid = plain->gidvid;
1896 const u32 il_pos = plain->il_pos;
1897
1898 ascii_digest (out_buf, salt_pos, digest_pos);
1899
1900 // plain
1901
1902 u64 crackpos = device_param->words_off;
1903
1904 uint plain_buf[16] = { 0 };
1905
1906 u8 *plain_ptr = (u8 *) plain_buf;
1907
1908 unsigned int plain_len = 0;
1909
1910 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1911 {
1912 pw_t pw;
1913
1914 gidd_to_pw_t (device_param, gidvid, &pw);
1915
1916 for (int i = 0; i < 16; i++)
1917 {
1918 plain_buf[i] = pw.i[i];
1919 }
1920
1921 plain_len = pw.pw_len;
1922
1923 const uint off = device_param->innerloop_pos + il_pos;
1924
1925 if (debug_mode > 0)
1926 {
1927 debug_rule_len = 0;
1928
1929 // save rule
1930 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1931 {
1932 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1933
1934 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1935 }
1936
1937 // save plain
1938 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1939 {
1940 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1941
1942 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1943
1944 debug_plain_len = plain_len;
1945 }
1946 }
1947
1948 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1949
1950 crackpos += gidvid;
1951 crackpos *= data.kernel_rules_cnt;
1952 crackpos += device_param->innerloop_pos + il_pos;
1953
1954 if (plain_len > data.pw_max) plain_len = data.pw_max;
1955 }
1956 else if (data.attack_mode == ATTACK_MODE_COMBI)
1957 {
1958 pw_t pw;
1959
1960 gidd_to_pw_t (device_param, gidvid, &pw);
1961
1962 for (int i = 0; i < 16; i++)
1963 {
1964 plain_buf[i] = pw.i[i];
1965 }
1966
1967 plain_len = pw.pw_len;
1968
1969 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1970 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1971
1972 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1973 {
1974 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1975 }
1976 else
1977 {
1978 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1979
1980 memcpy (plain_ptr, comb_buf, comb_len);
1981 }
1982
1983 plain_len += comb_len;
1984
1985 crackpos += gidvid;
1986 crackpos *= data.combs_cnt;
1987 crackpos += device_param->innerloop_pos + il_pos;
1988
1989 if (data.pw_max != PW_DICTMAX1)
1990 {
1991 if (plain_len > data.pw_max) plain_len = data.pw_max;
1992 }
1993 }
1994 else if (data.attack_mode == ATTACK_MODE_BF)
1995 {
1996 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1997 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1998
1999 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2000 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2001
2002 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2003 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2004
2005 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2006 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2007
2008 plain_len = data.css_cnt;
2009
2010 crackpos += gidvid;
2011 crackpos *= data.bfs_cnt;
2012 crackpos += device_param->innerloop_pos + il_pos;
2013 }
2014 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2015 {
2016 pw_t pw;
2017
2018 gidd_to_pw_t (device_param, gidvid, &pw);
2019
2020 for (int i = 0; i < 16; i++)
2021 {
2022 plain_buf[i] = pw.i[i];
2023 }
2024
2025 plain_len = pw.pw_len;
2026
2027 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2028
2029 uint start = 0;
2030 uint stop = device_param->kernel_params_mp_buf32[4];
2031
2032 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2033
2034 plain_len += start + stop;
2035
2036 crackpos += gidvid;
2037 crackpos *= data.combs_cnt;
2038 crackpos += device_param->innerloop_pos + il_pos;
2039
2040 if (data.pw_max != PW_DICTMAX1)
2041 {
2042 if (plain_len > data.pw_max) plain_len = data.pw_max;
2043 }
2044 }
2045 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2046 {
2047 pw_t pw;
2048
2049 gidd_to_pw_t (device_param, gidvid, &pw);
2050
2051 for (int i = 0; i < 16; i++)
2052 {
2053 plain_buf[i] = pw.i[i];
2054 }
2055
2056 plain_len = pw.pw_len;
2057
2058 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2059
2060 uint start = 0;
2061 uint stop = device_param->kernel_params_mp_buf32[4];
2062
2063 memmove (plain_ptr + stop, plain_ptr, plain_len);
2064
2065 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2066
2067 plain_len += start + stop;
2068
2069 crackpos += gidvid;
2070 crackpos *= data.combs_cnt;
2071 crackpos += device_param->innerloop_pos + il_pos;
2072
2073 if (data.pw_max != PW_DICTMAX1)
2074 {
2075 if (plain_len > data.pw_max) plain_len = data.pw_max;
2076 }
2077 }
2078
2079 if (data.attack_mode == ATTACK_MODE_BF)
2080 {
2081 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2082 {
2083 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2084 {
2085 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2086 {
2087 plain_len = plain_len - data.salts_buf[0].salt_len;
2088 }
2089 }
2090
2091 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2092 {
2093 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2094 {
2095 plain_ptr[j] = plain_ptr[i];
2096 }
2097
2098 plain_len = plain_len / 2;
2099 }
2100 }
2101 }
2102
2103 // if enabled, update also the potfile
2104
2105 if (pot_fp)
2106 {
2107 lock_file (pot_fp);
2108
2109 fprintf (pot_fp, "%s:", out_buf);
2110
2111 format_plain (pot_fp, plain_ptr, plain_len, 1);
2112
2113 fputc ('\n', pot_fp);
2114
2115 fflush (pot_fp);
2116
2117 unlock_file (pot_fp);
2118 }
2119
2120 // outfile
2121
2122 FILE *out_fp = NULL;
2123
2124 if (outfile != NULL)
2125 {
2126 if ((out_fp = fopen (outfile, "ab")) == NULL)
2127 {
2128 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2129
2130 out_fp = stdout;
2131 }
2132
2133 lock_file (out_fp);
2134 }
2135 else
2136 {
2137 out_fp = stdout;
2138
2139 if (quiet == 0) clear_prompt ();
2140 }
2141
2142 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2143
2144 if (outfile != NULL)
2145 {
2146 if (out_fp != stdout)
2147 {
2148 fclose (out_fp);
2149 }
2150 }
2151 else
2152 {
2153 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2154 {
2155 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2156 {
2157 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2158 if (quiet == 0) fflush (stdout);
2159 }
2160 }
2161 }
2162
2163 // loopback
2164
2165 if (loopback)
2166 {
2167 char *loopback_file = data.loopback_file;
2168
2169 FILE *fb_fp = NULL;
2170
2171 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2172 {
2173 lock_file (fb_fp);
2174
2175 format_plain (fb_fp, plain_ptr, plain_len, 1);
2176
2177 fputc ('\n', fb_fp);
2178
2179 fclose (fb_fp);
2180 }
2181 }
2182
2183 // (rule) debug mode
2184
2185 // the next check implies that:
2186 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2187 // - debug_mode > 0
2188
2189 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2190 {
2191 if (debug_rule_len < 0) debug_rule_len = 0;
2192
2193 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2194
2195 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2196
2197 if ((quiet == 0) && (debug_file == NULL))
2198 {
2199 fprintf (stdout, "%s", PROMPT);
2200
2201 fflush (stdout);
2202 }
2203 }
2204 }
2205
2206 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2207 {
2208 salt_t *salt_buf = &data.salts_buf[salt_pos];
2209
2210 u32 num_cracked;
2211
2212 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2213
2214 if (num_cracked)
2215 {
2216 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2217
2218 log_info_nn ("");
2219
2220 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2221
2222 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);
2223
2224 uint cpt_cracked = 0;
2225
2226 for (uint i = 0; i < num_cracked; i++)
2227 {
2228 const uint hash_pos = cracked[i].hash_pos;
2229
2230 if (data.digests_shown[hash_pos] == 1) continue;
2231
2232 hc_thread_mutex_lock (mux_display);
2233
2234 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2235 {
2236 data.digests_shown[hash_pos] = 1;
2237
2238 data.digests_done++;
2239
2240 cpt_cracked++;
2241
2242 salt_buf->digests_done++;
2243
2244 if (salt_buf->digests_done == salt_buf->digests_cnt)
2245 {
2246 data.salts_shown[salt_pos] = 1;
2247
2248 data.salts_done++;
2249 }
2250 }
2251
2252 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2253
2254 hc_thread_mutex_unlock (mux_display);
2255
2256 check_hash (device_param, &cracked[i]);
2257 }
2258
2259 myfree (cracked);
2260
2261 if (cpt_cracked > 0)
2262 {
2263 hc_thread_mutex_lock (mux_display);
2264
2265 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2266 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2267
2268 data.cpt_pos++;
2269
2270 data.cpt_total += cpt_cracked;
2271
2272 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2273
2274 hc_thread_mutex_unlock (mux_display);
2275 }
2276
2277 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2278 {
2279 // we need to reset cracked state on the device
2280 // otherwise host thinks again and again the hash was cracked
2281 // and returns invalid password each time
2282
2283 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2284
2285 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);
2286 }
2287
2288 num_cracked = 0;
2289
2290 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2291 }
2292 }
2293
2294 static void save_hash ()
2295 {
2296 char *hashfile = data.hashfile;
2297
2298 char new_hashfile[256] = { 0 };
2299 char old_hashfile[256] = { 0 };
2300
2301 snprintf (new_hashfile, 255, "%s.new", hashfile);
2302 snprintf (old_hashfile, 255, "%s.old", hashfile);
2303
2304 unlink (new_hashfile);
2305
2306 char separator = data.separator;
2307
2308 FILE *fp = fopen (new_hashfile, "wb");
2309
2310 if (fp == NULL)
2311 {
2312 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2313
2314 exit (-1);
2315 }
2316
2317 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2318 {
2319 if (data.salts_shown[salt_pos] == 1) continue;
2320
2321 salt_t *salt_buf = &data.salts_buf[salt_pos];
2322
2323 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2324 {
2325 uint idx = salt_buf->digests_offset + digest_pos;
2326
2327 if (data.digests_shown[idx] == 1) continue;
2328
2329 if (data.hash_mode != 2500)
2330 {
2331 char out_buf[HCBUFSIZ] = { 0 };
2332
2333 if (data.username == 1)
2334 {
2335 user_t *user = data.hash_info[idx]->user;
2336
2337 uint i;
2338
2339 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2340
2341 fputc (separator, fp);
2342 }
2343
2344 ascii_digest (out_buf, salt_pos, digest_pos);
2345
2346 fputs (out_buf, fp);
2347
2348 log_out (fp, "");
2349 }
2350 else
2351 {
2352 hccap_t hccap;
2353
2354 to_hccap_t (&hccap, salt_pos, digest_pos);
2355
2356 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2357 }
2358 }
2359 }
2360
2361 fflush (fp);
2362
2363 fclose (fp);
2364
2365 unlink (old_hashfile);
2366
2367 if (rename (hashfile, old_hashfile) != 0)
2368 {
2369 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2370
2371 exit (-1);
2372 }
2373
2374 unlink (hashfile);
2375
2376 if (rename (new_hashfile, hashfile) != 0)
2377 {
2378 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2379
2380 exit (-1);
2381 }
2382
2383 unlink (old_hashfile);
2384 }
2385
2386 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2387 {
2388 // function called only in case kernel_power_all > words_left
2389
2390 float kernel_power_div = (float) (total_left) / kernel_power_all;
2391
2392 kernel_power_div += kernel_power_div / 100;
2393
2394 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2395
2396 while (kernel_power_new < total_left)
2397 {
2398 kernel_power_div += kernel_power_div / 100;
2399
2400 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2401 }
2402
2403 if (data.quiet == 0)
2404 {
2405 clear_prompt ();
2406
2407 //log_info ("");
2408
2409 log_info ("INFO: approaching final keyspace, workload adjusted");
2410 log_info ("");
2411
2412 fprintf (stdout, "%s", PROMPT);
2413
2414 fflush (stdout);
2415 }
2416
2417 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2418
2419 return kernel_power_div;
2420 }
2421
2422 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2423 {
2424 uint num_elements = num;
2425
2426 device_param->kernel_params_buf32[30] = data.combs_mode;
2427 device_param->kernel_params_buf32[31] = num;
2428
2429 uint kernel_threads = device_param->kernel_threads;
2430
2431 while (num_elements % kernel_threads) num_elements++;
2432
2433 cl_kernel kernel = NULL;
2434
2435 switch (kern_run)
2436 {
2437 case KERN_RUN_1: kernel = device_param->kernel1; break;
2438 case KERN_RUN_12: kernel = device_param->kernel12; break;
2439 case KERN_RUN_2: kernel = device_param->kernel2; break;
2440 case KERN_RUN_23: kernel = device_param->kernel23; break;
2441 case KERN_RUN_3: kernel = device_param->kernel3; break;
2442 }
2443
2444 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2445 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2446 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2447 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2448 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2449 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2450 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2451 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2452 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2453 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2454 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2455
2456 cl_event event;
2457
2458 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2459 {
2460 const size_t global_work_size[3] = { num_elements, 32, 1 };
2461 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2462
2463 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2464 }
2465 else
2466 {
2467 if (kern_run == KERN_RUN_2)
2468 {
2469 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2470 {
2471 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2472 }
2473 }
2474
2475 while (num_elements % kernel_threads) num_elements++;
2476
2477 const size_t global_work_size[3] = { num_elements, 1, 1 };
2478 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2479
2480 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2481 }
2482
2483 hc_clFlush (data.ocl, device_param->command_queue);
2484
2485 hc_clWaitForEvents (data.ocl, 1, &event);
2486
2487 if (event_update)
2488 {
2489 cl_ulong time_start;
2490 cl_ulong time_end;
2491
2492 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2493 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2494
2495 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2496
2497 uint exec_pos = device_param->exec_pos;
2498
2499 device_param->exec_ms[exec_pos] = exec_time;
2500
2501 exec_pos++;
2502
2503 if (exec_pos == EXEC_CACHE)
2504 {
2505 exec_pos = 0;
2506 }
2507
2508 device_param->exec_pos = exec_pos;
2509 }
2510
2511 hc_clReleaseEvent (data.ocl, event);
2512
2513 hc_clFinish (data.ocl, device_param->command_queue);
2514 }
2515
2516 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2517 {
2518 uint num_elements = num;
2519
2520 switch (kern_run)
2521 {
2522 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2523 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2524 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2525 }
2526
2527 // causes problems with special threads like in bcrypt
2528 // const uint kernel_threads = device_param->kernel_threads;
2529
2530 uint kernel_threads = device_param->kernel_threads;
2531
2532 while (num_elements % kernel_threads) num_elements++;
2533
2534 cl_kernel kernel = NULL;
2535
2536 switch (kern_run)
2537 {
2538 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2539 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2540 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2541 }
2542
2543 switch (kern_run)
2544 {
2545 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2546 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2547 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2548 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2549 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2550 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2551 break;
2552 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2553 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2554 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2555 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2556 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2557 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2558 break;
2559 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2560 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2561 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2562 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2563 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2564 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2565 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2566 break;
2567 }
2568
2569 const size_t global_work_size[3] = { num_elements, 1, 1 };
2570 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2571
2572 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2573
2574 hc_clFlush (data.ocl, device_param->command_queue);
2575
2576 hc_clFinish (data.ocl, device_param->command_queue);
2577 }
2578
2579 static void run_kernel_tm (hc_device_param_t *device_param)
2580 {
2581 const uint num_elements = 1024; // fixed
2582
2583 uint kernel_threads = 32;
2584
2585 cl_kernel kernel = device_param->kernel_tm;
2586
2587 const size_t global_work_size[3] = { num_elements, 1, 1 };
2588 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2589
2590 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2591
2592 hc_clFlush (data.ocl, device_param->command_queue);
2593
2594 hc_clFinish (data.ocl, device_param->command_queue);
2595 }
2596
2597 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2598 {
2599 uint num_elements = num;
2600
2601 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2602 device_param->kernel_params_amp_buf32[6] = num_elements;
2603
2604 // causes problems with special threads like in bcrypt
2605 // const uint kernel_threads = device_param->kernel_threads;
2606
2607 uint kernel_threads = device_param->kernel_threads;
2608
2609 while (num_elements % kernel_threads) num_elements++;
2610
2611 cl_kernel kernel = device_param->kernel_amp;
2612
2613 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2614 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2615
2616 const size_t global_work_size[3] = { num_elements, 1, 1 };
2617 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2618
2619 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2620
2621 hc_clFlush (data.ocl, device_param->command_queue);
2622
2623 hc_clFinish (data.ocl, device_param->command_queue);
2624 }
2625
2626 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2627 {
2628 const u32 num16d = num / 16;
2629 const u32 num16m = num % 16;
2630
2631 if (num16d)
2632 {
2633 device_param->kernel_params_memset_buf32[1] = value;
2634 device_param->kernel_params_memset_buf32[2] = num16d;
2635
2636 uint kernel_threads = device_param->kernel_threads;
2637
2638 uint num_elements = num16d;
2639
2640 while (num_elements % kernel_threads) num_elements++;
2641
2642 cl_kernel kernel = device_param->kernel_memset;
2643
2644 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2645 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2646 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2647
2648 const size_t global_work_size[3] = { num_elements, 1, 1 };
2649 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2650
2651 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2652
2653 hc_clFlush (data.ocl, device_param->command_queue);
2654
2655 hc_clFinish (data.ocl, device_param->command_queue);
2656 }
2657
2658 if (num16m)
2659 {
2660 u32 tmp[4];
2661
2662 tmp[0] = value;
2663 tmp[1] = value;
2664 tmp[2] = value;
2665 tmp[3] = value;
2666
2667 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2668 }
2669 }
2670
2671 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2672 {
2673 run_kernel_memset (device_param, buf, 0, size);
2674
2675 /*
2676 int rc = -1;
2677
2678 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2679 {
2680 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2681
2682 const cl_uchar zero = 0;
2683
2684 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2685 }
2686
2687 if (rc != 0)
2688 {
2689 // NOTE: clEnqueueFillBuffer () always fails with -59
2690 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2691 // How's that possible, OpenCL 1.2 support is advertised??
2692 // We need to workaround...
2693
2694 #define FILLSZ 0x100000
2695
2696 char *tmp = (char *) mymalloc (FILLSZ);
2697
2698 for (size_t i = 0; i < size; i += FILLSZ)
2699 {
2700 const size_t left = size - i;
2701
2702 const size_t fillsz = MIN (FILLSZ, left);
2703
2704 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2705 }
2706
2707 myfree (tmp);
2708 }
2709 */
2710 }
2711
2712 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)
2713 {
2714 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2715 {
2716 if (attack_mode == ATTACK_MODE_BF)
2717 {
2718 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2719 {
2720 const uint size_tm = 32 * sizeof (bs_word_t);
2721
2722 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2723
2724 run_kernel_tm (device_param);
2725
2726 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);
2727 }
2728 }
2729
2730 if (highest_pw_len < 16)
2731 {
2732 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2733 }
2734 else if (highest_pw_len < 32)
2735 {
2736 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2737 }
2738 else
2739 {
2740 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2741 }
2742 }
2743 else
2744 {
2745 run_kernel_amp (device_param, pws_cnt);
2746
2747 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2748
2749 if (opts_type & OPTS_TYPE_HOOK12)
2750 {
2751 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2752 }
2753
2754 uint iter = salt_buf->salt_iter;
2755
2756 uint loop_step = device_param->kernel_loops;
2757
2758 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2759 {
2760 uint loop_left = iter - loop_pos;
2761
2762 loop_left = MIN (loop_left, loop_step);
2763
2764 device_param->kernel_params_buf32[25] = loop_pos;
2765 device_param->kernel_params_buf32[26] = loop_left;
2766
2767 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2768
2769 if (data.devices_status == STATUS_CRACKED) break;
2770 if (data.devices_status == STATUS_ABORTED) break;
2771 if (data.devices_status == STATUS_QUIT) break;
2772
2773 /**
2774 * speed
2775 */
2776
2777 const float iter_part = (float) (loop_pos + loop_left) / iter;
2778
2779 const u64 perf_sum_all = pws_cnt * iter_part;
2780
2781 double speed_ms;
2782
2783 hc_timer_get (device_param->timer_speed, speed_ms);
2784
2785 const u32 speed_pos = device_param->speed_pos;
2786
2787 device_param->speed_cnt[speed_pos] = perf_sum_all;
2788
2789 device_param->speed_ms[speed_pos] = speed_ms;
2790
2791 if (data.benchmark == 1)
2792 {
2793 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2794 }
2795 }
2796
2797 if (opts_type & OPTS_TYPE_HOOK23)
2798 {
2799 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2800
2801 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);
2802
2803 // do something with data
2804
2805 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);
2806 }
2807
2808 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2809 }
2810 }
2811
2812 static int run_rule_engine (const int rule_len, const char *rule_buf)
2813 {
2814 if (rule_len == 0)
2815 {
2816 return 0;
2817 }
2818 else if (rule_len == 1)
2819 {
2820 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2821 }
2822
2823 return 1;
2824 }
2825
2826 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2827 {
2828 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2829 {
2830 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);
2831 }
2832 else if (data.attack_kern == ATTACK_KERN_COMBI)
2833 {
2834 if (data.attack_mode == ATTACK_MODE_COMBI)
2835 {
2836 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2837 {
2838 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2839 {
2840 for (u32 i = 0; i < pws_cnt; i++)
2841 {
2842 const u32 pw_len = device_param->pws_buf[i].pw_len;
2843
2844 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2845
2846 ptr[pw_len] = 0x01;
2847 }
2848 }
2849 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2850 {
2851 for (u32 i = 0; i < pws_cnt; i++)
2852 {
2853 const u32 pw_len = device_param->pws_buf[i].pw_len;
2854
2855 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2856
2857 ptr[pw_len] = 0x80;
2858 }
2859 }
2860 }
2861 }
2862 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2863 {
2864 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2865 {
2866 for (u32 i = 0; i < pws_cnt; i++)
2867 {
2868 const u32 pw_len = device_param->pws_buf[i].pw_len;
2869
2870 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2871
2872 ptr[pw_len] = 0x01;
2873 }
2874 }
2875 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2876 {
2877 for (u32 i = 0; i < pws_cnt; i++)
2878 {
2879 const u32 pw_len = device_param->pws_buf[i].pw_len;
2880
2881 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2882
2883 ptr[pw_len] = 0x80;
2884 }
2885 }
2886 }
2887
2888 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);
2889 }
2890 else if (data.attack_kern == ATTACK_KERN_BF)
2891 {
2892 const u64 off = device_param->words_off;
2893
2894 device_param->kernel_params_mp_l_buf64[3] = off;
2895
2896 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2897 }
2898 }
2899
2900 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2901 {
2902 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2903
2904 device_param->kernel_params_buf32[25] = 0;
2905 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2906 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2907
2908 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2909 {
2910 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2911 }
2912 else
2913 {
2914 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2915 }
2916
2917 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2918
2919 return exec_ms_prev;
2920 }
2921
2922 static void autotune (hc_device_param_t *device_param)
2923 {
2924 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2925
2926 const u32 kernel_accel_min = device_param->kernel_accel_min;
2927 const u32 kernel_accel_max = device_param->kernel_accel_max;
2928
2929 const u32 kernel_loops_min = device_param->kernel_loops_min;
2930 const u32 kernel_loops_max = device_param->kernel_loops_max;
2931
2932 u32 kernel_accel = kernel_accel_min;
2933 u32 kernel_loops = kernel_loops_min;
2934
2935 // in this case the user specified a fixed -u and -n on the commandline
2936 // no way to tune anything
2937 // but we need to run a few caching rounds
2938
2939 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2940 {
2941 try_run (device_param, kernel_accel, kernel_loops);
2942 try_run (device_param, kernel_accel, kernel_loops);
2943 try_run (device_param, kernel_accel, kernel_loops);
2944 try_run (device_param, kernel_accel, kernel_loops);
2945
2946 device_param->kernel_accel = kernel_accel;
2947 device_param->kernel_loops = kernel_loops;
2948
2949 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2950
2951 device_param->kernel_power = kernel_power;
2952
2953 return;
2954 }
2955
2956 // from here it's clear we are allowed to autotune
2957 // so let's init some fake words
2958
2959 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2960
2961 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2962
2963 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2964 {
2965 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 7, kernel_power_max * sizeof (pw_t));
2966 }
2967
2968 /*
2969 for (u32 i = 0; i < kernel_power_max; i++)
2970 {
2971 device_param->pws_buf[i].i[0] = i;
2972 device_param->pws_buf[i].i[1] = 0x01234567;
2973 device_param->pws_buf[i].pw_len = 7;
2974 }
2975
2976 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);
2977
2978 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2979 {
2980 run_kernel_amp (device_param, kernel_power_max);
2981 }
2982 */
2983
2984 #define VERIFIER_CNT 1
2985
2986 // first find out highest kernel-loops that stays below target_ms
2987
2988 if (kernel_loops_min < kernel_loops_max)
2989 {
2990 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2991 {
2992 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2993
2994 for (int i = 0; i < VERIFIER_CNT; i++)
2995 {
2996 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
2997
2998 exec_ms = MIN (exec_ms, exec_ms_v);
2999 }
3000
3001 if (exec_ms < target_ms) break;
3002 }
3003 }
3004
3005 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3006
3007 #define STEPS_CNT 10
3008
3009 if (kernel_accel_min < kernel_accel_max)
3010 {
3011 for (int i = 0; i < STEPS_CNT; i++)
3012 {
3013 const u32 kernel_accel_try = 1 << i;
3014
3015 if (kernel_accel_try < kernel_accel_min) continue;
3016 if (kernel_accel_try > kernel_accel_max) break;
3017
3018 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3019
3020 for (int i = 0; i < VERIFIER_CNT; i++)
3021 {
3022 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3023
3024 exec_ms = MIN (exec_ms, exec_ms_v);
3025 }
3026
3027 if (exec_ms > target_ms) break;
3028
3029 kernel_accel = kernel_accel_try;
3030 }
3031 }
3032
3033 // at this point we want to know the actual runtime for the following reason:
3034 // we need a reference for the balancing loop following up, and this
3035 // the balancing loop can have an effect that the creates a new opportunity, for example:
3036 // if the target is 95 ms and the current runtime is 48ms the above loop
3037 // stopped the execution because the previous exec_ms was > 95ms
3038 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3039 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3040
3041 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3042
3043 for (int i = 0; i < VERIFIER_CNT; i++)
3044 {
3045 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3046
3047 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3048 }
3049
3050 u32 diff = kernel_loops - kernel_accel;
3051
3052 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3053 {
3054 u32 kernel_accel_orig = kernel_accel;
3055 u32 kernel_loops_orig = kernel_loops;
3056
3057 for (u32 f = 1; f < 1024; f++)
3058 {
3059 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3060 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3061
3062 if (kernel_accel_try > kernel_accel_max) break;
3063 if (kernel_loops_try < kernel_loops_min) break;
3064
3065 u32 diff_new = kernel_loops_try - kernel_accel_try;
3066
3067 if (diff_new > diff) break;
3068
3069 diff_new = diff;
3070
3071 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3072
3073 for (int i = 0; i < VERIFIER_CNT; i++)
3074 {
3075 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3076
3077 exec_ms = MIN (exec_ms, exec_ms_v);
3078 }
3079
3080 if (exec_ms < exec_ms_pre_final)
3081 {
3082 exec_ms_pre_final = exec_ms;
3083
3084 kernel_accel = kernel_accel_try;
3085 kernel_loops = kernel_loops_try;
3086 }
3087 }
3088 }
3089
3090 const double exec_left = target_ms / exec_ms_pre_final;
3091
3092 const double accel_left = kernel_accel_max / kernel_accel;
3093
3094 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3095
3096 if (exec_accel_min >= 1.0)
3097 {
3098 // this is safe to not overflow kernel_accel_max because of accel_left
3099
3100 kernel_accel = (double) kernel_accel * exec_accel_min;
3101 }
3102
3103 // reset them fake words
3104
3105 /*
3106 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3107
3108 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);
3109 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);
3110 */
3111
3112 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3113
3114 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3115 {
3116 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3117 }
3118
3119 // reset timer
3120
3121 device_param->exec_pos = 0;
3122
3123 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3124
3125 // store
3126
3127 device_param->kernel_accel = kernel_accel;
3128 device_param->kernel_loops = kernel_loops;
3129
3130 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3131
3132 device_param->kernel_power = kernel_power;
3133
3134 #ifdef DEBUG
3135
3136 if (data.quiet == 0)
3137 {
3138 clear_prompt ();
3139
3140 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3141 "Device #%u: autotuned kernel-loops to %u\n",
3142 device_param->device_id + 1, kernel_accel,
3143 device_param->device_id + 1, kernel_loops);
3144
3145 fprintf (stdout, "%s", PROMPT);
3146
3147 fflush (stdout);
3148 }
3149
3150 #endif
3151 }
3152
3153 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3154 {
3155 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3156
3157 // init speed timer
3158
3159 uint speed_pos = device_param->speed_pos;
3160
3161 #ifdef _POSIX
3162 if (device_param->timer_speed.tv_sec == 0)
3163 {
3164 hc_timer_set (&device_param->timer_speed);
3165 }
3166 #endif
3167
3168 #ifdef _WIN
3169 if (device_param->timer_speed.QuadPart == 0)
3170 {
3171 hc_timer_set (&device_param->timer_speed);
3172 }
3173 #endif
3174
3175 // find higest password length, this is for optimization stuff
3176
3177 uint highest_pw_len = 0;
3178
3179 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3180 {
3181 }
3182 else if (data.attack_kern == ATTACK_KERN_COMBI)
3183 {
3184 }
3185 else if (data.attack_kern == ATTACK_KERN_BF)
3186 {
3187 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3188 + device_param->kernel_params_mp_l_buf32[5];
3189 }
3190
3191 // iteration type
3192
3193 uint innerloop_step = 0;
3194 uint innerloop_cnt = 0;
3195
3196 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3197 else innerloop_step = 1;
3198
3199 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3200 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3201 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3202
3203 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3204
3205 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3206 {
3207 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3208
3209 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3210
3211 if (data.devices_status == STATUS_CRACKED) break;
3212 if (data.devices_status == STATUS_ABORTED) break;
3213 if (data.devices_status == STATUS_QUIT) break;
3214 if (data.devices_status == STATUS_BYPASS) break;
3215
3216 salt_t *salt_buf = &data.salts_buf[salt_pos];
3217
3218 device_param->kernel_params_buf32[24] = salt_pos;
3219 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3220 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3221
3222 FILE *combs_fp = device_param->combs_fp;
3223
3224 if (data.attack_mode == ATTACK_MODE_COMBI)
3225 {
3226 rewind (combs_fp);
3227 }
3228
3229 // innerloops
3230
3231 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3232 {
3233 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3234
3235 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3236
3237 if (data.devices_status == STATUS_CRACKED) break;
3238 if (data.devices_status == STATUS_ABORTED) break;
3239 if (data.devices_status == STATUS_QUIT) break;
3240 if (data.devices_status == STATUS_BYPASS) break;
3241
3242 uint innerloop_left = innerloop_cnt - innerloop_pos;
3243
3244 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3245
3246 device_param->innerloop_pos = innerloop_pos;
3247 device_param->innerloop_left = innerloop_left;
3248
3249 device_param->kernel_params_buf32[27] = innerloop_left;
3250
3251 // i think we can get rid of this
3252 if (innerloop_left == 0)
3253 {
3254 puts ("bug, how should this happen????\n");
3255
3256 continue;
3257 }
3258
3259 if (data.salts_shown[salt_pos] == 1)
3260 {
3261 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3262
3263 continue;
3264 }
3265
3266 // initialize amplifiers
3267
3268 if (data.attack_mode == ATTACK_MODE_COMBI)
3269 {
3270 uint i = 0;
3271
3272 while (i < innerloop_left)
3273 {
3274 if (feof (combs_fp)) break;
3275
3276 int line_len = fgetl (combs_fp, line_buf);
3277
3278 if (line_len >= PW_MAX1) continue;
3279
3280 line_len = convert_from_hex (line_buf, line_len);
3281
3282 char *line_buf_new = line_buf;
3283
3284 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3285 {
3286 char rule_buf_out[BLOCK_SIZE] = { 0 };
3287
3288 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3289
3290 if (rule_len_out < 0)
3291 {
3292 data.words_progress_rejected[salt_pos] += pws_cnt;
3293
3294 continue;
3295 }
3296
3297 line_len = rule_len_out;
3298
3299 line_buf_new = rule_buf_out;
3300 }
3301
3302 line_len = MIN (line_len, PW_DICTMAX);
3303
3304 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3305
3306 memcpy (ptr, line_buf_new, line_len);
3307
3308 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3309
3310 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3311 {
3312 uppercase (ptr, line_len);
3313 }
3314
3315 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3316 {
3317 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3318 {
3319 ptr[line_len] = 0x80;
3320 }
3321
3322 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3323 {
3324 ptr[line_len] = 0x01;
3325 }
3326 }
3327
3328 device_param->combs_buf[i].pw_len = line_len;
3329
3330 i++;
3331 }
3332
3333 for (uint j = i; j < innerloop_left; j++)
3334 {
3335 device_param->combs_buf[j].i[0] = 0;
3336 device_param->combs_buf[j].i[1] = 0;
3337 device_param->combs_buf[j].i[2] = 0;
3338 device_param->combs_buf[j].i[3] = 0;
3339 device_param->combs_buf[j].i[4] = 0;
3340 device_param->combs_buf[j].i[5] = 0;
3341 device_param->combs_buf[j].i[6] = 0;
3342 device_param->combs_buf[j].i[7] = 0;
3343
3344 device_param->combs_buf[j].pw_len = 0;
3345 }
3346
3347 innerloop_left = i;
3348 }
3349 else if (data.attack_mode == ATTACK_MODE_BF)
3350 {
3351 u64 off = innerloop_pos;
3352
3353 device_param->kernel_params_mp_r_buf64[3] = off;
3354
3355 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3356 }
3357 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3358 {
3359 u64 off = innerloop_pos;
3360
3361 device_param->kernel_params_mp_buf64[3] = off;
3362
3363 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3364 }
3365 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3366 {
3367 u64 off = innerloop_pos;
3368
3369 device_param->kernel_params_mp_buf64[3] = off;
3370
3371 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3372 }
3373
3374 // copy amplifiers
3375
3376 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3377 {
3378 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);
3379 }
3380 else if (data.attack_mode == ATTACK_MODE_COMBI)
3381 {
3382 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);
3383 }
3384 else if (data.attack_mode == ATTACK_MODE_BF)
3385 {
3386 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);
3387 }
3388 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3389 {
3390 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);
3391 }
3392 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3393 {
3394 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);
3395 }
3396
3397 if (data.benchmark == 1)
3398 {
3399 hc_timer_set (&device_param->timer_speed);
3400 }
3401
3402 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3403
3404 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3405
3406 if (data.devices_status == STATUS_CRACKED) break;
3407 if (data.devices_status == STATUS_ABORTED) break;
3408 if (data.devices_status == STATUS_QUIT) break;
3409
3410 /**
3411 * result
3412 */
3413
3414 check_cracked (device_param, salt_pos);
3415
3416 /**
3417 * progress
3418 */
3419
3420 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3421
3422 hc_thread_mutex_lock (mux_counter);
3423
3424 data.words_progress_done[salt_pos] += perf_sum_all;
3425
3426 hc_thread_mutex_unlock (mux_counter);
3427
3428 /**
3429 * speed
3430 */
3431
3432 double speed_ms;
3433
3434 hc_timer_get (device_param->timer_speed, speed_ms);
3435
3436 hc_timer_set (&device_param->timer_speed);
3437
3438 // current speed
3439
3440 //hc_thread_mutex_lock (mux_display);
3441
3442 device_param->speed_cnt[speed_pos] = perf_sum_all;
3443
3444 device_param->speed_ms[speed_pos] = speed_ms;
3445
3446 //hc_thread_mutex_unlock (mux_display);
3447
3448 speed_pos++;
3449
3450 if (speed_pos == SPEED_CACHE)
3451 {
3452 speed_pos = 0;
3453 }
3454
3455 /**
3456 * benchmark
3457 */
3458
3459 if (data.benchmark == 1) break;
3460 }
3461 }
3462
3463 device_param->speed_pos = speed_pos;
3464
3465 myfree (line_buf);
3466 }
3467
3468 static void load_segment (wl_data_t *wl_data, FILE *fd)
3469 {
3470 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3471
3472 wl_data->pos = 0;
3473
3474 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3475
3476 wl_data->buf[wl_data->cnt] = 0;
3477
3478 if (wl_data->cnt == 0) return;
3479
3480 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3481
3482 while (!feof (fd))
3483 {
3484 if (wl_data->cnt == wl_data->avail)
3485 {
3486 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3487
3488 wl_data->avail += wl_data->incr;
3489 }
3490
3491 const int c = fgetc (fd);
3492
3493 if (c == EOF) break;
3494
3495 wl_data->buf[wl_data->cnt] = (char) c;
3496
3497 wl_data->cnt++;
3498
3499 if (c == '\n') break;
3500 }
3501
3502 // ensure stream ends with a newline
3503
3504 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3505 {
3506 wl_data->cnt++;
3507
3508 wl_data->buf[wl_data->cnt - 1] = '\n';
3509 }
3510
3511 return;
3512 }
3513
3514 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3515 {
3516 char *ptr = buf;
3517
3518 for (u32 i = 0; i < sz; i++, ptr++)
3519 {
3520 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3521
3522 if (i == 7)
3523 {
3524 *off = i;
3525 *len = i;
3526
3527 return;
3528 }
3529
3530 if (*ptr != '\n') continue;
3531
3532 *off = i + 1;
3533
3534 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3535
3536 *len = i;
3537
3538 return;
3539 }
3540
3541 *off = sz;
3542 *len = sz;
3543 }
3544
3545 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3546 {
3547 char *ptr = buf;
3548
3549 for (u32 i = 0; i < sz; i++, ptr++)
3550 {
3551 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3552
3553 if (*ptr != '\n') continue;
3554
3555 *off = i + 1;
3556
3557 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3558
3559 *len = i;
3560
3561 return;
3562 }
3563
3564 *off = sz;
3565 *len = sz;
3566 }
3567
3568 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3569 {
3570 char *ptr = buf;
3571
3572 for (u32 i = 0; i < sz; i++, ptr++)
3573 {
3574 if (*ptr != '\n') continue;
3575
3576 *off = i + 1;
3577
3578 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3579
3580 *len = i;
3581
3582 return;
3583 }
3584
3585 *off = sz;
3586 *len = sz;
3587 }
3588
3589 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3590 {
3591 while (wl_data->pos < wl_data->cnt)
3592 {
3593 uint off;
3594 uint len;
3595
3596 char *ptr = wl_data->buf + wl_data->pos;
3597
3598 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3599
3600 wl_data->pos += off;
3601
3602 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3603 {
3604 char rule_buf_out[BLOCK_SIZE] = { 0 };
3605
3606 int rule_len_out = -1;
3607
3608 if (len < BLOCK_SIZE)
3609 {
3610 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3611 }
3612
3613 if (rule_len_out < 0)
3614 {
3615 continue;
3616 }
3617
3618 if (rule_len_out > PW_MAX)
3619 {
3620 continue;
3621 }
3622 }
3623 else
3624 {
3625 if (len > PW_MAX)
3626 {
3627 continue;
3628 }
3629 }
3630
3631 *out_buf = ptr;
3632 *out_len = len;
3633
3634 return;
3635 }
3636
3637 if (feof (fd))
3638 {
3639 fprintf (stderr, "BUG feof()!!\n");
3640
3641 return;
3642 }
3643
3644 load_segment (wl_data, fd);
3645
3646 get_next_word (wl_data, fd, out_buf, out_len);
3647 }
3648
3649 #ifdef _POSIX
3650 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3651 #endif
3652
3653 #ifdef _WIN
3654 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3655 #endif
3656 {
3657 hc_signal (NULL);
3658
3659 dictstat_t d;
3660
3661 d.cnt = 0;
3662
3663 #ifdef _POSIX
3664 fstat (fileno (fd), &d.stat);
3665 #endif
3666
3667 #ifdef _WIN
3668 _fstat64 (fileno (fd), &d.stat);
3669 #endif
3670
3671 d.stat.st_mode = 0;
3672 d.stat.st_nlink = 0;
3673 d.stat.st_uid = 0;
3674 d.stat.st_gid = 0;
3675 d.stat.st_rdev = 0;
3676 d.stat.st_atime = 0;
3677
3678 #ifdef _POSIX
3679 d.stat.st_blksize = 0;
3680 d.stat.st_blocks = 0;
3681 #endif
3682
3683 if (d.stat.st_size == 0) return 0;
3684
3685 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3686
3687 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3688 {
3689 if (d_cache)
3690 {
3691 u64 cnt = d_cache->cnt;
3692
3693 u64 keyspace = cnt;
3694
3695 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3696 {
3697 keyspace *= data.kernel_rules_cnt;
3698 }
3699 else if (data.attack_kern == ATTACK_KERN_COMBI)
3700 {
3701 keyspace *= data.combs_cnt;
3702 }
3703
3704 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);
3705 if (data.quiet == 0) log_info ("");
3706
3707 hc_signal (sigHandler_default);
3708
3709 return (keyspace);
3710 }
3711 }
3712
3713 time_t now = 0;
3714 time_t prev = 0;
3715
3716 u64 comp = 0;
3717 u64 cnt = 0;
3718 u64 cnt2 = 0;
3719
3720 while (!feof (fd))
3721 {
3722 load_segment (wl_data, fd);
3723
3724 comp += wl_data->cnt;
3725
3726 u32 i = 0;
3727
3728 while (i < wl_data->cnt)
3729 {
3730 u32 len;
3731 u32 off;
3732
3733 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3734
3735 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3736 {
3737 char rule_buf_out[BLOCK_SIZE] = { 0 };
3738
3739 int rule_len_out = -1;
3740
3741 if (len < BLOCK_SIZE)
3742 {
3743 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3744 }
3745
3746 if (rule_len_out < 0)
3747 {
3748 len = PW_MAX1;
3749 }
3750 else
3751 {
3752 len = rule_len_out;
3753 }
3754 }
3755
3756 if (len < PW_MAX1)
3757 {
3758 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3759 {
3760 cnt += data.kernel_rules_cnt;
3761 }
3762 else if (data.attack_kern == ATTACK_KERN_COMBI)
3763 {
3764 cnt += data.combs_cnt;
3765 }
3766
3767 d.cnt++;
3768 }
3769
3770 i += off;
3771
3772 cnt2++;
3773 }
3774
3775 time (&now);
3776
3777 if ((now - prev) == 0) continue;
3778
3779 float percent = (float) comp / (float) d.stat.st_size;
3780
3781 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);
3782
3783 time (&prev);
3784 }
3785
3786 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);
3787 if (data.quiet == 0) log_info ("");
3788
3789 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3790
3791 hc_signal (sigHandler_default);
3792
3793 return (cnt);
3794 }
3795
3796 static void *thread_monitor (void *p)
3797 {
3798 uint runtime_check = 0;
3799 uint remove_check = 0;
3800 uint status_check = 0;
3801 uint restore_check = 0;
3802
3803 uint restore_left = data.restore_timer;
3804 uint remove_left = data.remove_timer;
3805 uint status_left = data.status_timer;
3806
3807 #ifdef HAVE_HWMON
3808 uint hwmon_check = 0;
3809
3810 int slowdown_warnings = 0;
3811
3812 // these variables are mainly used for fan control (AMD only)
3813
3814 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3815
3816 // temperature controller "loopback" values
3817
3818 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3819 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3820
3821 #ifdef HAVE_ADL
3822 int temp_threshold = 1; // degrees celcius
3823
3824 int fan_speed_min = 15; // in percentage
3825 int fan_speed_max = 100;
3826 #endif // HAVE_ADL
3827
3828 time_t last_temp_check_time;
3829 #endif // HAVE_HWMON
3830
3831 uint sleep_time = 1;
3832
3833 if (data.runtime)
3834 {
3835 runtime_check = 1;
3836 }
3837
3838 if (data.restore_timer)
3839 {
3840 restore_check = 1;
3841 }
3842
3843 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3844 {
3845 remove_check = 1;
3846 }
3847
3848 if (data.status == 1)
3849 {
3850 status_check = 1;
3851 }
3852
3853 #ifdef HAVE_HWMON
3854 if (data.gpu_temp_disable == 0)
3855 {
3856 time (&last_temp_check_time);
3857
3858 hwmon_check = 1;
3859 }
3860 #endif
3861
3862 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3863 {
3864 #ifdef HAVE_HWMON
3865 if (hwmon_check == 0)
3866 #endif
3867 return (p);
3868 }
3869
3870 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3871 {
3872 hc_sleep (sleep_time);
3873
3874 if (data.devices_status != STATUS_RUNNING) continue;
3875
3876 #ifdef HAVE_HWMON
3877
3878 if (1)
3879 {
3880 hc_thread_mutex_lock (mux_adl);
3881
3882 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3883 {
3884 hc_device_param_t *device_param = &data.devices_param[device_id];
3885
3886 if (device_param->skipped) continue;
3887
3888 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3889
3890 const int temperature = hm_get_temperature_with_device_id (device_id);
3891
3892 const int threshold = data.hm_device[device_id].gpu_temp_threshold_slowdown;
3893
3894 if (temperature >= threshold)
3895 {
3896 if (slowdown_warnings < 3)
3897 {
3898 if (data.quiet == 0) clear_prompt ();
3899
3900 log_info ("WARNING: Drivers temperature threshold (%dc) hit on GPU #%d, expect performance to drop...", threshold, device_id + 1);
3901
3902 if (slowdown_warnings == 2)
3903 {
3904 log_info ("");
3905 }
3906
3907 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
3908 if (data.quiet == 0) fflush (stdout);
3909
3910 slowdown_warnings++;
3911 }
3912 }
3913 else
3914 {
3915 slowdown_warnings = 0;
3916 }
3917 }
3918
3919 hc_thread_mutex_unlock (mux_adl);
3920 }
3921
3922 if (hwmon_check == 1)
3923 {
3924 hc_thread_mutex_lock (mux_adl);
3925
3926 time_t temp_check_time;
3927
3928 time (&temp_check_time);
3929
3930 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3931
3932 if (Ta == 0) Ta = 1;
3933
3934 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3935 {
3936 hc_device_param_t *device_param = &data.devices_param[device_id];
3937
3938 if (device_param->skipped) continue;
3939
3940 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3941
3942 const int temperature = hm_get_temperature_with_device_id (device_id);
3943
3944 if (temperature > (int) data.gpu_temp_abort)
3945 {
3946 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3947
3948 if (data.devices_status != STATUS_QUIT) myabort ();
3949
3950 break;
3951 }
3952
3953 #ifdef HAVE_ADL
3954 const int gpu_temp_retain = data.gpu_temp_retain;
3955
3956 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3957 {
3958 if (data.hm_device[device_id].fan_supported == 1)
3959 {
3960 int temp_cur = temperature;
3961
3962 int temp_diff_new = gpu_temp_retain - temp_cur;
3963
3964 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3965
3966 // calculate Ta value (time difference in seconds between the last check and this check)
3967
3968 last_temp_check_time = temp_check_time;
3969
3970 float Kp = 1.8;
3971 float Ki = 0.005;
3972 float Kd = 6;
3973
3974 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3975
3976 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);
3977
3978 if (abs (fan_diff_required) >= temp_threshold)
3979 {
3980 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3981
3982 int fan_speed_level = fan_speed_cur;
3983
3984 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3985
3986 int fan_speed_new = fan_speed_level - fan_diff_required;
3987
3988 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3989 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3990
3991 if (fan_speed_new != fan_speed_cur)
3992 {
3993 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3994 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3995
3996 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3997 {
3998 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3999
4000 fan_speed_chgd[device_id] = 1;
4001 }
4002
4003 temp_diff_old[device_id] = temp_diff_new;
4004 }
4005 }
4006 }
4007 }
4008 #endif // HAVE_ADL
4009 }
4010
4011 hc_thread_mutex_unlock (mux_adl);
4012 }
4013 #endif // HAVE_HWMON
4014
4015 if (restore_check == 1)
4016 {
4017 restore_left--;
4018
4019 if (restore_left == 0)
4020 {
4021 if (data.restore_disable == 0) cycle_restore ();
4022
4023 restore_left = data.restore_timer;
4024 }
4025 }
4026
4027 if ((runtime_check == 1) && (data.runtime_start > 0))
4028 {
4029 time_t runtime_cur;
4030
4031 time (&runtime_cur);
4032
4033 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4034
4035 if (runtime_left <= 0)
4036 {
4037 if (data.benchmark == 0)
4038 {
4039 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4040 }
4041
4042 if (data.devices_status != STATUS_QUIT) myabort ();
4043 }
4044 }
4045
4046 if (remove_check == 1)
4047 {
4048 remove_left--;
4049
4050 if (remove_left == 0)
4051 {
4052 if (data.digests_saved != data.digests_done)
4053 {
4054 data.digests_saved = data.digests_done;
4055
4056 save_hash ();
4057 }
4058
4059 remove_left = data.remove_timer;
4060 }
4061 }
4062
4063 if (status_check == 1)
4064 {
4065 status_left--;
4066
4067 if (status_left == 0)
4068 {
4069 //hc_thread_mutex_lock (mux_display);
4070
4071 if (data.quiet == 0) clear_prompt ();
4072
4073 if (data.quiet == 0) log_info ("");
4074
4075 status_display ();
4076
4077 if (data.quiet == 0) log_info ("");
4078
4079 //hc_thread_mutex_unlock (mux_display);
4080
4081 status_left = data.status_timer;
4082 }
4083 }
4084 }
4085
4086 #ifdef HAVE_HWMON
4087 myfree (fan_speed_chgd);
4088
4089 myfree (temp_diff_old);
4090 myfree (temp_diff_sum);
4091 #endif
4092
4093 p = NULL;
4094
4095 return (p);
4096 }
4097
4098 static void *thread_outfile_remove (void *p)
4099 {
4100 // some hash-dependent constants
4101 char *outfile_dir = data.outfile_check_directory;
4102 uint dgst_size = data.dgst_size;
4103 uint isSalted = data.isSalted;
4104 uint esalt_size = data.esalt_size;
4105 uint hash_mode = data.hash_mode;
4106
4107 uint outfile_check_timer = data.outfile_check_timer;
4108
4109 char separator = data.separator;
4110
4111 // some hash-dependent functions
4112 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4113 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4114
4115 // buffers
4116 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4117
4118 hash_buf.digest = mymalloc (dgst_size);
4119
4120 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4121
4122 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4123
4124 uint digest_buf[64] = { 0 };
4125
4126 outfile_data_t *out_info = NULL;
4127
4128 char **out_files = NULL;
4129
4130 time_t folder_mtime = 0;
4131
4132 int out_cnt = 0;
4133
4134 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4135
4136 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4137 {
4138 hc_sleep (1);
4139
4140 if (data.devices_status != STATUS_RUNNING) continue;
4141
4142 check_left--;
4143
4144 if (check_left == 0)
4145 {
4146 struct stat outfile_check_stat;
4147
4148 if (stat (outfile_dir, &outfile_check_stat) == 0)
4149 {
4150 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4151
4152 if (is_dir == 1)
4153 {
4154 if (outfile_check_stat.st_mtime > folder_mtime)
4155 {
4156 char **out_files_new = scan_directory (outfile_dir);
4157
4158 int out_cnt_new = count_dictionaries (out_files_new);
4159
4160 outfile_data_t *out_info_new = NULL;
4161
4162 if (out_cnt_new > 0)
4163 {
4164 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4165
4166 for (int i = 0; i < out_cnt_new; i++)
4167 {
4168 out_info_new[i].file_name = out_files_new[i];
4169
4170 // check if there are files that we have seen/checked before (and not changed)
4171
4172 for (int j = 0; j < out_cnt; j++)
4173 {
4174 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4175 {
4176 struct stat outfile_stat;
4177
4178 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4179 {
4180 if (outfile_stat.st_ctime == out_info[j].ctime)
4181 {
4182 out_info_new[i].ctime = out_info[j].ctime;
4183 out_info_new[i].seek = out_info[j].seek;
4184 }
4185 }
4186 }
4187 }
4188 }
4189 }
4190
4191 local_free (out_info);
4192 local_free (out_files);
4193
4194 out_files = out_files_new;
4195 out_cnt = out_cnt_new;
4196 out_info = out_info_new;
4197
4198 folder_mtime = outfile_check_stat.st_mtime;
4199 }
4200
4201 for (int j = 0; j < out_cnt; j++)
4202 {
4203 FILE *fp = fopen (out_info[j].file_name, "rb");
4204
4205 if (fp != NULL)
4206 {
4207 //hc_thread_mutex_lock (mux_display);
4208
4209 #ifdef _POSIX
4210 struct stat outfile_stat;
4211
4212 fstat (fileno (fp), &outfile_stat);
4213 #endif
4214
4215 #ifdef _WIN
4216 struct stat64 outfile_stat;
4217
4218 _fstat64 (fileno (fp), &outfile_stat);
4219 #endif
4220
4221 if (outfile_stat.st_ctime > out_info[j].ctime)
4222 {
4223 out_info[j].ctime = outfile_stat.st_ctime;
4224 out_info[j].seek = 0;
4225 }
4226
4227 fseek (fp, out_info[j].seek, SEEK_SET);
4228
4229 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4230
4231 while (!feof (fp))
4232 {
4233 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4234
4235 if (ptr == NULL) break;
4236
4237 int line_len = strlen (line_buf);
4238
4239 if (line_len <= 0) continue;
4240
4241 int iter = MAX_CUT_TRIES;
4242
4243 for (uint i = line_len - 1; i && iter; i--, line_len--)
4244 {
4245 if (line_buf[i] != separator) continue;
4246
4247 int parser_status = PARSER_OK;
4248
4249 if ((hash_mode != 2500) && (hash_mode != 6800))
4250 {
4251 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4252 }
4253
4254 uint found = 0;
4255
4256 if (parser_status == PARSER_OK)
4257 {
4258 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4259 {
4260 if (data.salts_shown[salt_pos] == 1) continue;
4261
4262 salt_t *salt_buf = &data.salts_buf[salt_pos];
4263
4264 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4265 {
4266 uint idx = salt_buf->digests_offset + digest_pos;
4267
4268 if (data.digests_shown[idx] == 1) continue;
4269
4270 uint cracked = 0;
4271
4272 if (hash_mode == 6800)
4273 {
4274 if (i == salt_buf->salt_len)
4275 {
4276 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4277 }
4278 }
4279 else if (hash_mode == 2500)
4280 {
4281 // BSSID : MAC1 : MAC2 (:plain)
4282 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4283 {
4284 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4285
4286 if (!cracked) continue;
4287
4288 // now compare MAC1 and MAC2 too, since we have this additional info
4289 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4290 char *mac2_pos = mac1_pos + 12 + 1;
4291
4292 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4293 wpa_t *wpa = &wpas[salt_pos];
4294
4295 // compare hex string(s) vs binary MAC address(es)
4296
4297 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4298 {
4299 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4300 {
4301 cracked = 0;
4302
4303 break;
4304 }
4305 }
4306
4307 // early skip ;)
4308 if (!cracked) continue;
4309
4310 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4311 {
4312 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4313 {
4314 cracked = 0;
4315
4316 break;
4317 }
4318 }
4319 }
4320 }
4321 else
4322 {
4323 char *digests_buf_ptr = (char *) data.digests_buf;
4324
4325 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4326
4327 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4328 }
4329
4330 if (cracked == 1)
4331 {
4332 found = 1;
4333
4334 data.digests_shown[idx] = 1;
4335
4336 data.digests_done++;
4337
4338 salt_buf->digests_done++;
4339
4340 if (salt_buf->digests_done == salt_buf->digests_cnt)
4341 {
4342 data.salts_shown[salt_pos] = 1;
4343
4344 data.salts_done++;
4345
4346 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4347 }
4348 }
4349 }
4350
4351 if (data.devices_status == STATUS_CRACKED) break;
4352 }
4353 }
4354
4355 if (found) break;
4356
4357 if (data.devices_status == STATUS_CRACKED) break;
4358
4359 iter--;
4360 }
4361
4362 if (data.devices_status == STATUS_CRACKED) break;
4363 }
4364
4365 myfree (line_buf);
4366
4367 out_info[j].seek = ftell (fp);
4368
4369 //hc_thread_mutex_unlock (mux_display);
4370
4371 fclose (fp);
4372 }
4373 }
4374 }
4375 }
4376
4377 check_left = outfile_check_timer;
4378 }
4379 }
4380
4381 if (esalt_size) local_free (hash_buf.esalt);
4382
4383 if (isSalted) local_free (hash_buf.salt);
4384
4385 local_free (hash_buf.digest);
4386
4387 local_free (out_info);
4388
4389 local_free (out_files);
4390
4391 p = NULL;
4392
4393 return (p);
4394 }
4395
4396 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4397 {
4398 if (device_param->pws_cnt < device_param->kernel_power)
4399 {
4400 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4401
4402 u8 *ptr = (u8 *) pw->i;
4403
4404 memcpy (ptr, pw_buf, pw_len);
4405
4406 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4407
4408 pw->pw_len = pw_len;
4409
4410 device_param->pws_cnt++;
4411 }
4412 else
4413 {
4414 fprintf (stderr, "BUG pw_add()!!\n");
4415
4416 return;
4417 }
4418 }
4419
4420 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4421 {
4422 hc_thread_mutex_lock (mux_dispatcher);
4423
4424 const u64 words_cur = data.words_cur;
4425 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4426
4427 device_param->words_off = words_cur;
4428
4429 const u64 words_left = words_base - words_cur;
4430
4431 if (allow_div)
4432 {
4433 if (data.kernel_power_all > words_left)
4434 {
4435 if (data.kernel_power_div == 0)
4436 {
4437 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4438 }
4439 }
4440
4441 if (data.kernel_power_div)
4442 {
4443 if (device_param->kernel_power == device_param->kernel_power_user)
4444 {
4445 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4446
4447 if (kernel_power_new < device_param->kernel_power)
4448 {
4449 device_param->kernel_power = kernel_power_new;
4450 }
4451 }
4452 }
4453 }
4454
4455 const uint kernel_power = device_param->kernel_power;
4456
4457 uint work = MIN (words_left, kernel_power);
4458
4459 work = MIN (work, max);
4460
4461 data.words_cur += work;
4462
4463 hc_thread_mutex_unlock (mux_dispatcher);
4464
4465 return work;
4466 }
4467
4468 static void *thread_calc_stdin (void *p)
4469 {
4470 hc_device_param_t *device_param = (hc_device_param_t *) p;
4471
4472 if (device_param->skipped) return NULL;
4473
4474 autotune (device_param);
4475
4476 char *buf = (char *) mymalloc (HCBUFSIZ);
4477
4478 const uint attack_kern = data.attack_kern;
4479
4480 const uint kernel_power = device_param->kernel_power;
4481
4482 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4483 {
4484 hc_thread_mutex_lock (mux_dispatcher);
4485
4486 if (feof (stdin) != 0)
4487 {
4488 hc_thread_mutex_unlock (mux_dispatcher);
4489
4490 break;
4491 }
4492
4493 uint words_cur = 0;
4494
4495 while (words_cur < kernel_power)
4496 {
4497 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4498
4499 if (line_buf == NULL) break;
4500
4501 uint line_len = in_superchop (line_buf);
4502
4503 line_len = convert_from_hex (line_buf, line_len);
4504
4505 // post-process rule engine
4506
4507 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4508 {
4509 char rule_buf_out[BLOCK_SIZE] = { 0 };
4510
4511 int rule_len_out = -1;
4512
4513 if (line_len < BLOCK_SIZE)
4514 {
4515 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4516 }
4517
4518 if (rule_len_out < 0) continue;
4519
4520 line_buf = rule_buf_out;
4521 line_len = rule_len_out;
4522 }
4523
4524 if (line_len > PW_MAX)
4525 {
4526 continue;
4527 }
4528
4529 if (attack_kern == ATTACK_KERN_STRAIGHT)
4530 {
4531 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4532 {
4533 hc_thread_mutex_lock (mux_counter);
4534
4535 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4536 {
4537 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4538 }
4539
4540 hc_thread_mutex_unlock (mux_counter);
4541
4542 continue;
4543 }
4544 }
4545 else if (attack_kern == ATTACK_KERN_COMBI)
4546 {
4547 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4548 // since we still need to combine the plains
4549
4550 if (line_len > data.pw_max)
4551 {
4552 hc_thread_mutex_lock (mux_counter);
4553
4554 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4555 {
4556 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4557 }
4558
4559 hc_thread_mutex_unlock (mux_counter);
4560
4561 continue;
4562 }
4563 }
4564
4565 pw_add (device_param, (u8 *) line_buf, line_len);
4566
4567 words_cur++;
4568
4569 if (data.devices_status == STATUS_CRACKED) break;
4570 if (data.devices_status == STATUS_ABORTED) break;
4571 if (data.devices_status == STATUS_QUIT) break;
4572 if (data.devices_status == STATUS_BYPASS) break;
4573 }
4574
4575 hc_thread_mutex_unlock (mux_dispatcher);
4576
4577 if (data.devices_status == STATUS_CRACKED) break;
4578 if (data.devices_status == STATUS_ABORTED) break;
4579 if (data.devices_status == STATUS_QUIT) break;
4580 if (data.devices_status == STATUS_BYPASS) break;
4581
4582 // flush
4583
4584 const uint pws_cnt = device_param->pws_cnt;
4585
4586 if (pws_cnt)
4587 {
4588 run_copy (device_param, pws_cnt);
4589
4590 run_cracker (device_param, pws_cnt);
4591
4592 device_param->pws_cnt = 0;
4593
4594 /*
4595 still required?
4596 if (attack_kern == ATTACK_KERN_STRAIGHT)
4597 {
4598 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4599 }
4600 else if (attack_kern == ATTACK_KERN_COMBI)
4601 {
4602 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4603 }
4604 */
4605 }
4606 }
4607
4608 device_param->kernel_accel = 0;
4609 device_param->kernel_loops = 0;
4610
4611 myfree (buf);
4612
4613 return NULL;
4614 }
4615
4616 static void *thread_calc (void *p)
4617 {
4618 hc_device_param_t *device_param = (hc_device_param_t *) p;
4619
4620 if (device_param->skipped) return NULL;
4621
4622 autotune (device_param);
4623
4624 const uint attack_mode = data.attack_mode;
4625 const uint attack_kern = data.attack_kern;
4626
4627 if (attack_mode == ATTACK_MODE_BF)
4628 {
4629 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4630 {
4631 const uint work = get_work (device_param, -1, true);
4632
4633 if (work == 0) break;
4634
4635 const u64 words_off = device_param->words_off;
4636 const u64 words_fin = words_off + work;
4637
4638 const uint pws_cnt = work;
4639
4640 device_param->pws_cnt = pws_cnt;
4641
4642 if (pws_cnt)
4643 {
4644 run_copy (device_param, pws_cnt);
4645
4646 run_cracker (device_param, pws_cnt);
4647
4648 device_param->pws_cnt = 0;
4649
4650 /*
4651 still required?
4652 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4653 */
4654 }
4655
4656 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4657
4658 if (data.devices_status == STATUS_CRACKED) break;
4659 if (data.devices_status == STATUS_ABORTED) break;
4660 if (data.devices_status == STATUS_QUIT) break;
4661 if (data.devices_status == STATUS_BYPASS) break;
4662
4663 if (data.benchmark == 1) break;
4664
4665 device_param->words_done = words_fin;
4666 }
4667 }
4668 else
4669 {
4670 const uint segment_size = data.segment_size;
4671
4672 char *dictfile = data.dictfile;
4673
4674 if (attack_mode == ATTACK_MODE_COMBI)
4675 {
4676 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4677 {
4678 dictfile = data.dictfile2;
4679 }
4680 }
4681
4682 FILE *fd = fopen (dictfile, "rb");
4683
4684 if (fd == NULL)
4685 {
4686 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4687
4688 return NULL;
4689 }
4690
4691 if (attack_mode == ATTACK_MODE_COMBI)
4692 {
4693 const uint combs_mode = data.combs_mode;
4694
4695 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4696 {
4697 const char *dictfilec = data.dictfile2;
4698
4699 FILE *combs_fp = fopen (dictfilec, "rb");
4700
4701 if (combs_fp == NULL)
4702 {
4703 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4704
4705 fclose (fd);
4706
4707 return NULL;
4708 }
4709
4710 device_param->combs_fp = combs_fp;
4711 }
4712 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4713 {
4714 const char *dictfilec = data.dictfile;
4715
4716 FILE *combs_fp = fopen (dictfilec, "rb");
4717
4718 if (combs_fp == NULL)
4719 {
4720 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4721
4722 fclose (fd);
4723
4724 return NULL;
4725 }
4726
4727 device_param->combs_fp = combs_fp;
4728 }
4729 }
4730
4731 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4732
4733 wl_data->buf = (char *) mymalloc (segment_size);
4734 wl_data->avail = segment_size;
4735 wl_data->incr = segment_size;
4736 wl_data->cnt = 0;
4737 wl_data->pos = 0;
4738
4739 u64 words_cur = 0;
4740
4741 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4742 {
4743 u64 words_off = 0;
4744 u64 words_fin = 0;
4745
4746 bool allow_div = true;
4747
4748 u64 max = -1;
4749
4750 while (max)
4751 {
4752 const uint work = get_work (device_param, max, allow_div);
4753
4754 allow_div = false;
4755
4756 if (work == 0) break;
4757
4758 words_off = device_param->words_off;
4759 words_fin = words_off + work;
4760
4761 char *line_buf;
4762 uint line_len;
4763
4764 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4765
4766 max = 0;
4767
4768 for ( ; words_cur < words_fin; words_cur++)
4769 {
4770 get_next_word (wl_data, fd, &line_buf, &line_len);
4771
4772 line_len = convert_from_hex (line_buf, line_len);
4773
4774 // post-process rule engine
4775
4776 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4777 {
4778 char rule_buf_out[BLOCK_SIZE] = { 0 };
4779
4780 int rule_len_out = -1;
4781
4782 if (line_len < BLOCK_SIZE)
4783 {
4784 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4785 }
4786
4787 if (rule_len_out < 0) continue;
4788
4789 line_buf = rule_buf_out;
4790 line_len = rule_len_out;
4791 }
4792
4793 if (attack_kern == ATTACK_KERN_STRAIGHT)
4794 {
4795 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4796 {
4797 max++;
4798
4799 hc_thread_mutex_lock (mux_counter);
4800
4801 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4802 {
4803 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4804 }
4805
4806 hc_thread_mutex_unlock (mux_counter);
4807
4808 continue;
4809 }
4810 }
4811 else if (attack_kern == ATTACK_KERN_COMBI)
4812 {
4813 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4814 // since we still need to combine the plains
4815
4816 if (line_len > data.pw_max)
4817 {
4818 max++;
4819
4820 hc_thread_mutex_lock (mux_counter);
4821
4822 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4823 {
4824 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4825 }
4826
4827 hc_thread_mutex_unlock (mux_counter);
4828
4829 continue;
4830 }
4831 }
4832
4833 pw_add (device_param, (u8 *) line_buf, line_len);
4834
4835 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4836
4837 if (data.devices_status == STATUS_CRACKED) break;
4838 if (data.devices_status == STATUS_ABORTED) break;
4839 if (data.devices_status == STATUS_QUIT) break;
4840 if (data.devices_status == STATUS_BYPASS) break;
4841 }
4842
4843 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4844
4845 if (data.devices_status == STATUS_CRACKED) break;
4846 if (data.devices_status == STATUS_ABORTED) break;
4847 if (data.devices_status == STATUS_QUIT) break;
4848 if (data.devices_status == STATUS_BYPASS) break;
4849 }
4850
4851 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4852
4853 if (data.devices_status == STATUS_CRACKED) break;
4854 if (data.devices_status == STATUS_ABORTED) break;
4855 if (data.devices_status == STATUS_QUIT) break;
4856 if (data.devices_status == STATUS_BYPASS) break;
4857
4858 //
4859 // flush
4860 //
4861
4862 const uint pws_cnt = device_param->pws_cnt;
4863
4864 if (pws_cnt)
4865 {
4866 run_copy (device_param, pws_cnt);
4867
4868 run_cracker (device_param, pws_cnt);
4869
4870 device_param->pws_cnt = 0;
4871
4872 /*
4873 still required?
4874 if (attack_kern == ATTACK_KERN_STRAIGHT)
4875 {
4876 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4877 }
4878 else if (attack_kern == ATTACK_KERN_COMBI)
4879 {
4880 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4881 }
4882 */
4883 }
4884
4885 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4886
4887 if (data.devices_status == STATUS_CRACKED) break;
4888 if (data.devices_status == STATUS_ABORTED) break;
4889 if (data.devices_status == STATUS_QUIT) break;
4890 if (data.devices_status == STATUS_BYPASS) break;
4891
4892 if (words_fin == 0) break;
4893
4894 device_param->words_done = words_fin;
4895 }
4896
4897 if (attack_mode == ATTACK_MODE_COMBI)
4898 {
4899 fclose (device_param->combs_fp);
4900 }
4901
4902 free (wl_data->buf);
4903 free (wl_data);
4904
4905 fclose (fd);
4906 }
4907
4908 device_param->kernel_accel = 0;
4909 device_param->kernel_loops = 0;
4910
4911 return NULL;
4912 }
4913
4914 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4915 {
4916 if (!device_param)
4917 {
4918 log_error ("ERROR: %s : Invalid argument", __func__);
4919
4920 exit (-1);
4921 }
4922
4923 salt_t *salt_buf = &data.salts_buf[salt_pos];
4924
4925 device_param->kernel_params_buf32[24] = salt_pos;
4926 device_param->kernel_params_buf32[27] = 1;
4927 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4928 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4929 device_param->kernel_params_buf32[30] = 0;
4930 device_param->kernel_params_buf32[31] = 1;
4931
4932 char *dictfile_old = data.dictfile;
4933
4934 const char *weak_hash_check = "weak-hash-check";
4935
4936 data.dictfile = (char *) weak_hash_check;
4937
4938 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4939
4940 data.kernel_rules_buf[0].cmds[0] = 0;
4941
4942 /**
4943 * run the kernel
4944 */
4945
4946 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4947 {
4948 run_kernel (KERN_RUN_1, device_param, 1, false);
4949 }
4950 else
4951 {
4952 run_kernel (KERN_RUN_1, device_param, 1, false);
4953
4954 uint loop_step = 16;
4955
4956 const uint iter = salt_buf->salt_iter;
4957
4958 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4959 {
4960 uint loop_left = iter - loop_pos;
4961
4962 loop_left = MIN (loop_left, loop_step);
4963
4964 device_param->kernel_params_buf32[25] = loop_pos;
4965 device_param->kernel_params_buf32[26] = loop_left;
4966
4967 run_kernel (KERN_RUN_2, device_param, 1, false);
4968 }
4969
4970 run_kernel (KERN_RUN_3, device_param, 1, false);
4971 }
4972
4973 /**
4974 * result
4975 */
4976
4977 check_cracked (device_param, salt_pos);
4978
4979 /**
4980 * cleanup
4981 */
4982
4983 device_param->kernel_params_buf32[24] = 0;
4984 device_param->kernel_params_buf32[25] = 0;
4985 device_param->kernel_params_buf32[26] = 0;
4986 device_param->kernel_params_buf32[27] = 0;
4987 device_param->kernel_params_buf32[28] = 0;
4988 device_param->kernel_params_buf32[29] = 0;
4989 device_param->kernel_params_buf32[30] = 0;
4990 device_param->kernel_params_buf32[31] = 0;
4991
4992 data.dictfile = dictfile_old;
4993
4994 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4995 }
4996
4997 // hlfmt hashcat
4998
4999 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5000 {
5001 if (data.username == 0)
5002 {
5003 *hashbuf_pos = line_buf;
5004 *hashbuf_len = line_len;
5005 }
5006 else
5007 {
5008 char *pos = line_buf;
5009 int len = line_len;
5010
5011 for (int i = 0; i < line_len; i++, pos++, len--)
5012 {
5013 if (line_buf[i] == data.separator)
5014 {
5015 pos++;
5016
5017 len--;
5018
5019 break;
5020 }
5021 }
5022
5023 *hashbuf_pos = pos;
5024 *hashbuf_len = len;
5025 }
5026 }
5027
5028 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5029 {
5030 char *pos = NULL;
5031 int len = 0;
5032
5033 int sep_cnt = 0;
5034
5035 for (int i = 0; i < line_len; i++)
5036 {
5037 if (line_buf[i] == data.separator)
5038 {
5039 sep_cnt++;
5040
5041 continue;
5042 }
5043
5044 if (sep_cnt == 0)
5045 {
5046 if (pos == NULL) pos = line_buf + i;
5047
5048 len++;
5049 }
5050 }
5051
5052 *userbuf_pos = pos;
5053 *userbuf_len = len;
5054 }
5055
5056 // hlfmt pwdump
5057
5058 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5059 {
5060 int sep_cnt = 0;
5061
5062 int sep2_len = 0;
5063 int sep3_len = 0;
5064
5065 for (int i = 0; i < line_len; i++)
5066 {
5067 if (line_buf[i] == ':')
5068 {
5069 sep_cnt++;
5070
5071 continue;
5072 }
5073
5074 if (sep_cnt == 2) sep2_len++;
5075 if (sep_cnt == 3) sep3_len++;
5076 }
5077
5078 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5079
5080 return 0;
5081 }
5082
5083 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5084 {
5085 char *pos = NULL;
5086 int len = 0;
5087
5088 int sep_cnt = 0;
5089
5090 for (int i = 0; i < line_len; i++)
5091 {
5092 if (line_buf[i] == ':')
5093 {
5094 sep_cnt++;
5095
5096 continue;
5097 }
5098
5099 if (data.hash_mode == 1000)
5100 {
5101 if (sep_cnt == 3)
5102 {
5103 if (pos == NULL) pos = line_buf + i;
5104
5105 len++;
5106 }
5107 }
5108 else if (data.hash_mode == 3000)
5109 {
5110 if (sep_cnt == 2)
5111 {
5112 if (pos == NULL) pos = line_buf + i;
5113
5114 len++;
5115 }
5116 }
5117 }
5118
5119 *hashbuf_pos = pos;
5120 *hashbuf_len = len;
5121 }
5122
5123 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5124 {
5125 char *pos = NULL;
5126 int len = 0;
5127
5128 int sep_cnt = 0;
5129
5130 for (int i = 0; i < line_len; i++)
5131 {
5132 if (line_buf[i] == ':')
5133 {
5134 sep_cnt++;
5135
5136 continue;
5137 }
5138
5139 if (sep_cnt == 0)
5140 {
5141 if (pos == NULL) pos = line_buf + i;
5142
5143 len++;
5144 }
5145 }
5146
5147 *userbuf_pos = pos;
5148 *userbuf_len = len;
5149 }
5150
5151 // hlfmt passwd
5152
5153 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5154 {
5155 int sep_cnt = 0;
5156
5157 char sep5_first = 0;
5158 char sep6_first = 0;
5159
5160 for (int i = 0; i < line_len; i++)
5161 {
5162 if (line_buf[i] == ':')
5163 {
5164 sep_cnt++;
5165
5166 continue;
5167 }
5168
5169 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5170 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5171 }
5172
5173 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5174
5175 return 0;
5176 }
5177
5178 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5179 {
5180 char *pos = NULL;
5181 int len = 0;
5182
5183 int sep_cnt = 0;
5184
5185 for (int i = 0; i < line_len; i++)
5186 {
5187 if (line_buf[i] == ':')
5188 {
5189 sep_cnt++;
5190
5191 continue;
5192 }
5193
5194 if (sep_cnt == 1)
5195 {
5196 if (pos == NULL) pos = line_buf + i;
5197
5198 len++;
5199 }
5200 }
5201
5202 *hashbuf_pos = pos;
5203 *hashbuf_len = len;
5204 }
5205
5206 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5207 {
5208 char *pos = NULL;
5209 int len = 0;
5210
5211 int sep_cnt = 0;
5212
5213 for (int i = 0; i < line_len; i++)
5214 {
5215 if (line_buf[i] == ':')
5216 {
5217 sep_cnt++;
5218
5219 continue;
5220 }
5221
5222 if (sep_cnt == 0)
5223 {
5224 if (pos == NULL) pos = line_buf + i;
5225
5226 len++;
5227 }
5228 }
5229
5230 *userbuf_pos = pos;
5231 *userbuf_len = len;
5232 }
5233
5234 // hlfmt shadow
5235
5236 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5237 {
5238 int sep_cnt = 0;
5239
5240 for (int i = 0; i < line_len; i++)
5241 {
5242 if (line_buf[i] == ':') sep_cnt++;
5243 }
5244
5245 if (sep_cnt == 8) return 1;
5246
5247 return 0;
5248 }
5249
5250 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5251 {
5252 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5253 }
5254
5255 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5256 {
5257 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5258 }
5259
5260 // hlfmt main
5261
5262 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5263 {
5264 switch (hashfile_format)
5265 {
5266 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5267 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5268 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5269 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5270 }
5271 }
5272
5273 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5274 {
5275 switch (hashfile_format)
5276 {
5277 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5278 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5279 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5280 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5281 }
5282 }
5283
5284 char *strhlfmt (const uint hashfile_format)
5285 {
5286 switch (hashfile_format)
5287 {
5288 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5289 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5290 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5291 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5292 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5293 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5294 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5295 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5296 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5297 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5298 }
5299
5300 return ((char *) "Unknown");
5301 }
5302
5303 static uint hlfmt_detect (FILE *fp, uint max_check)
5304 {
5305 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5306
5307 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5308 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5309
5310 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5311
5312 uint num_check = 0;
5313
5314 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5315
5316 while (!feof (fp))
5317 {
5318 int line_len = fgetl (fp, line_buf);
5319
5320 if (line_len == 0) continue;
5321
5322 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5323 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5324 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5325
5326 if (num_check == max_check) break;
5327
5328 num_check++;
5329 }
5330
5331 myfree (line_buf);
5332
5333 uint hashlist_format = HLFMT_HASHCAT;
5334
5335 for (int i = 1; i < HLFMTS_CNT; i++)
5336 {
5337 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5338
5339 hashlist_format = i;
5340 }
5341
5342 free (formats_cnt);
5343
5344 return hashlist_format;
5345 }
5346
5347 /**
5348 * some further helper function
5349 */
5350
5351 // wrapper around mymalloc for ADL
5352
5353 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5354 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5355 {
5356 return mymalloc (iSize);
5357 }
5358 #endif
5359
5360 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)
5361 {
5362 u64 collisions = 0;
5363
5364 const uint dgst_pos0 = data.dgst_pos0;
5365 const uint dgst_pos1 = data.dgst_pos1;
5366 const uint dgst_pos2 = data.dgst_pos2;
5367 const uint dgst_pos3 = data.dgst_pos3;
5368
5369 memset (bitmap_a, 0, bitmap_size);
5370 memset (bitmap_b, 0, bitmap_size);
5371 memset (bitmap_c, 0, bitmap_size);
5372 memset (bitmap_d, 0, bitmap_size);
5373
5374 for (uint i = 0; i < digests_cnt; i++)
5375 {
5376 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5377
5378 uint *digest_ptr = (uint *) digests_buf_ptr;
5379
5380 digests_buf_ptr += dgst_size;
5381
5382 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5383 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5384 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5385 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5386
5387 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5388 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5389 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5390 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5391
5392 if (bitmap_a[idx0] & val0) collisions++;
5393 if (bitmap_b[idx1] & val1) collisions++;
5394 if (bitmap_c[idx2] & val2) collisions++;
5395 if (bitmap_d[idx3] & val3) collisions++;
5396
5397 bitmap_a[idx0] |= val0;
5398 bitmap_b[idx1] |= val1;
5399 bitmap_c[idx2] |= val2;
5400 bitmap_d[idx3] |= val3;
5401
5402 if (collisions >= collisions_max) return 0x7fffffff;
5403 }
5404
5405 return collisions;
5406 }
5407
5408 /**
5409 * main
5410 */
5411
5412 #ifdef _WIN
5413 void SetConsoleWindowSize (const int x)
5414 {
5415 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5416
5417 if (h == INVALID_HANDLE_VALUE) return;
5418
5419 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5420
5421 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5422
5423 SMALL_RECT *sr = &bufferInfo.srWindow;
5424
5425 sr->Right = MAX (sr->Right, x - 1);
5426
5427 COORD co;
5428
5429 co.X = sr->Right + 1;
5430 co.Y = sr->Bottom + 1;
5431
5432 if (!SetConsoleScreenBufferSize (h, co)) return;
5433
5434 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5435 }
5436 #endif
5437
5438 int main (int argc, char **argv)
5439 {
5440 #ifdef _WIN
5441 SetConsoleWindowSize (132);
5442 #endif
5443
5444 /**
5445 * To help users a bit
5446 */
5447
5448 char *compute = getenv ("COMPUTE");
5449
5450 if (compute)
5451 {
5452 static char display[100];
5453
5454 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5455
5456 putenv (display);
5457 }
5458 else
5459 {
5460 if (getenv ("DISPLAY") == NULL)
5461 putenv ((char *) "DISPLAY=:0");
5462 }
5463
5464 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5465 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5466
5467 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5468 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5469
5470 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5471 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5472
5473 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5474 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5475
5476 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5477 putenv ((char *) "POCL_KERNEL_CACHE=0");
5478
5479 umask (077);
5480
5481 /**
5482 * Real init
5483 */
5484
5485 memset (&data, 0, sizeof (hc_global_data_t));
5486
5487 time_t proc_start;
5488
5489 time (&proc_start);
5490
5491 data.proc_start = proc_start;
5492
5493 int myargc = argc;
5494 char **myargv = argv;
5495
5496 hc_thread_mutex_init (mux_dispatcher);
5497 hc_thread_mutex_init (mux_counter);
5498 hc_thread_mutex_init (mux_display);
5499 hc_thread_mutex_init (mux_adl);
5500
5501 /**
5502 * commandline parameters
5503 */
5504
5505 uint usage = USAGE;
5506 uint version = VERSION;
5507 uint quiet = QUIET;
5508 uint benchmark = BENCHMARK;
5509 uint show = SHOW;
5510 uint left = LEFT;
5511 uint username = USERNAME;
5512 uint remove = REMOVE;
5513 uint remove_timer = REMOVE_TIMER;
5514 u64 skip = SKIP;
5515 u64 limit = LIMIT;
5516 uint keyspace = KEYSPACE;
5517 uint potfile_disable = POTFILE_DISABLE;
5518 char *potfile_path = NULL;
5519 uint debug_mode = DEBUG_MODE;
5520 char *debug_file = NULL;
5521 char *induction_dir = NULL;
5522 char *outfile_check_dir = NULL;
5523 uint force = FORCE;
5524 uint runtime = RUNTIME;
5525 uint hash_mode = HASH_MODE;
5526 uint attack_mode = ATTACK_MODE;
5527 uint markov_disable = MARKOV_DISABLE;
5528 uint markov_classic = MARKOV_CLASSIC;
5529 uint markov_threshold = MARKOV_THRESHOLD;
5530 char *markov_hcstat = NULL;
5531 char *outfile = NULL;
5532 uint outfile_format = OUTFILE_FORMAT;
5533 uint outfile_autohex = OUTFILE_AUTOHEX;
5534 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5535 uint restore = RESTORE;
5536 uint restore_timer = RESTORE_TIMER;
5537 uint restore_disable = RESTORE_DISABLE;
5538 uint status = STATUS;
5539 uint status_timer = STATUS_TIMER;
5540 uint machine_readable = MACHINE_READABLE;
5541 uint loopback = LOOPBACK;
5542 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5543 char *session = NULL;
5544 uint hex_charset = HEX_CHARSET;
5545 uint hex_salt = HEX_SALT;
5546 uint hex_wordlist = HEX_WORDLIST;
5547 uint rp_gen = RP_GEN;
5548 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5549 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5550 uint rp_gen_seed = RP_GEN_SEED;
5551 char *rule_buf_l = (char *) RULE_BUF_L;
5552 char *rule_buf_r = (char *) RULE_BUF_R;
5553 uint increment = INCREMENT;
5554 uint increment_min = INCREMENT_MIN;
5555 uint increment_max = INCREMENT_MAX;
5556 char *cpu_affinity = NULL;
5557 OCL_PTR *ocl = NULL;
5558 char *opencl_devices = NULL;
5559 char *opencl_platforms = NULL;
5560 char *opencl_device_types = NULL;
5561 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5562 char *truecrypt_keyfiles = NULL;
5563 char *veracrypt_keyfiles = NULL;
5564 uint veracrypt_pim = 0;
5565 uint workload_profile = WORKLOAD_PROFILE;
5566 uint kernel_accel = KERNEL_ACCEL;
5567 uint kernel_loops = KERNEL_LOOPS;
5568 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5569 #ifdef HAVE_HWMON
5570 uint gpu_temp_abort = GPU_TEMP_ABORT;
5571 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5572 #ifdef HAVE_ADL
5573 uint powertune_enable = POWERTUNE_ENABLE;
5574 #endif
5575 #endif
5576 uint logfile_disable = LOGFILE_DISABLE;
5577 uint segment_size = SEGMENT_SIZE;
5578 uint scrypt_tmto = SCRYPT_TMTO;
5579 char separator = SEPARATOR;
5580 uint bitmap_min = BITMAP_MIN;
5581 uint bitmap_max = BITMAP_MAX;
5582 char *custom_charset_1 = NULL;
5583 char *custom_charset_2 = NULL;
5584 char *custom_charset_3 = NULL;
5585 char *custom_charset_4 = NULL;
5586
5587 #define IDX_HELP 'h'
5588 #define IDX_VERSION 'V'
5589 #define IDX_VERSION_LOWER 'v'
5590 #define IDX_QUIET 0xff02
5591 #define IDX_SHOW 0xff03
5592 #define IDX_LEFT 0xff04
5593 #define IDX_REMOVE 0xff05
5594 #define IDX_REMOVE_TIMER 0xff37
5595 #define IDX_SKIP 's'
5596 #define IDX_LIMIT 'l'
5597 #define IDX_KEYSPACE 0xff35
5598 #define IDX_POTFILE_DISABLE 0xff06
5599 #define IDX_POTFILE_PATH 0xffe0
5600 #define IDX_DEBUG_MODE 0xff43
5601 #define IDX_DEBUG_FILE 0xff44
5602 #define IDX_INDUCTION_DIR 0xff46
5603 #define IDX_OUTFILE_CHECK_DIR 0xff47
5604 #define IDX_USERNAME 0xff07
5605 #define IDX_FORCE 0xff08
5606 #define IDX_RUNTIME 0xff09
5607 #define IDX_BENCHMARK 'b'
5608 #define IDX_HASH_MODE 'm'
5609 #define IDX_ATTACK_MODE 'a'
5610 #define IDX_RP_FILE 'r'
5611 #define IDX_RP_GEN 'g'
5612 #define IDX_RP_GEN_FUNC_MIN 0xff10
5613 #define IDX_RP_GEN_FUNC_MAX 0xff11
5614 #define IDX_RP_GEN_SEED 0xff34
5615 #define IDX_RULE_BUF_L 'j'
5616 #define IDX_RULE_BUF_R 'k'
5617 #define IDX_INCREMENT 'i'
5618 #define IDX_INCREMENT_MIN 0xff12
5619 #define IDX_INCREMENT_MAX 0xff13
5620 #define IDX_OUTFILE 'o'
5621 #define IDX_OUTFILE_FORMAT 0xff14
5622 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5623 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5624 #define IDX_RESTORE 0xff15
5625 #define IDX_RESTORE_DISABLE 0xff27
5626 #define IDX_STATUS 0xff17
5627 #define IDX_STATUS_TIMER 0xff18
5628 #define IDX_MACHINE_READABLE 0xff50
5629 #define IDX_LOOPBACK 0xff38
5630 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5631 #define IDX_SESSION 0xff19
5632 #define IDX_HEX_CHARSET 0xff20
5633 #define IDX_HEX_SALT 0xff21
5634 #define IDX_HEX_WORDLIST 0xff40
5635 #define IDX_MARKOV_DISABLE 0xff22
5636 #define IDX_MARKOV_CLASSIC 0xff23
5637 #define IDX_MARKOV_THRESHOLD 't'
5638 #define IDX_MARKOV_HCSTAT 0xff24
5639 #define IDX_CPU_AFFINITY 0xff25
5640 #define IDX_OPENCL_DEVICES 'd'
5641 #define IDX_OPENCL_PLATFORMS 0xff72
5642 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5643 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5644 #define IDX_WORKLOAD_PROFILE 'w'
5645 #define IDX_KERNEL_ACCEL 'n'
5646 #define IDX_KERNEL_LOOPS 'u'
5647 #define IDX_GPU_TEMP_DISABLE 0xff29
5648 #define IDX_GPU_TEMP_ABORT 0xff30
5649 #define IDX_GPU_TEMP_RETAIN 0xff31
5650 #define IDX_POWERTUNE_ENABLE 0xff41
5651 #define IDX_LOGFILE_DISABLE 0xff51
5652 #define IDX_TRUECRYPT_KEYFILES 0xff52
5653 #define IDX_VERACRYPT_KEYFILES 0xff53
5654 #define IDX_VERACRYPT_PIM 0xff54
5655 #define IDX_SCRYPT_TMTO 0xff61
5656 #define IDX_SEGMENT_SIZE 'c'
5657 #define IDX_SEPARATOR 'p'
5658 #define IDX_BITMAP_MIN 0xff70
5659 #define IDX_BITMAP_MAX 0xff71
5660 #define IDX_CUSTOM_CHARSET_1 '1'
5661 #define IDX_CUSTOM_CHARSET_2 '2'
5662 #define IDX_CUSTOM_CHARSET_3 '3'
5663 #define IDX_CUSTOM_CHARSET_4 '4'
5664
5665 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5666
5667 struct option long_options[] =
5668 {
5669 {"help", no_argument, 0, IDX_HELP},
5670 {"version", no_argument, 0, IDX_VERSION},
5671 {"quiet", no_argument, 0, IDX_QUIET},
5672 {"show", no_argument, 0, IDX_SHOW},
5673 {"left", no_argument, 0, IDX_LEFT},
5674 {"username", no_argument, 0, IDX_USERNAME},
5675 {"remove", no_argument, 0, IDX_REMOVE},
5676 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5677 {"skip", required_argument, 0, IDX_SKIP},
5678 {"limit", required_argument, 0, IDX_LIMIT},
5679 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5680 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5681 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5682 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5683 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5684 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5685 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5686 {"force", no_argument, 0, IDX_FORCE},
5687 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5688 {"restore", no_argument, 0, IDX_RESTORE},
5689 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5690 {"status", no_argument, 0, IDX_STATUS},
5691 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5692 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5693 {"loopback", no_argument, 0, IDX_LOOPBACK},
5694 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5695 {"session", required_argument, 0, IDX_SESSION},
5696 {"runtime", required_argument, 0, IDX_RUNTIME},
5697 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5698 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5699 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5700 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5701 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5702 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5703 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5704 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5705 {"rules-file", required_argument, 0, IDX_RP_FILE},
5706 {"outfile", required_argument, 0, IDX_OUTFILE},
5707 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5708 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5709 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5710 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5711 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5712 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5713 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5714 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5715 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5716 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5717 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5718 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5719 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5720 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5721 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5722 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5723 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5724 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5725 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5726 #ifdef HAVE_HWMON
5727 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5728 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5729 #ifdef HAVE_ADL
5730 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5731 #endif
5732 #endif // HAVE_HWMON
5733 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5734 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5735 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5736 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5737 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5738 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5739 {"seperator", required_argument, 0, IDX_SEPARATOR},
5740 {"separator", required_argument, 0, IDX_SEPARATOR},
5741 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5742 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5743 {"increment", no_argument, 0, IDX_INCREMENT},
5744 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5745 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5746 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5747 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5748 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5749 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5750 {0, 0, 0, 0}
5751 };
5752
5753 uint rp_files_cnt = 0;
5754
5755 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5756
5757 int option_index = 0;
5758 int c = -1;
5759
5760 optind = 1;
5761 optopt = 0;
5762
5763 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5764 {
5765 switch (c)
5766 {
5767 case IDX_HELP: usage = 1; break;
5768 case IDX_VERSION:
5769 case IDX_VERSION_LOWER: version = 1; break;
5770 case IDX_RESTORE: restore = 1; break;
5771 case IDX_SESSION: session = optarg; break;
5772 case IDX_SHOW: show = 1; break;
5773 case IDX_LEFT: left = 1; break;
5774 case '?': return (-1);
5775 }
5776 }
5777
5778 if (optopt != 0)
5779 {
5780 log_error ("ERROR: Invalid argument specified");
5781
5782 return (-1);
5783 }
5784
5785 /**
5786 * exit functions
5787 */
5788
5789 if (version)
5790 {
5791 log_info ("%s", VERSION_TAG);
5792
5793 return (0);
5794 }
5795
5796 if (usage)
5797 {
5798 usage_big_print (PROGNAME);
5799
5800 return (0);
5801 }
5802
5803 /**
5804 * session needs to be set, always!
5805 */
5806
5807 if (session == NULL) session = (char *) PROGNAME;
5808
5809 /**
5810 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5811 */
5812
5813 char *exec_path = get_exec_path ();
5814
5815 #ifdef LINUX
5816
5817 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5818 char *resolved_exec_path = realpath (exec_path, NULL);
5819
5820 char *install_dir = get_install_dir (resolved_exec_path);
5821 char *profile_dir = NULL;
5822 char *session_dir = NULL;
5823 char *shared_dir = NULL;
5824
5825 if (strcmp (install_dir, resolved_install_folder) == 0)
5826 {
5827 struct passwd *pw = getpwuid (getuid ());
5828
5829 const char *homedir = pw->pw_dir;
5830
5831 profile_dir = get_profile_dir (homedir);
5832 session_dir = get_session_dir (profile_dir);
5833 shared_dir = strdup (SHARED_FOLDER);
5834
5835 mkdir (profile_dir, 0700);
5836 mkdir (session_dir, 0700);
5837 }
5838 else
5839 {
5840 profile_dir = install_dir;
5841 session_dir = install_dir;
5842 shared_dir = install_dir;
5843 }
5844
5845 myfree (resolved_install_folder);
5846 myfree (resolved_exec_path);
5847
5848 #else
5849
5850 char *install_dir = get_install_dir (exec_path);
5851 char *profile_dir = install_dir;
5852 char *session_dir = install_dir;
5853 char *shared_dir = install_dir;
5854
5855 #endif
5856
5857 data.install_dir = install_dir;
5858 data.profile_dir = profile_dir;
5859 data.session_dir = session_dir;
5860 data.shared_dir = shared_dir;
5861
5862 myfree (exec_path);
5863
5864 /**
5865 * kernel cache, we need to make sure folder exist
5866 */
5867
5868 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5869
5870 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5871
5872 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5873
5874 mkdir (kernels_folder, 0700);
5875
5876 myfree (kernels_folder);
5877
5878 /**
5879 * session
5880 */
5881
5882 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5883
5884 data.session = session;
5885
5886 char *eff_restore_file = (char *) mymalloc (session_size);
5887 char *new_restore_file = (char *) mymalloc (session_size);
5888
5889 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5890 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5891
5892 data.eff_restore_file = eff_restore_file;
5893 data.new_restore_file = new_restore_file;
5894
5895 if (((show == 1) || (left == 1)) && (restore == 1))
5896 {
5897 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5898 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5899
5900 return (-1);
5901 }
5902
5903 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5904 if ((show == 1) || (left == 1))
5905 {
5906 restore_disable = 1;
5907
5908 restore = 0;
5909 }
5910
5911 data.restore_disable = restore_disable;
5912
5913 restore_data_t *rd = init_restore (argc, argv);
5914
5915 data.rd = rd;
5916
5917 /**
5918 * restore file
5919 */
5920
5921 if (restore == 1)
5922 {
5923 read_restore (eff_restore_file, rd);
5924
5925 if (rd->version_bin < RESTORE_MIN)
5926 {
5927 log_error ("ERROR: Incompatible restore-file version");
5928
5929 return (-1);
5930 }
5931
5932 myargc = rd->argc;
5933 myargv = rd->argv;
5934
5935 #ifdef _POSIX
5936 rd->pid = getpid ();
5937 #elif _WIN
5938 rd->pid = GetCurrentProcessId ();
5939 #endif
5940 }
5941
5942 uint hash_mode_chgd = 0;
5943 uint runtime_chgd = 0;
5944 uint kernel_loops_chgd = 0;
5945 uint kernel_accel_chgd = 0;
5946 uint attack_mode_chgd = 0;
5947 uint outfile_format_chgd = 0;
5948 uint rp_gen_seed_chgd = 0;
5949 uint remove_timer_chgd = 0;
5950 uint increment_min_chgd = 0;
5951 uint increment_max_chgd = 0;
5952 uint workload_profile_chgd = 0;
5953 uint opencl_vector_width_chgd = 0;
5954
5955 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5956 uint gpu_temp_retain_chgd = 0;
5957 uint gpu_temp_abort_chgd = 0;
5958 #endif
5959
5960 optind = 1;
5961 optopt = 0;
5962 option_index = 0;
5963
5964 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5965 {
5966 switch (c)
5967 {
5968 //case IDX_HELP: usage = 1; break;
5969 //case IDX_VERSION: version = 1; break;
5970 //case IDX_RESTORE: restore = 1; break;
5971 case IDX_QUIET: quiet = 1; break;
5972 //case IDX_SHOW: show = 1; break;
5973 case IDX_SHOW: break;
5974 //case IDX_LEFT: left = 1; break;
5975 case IDX_LEFT: break;
5976 case IDX_USERNAME: username = 1; break;
5977 case IDX_REMOVE: remove = 1; break;
5978 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5979 remove_timer_chgd = 1; break;
5980 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5981 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5982 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5983 case IDX_DEBUG_FILE: debug_file = optarg; break;
5984 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5985 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5986 case IDX_FORCE: force = 1; break;
5987 case IDX_SKIP: skip = atoll (optarg); break;
5988 case IDX_LIMIT: limit = atoll (optarg); break;
5989 case IDX_KEYSPACE: keyspace = 1; break;
5990 case IDX_BENCHMARK: benchmark = 1; break;
5991 case IDX_RESTORE: break;
5992 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5993 case IDX_STATUS: status = 1; break;
5994 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5995 case IDX_MACHINE_READABLE: machine_readable = 1; break;
5996 case IDX_LOOPBACK: loopback = 1; break;
5997 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
5998 //case IDX_SESSION: session = optarg; break;
5999 case IDX_SESSION: break;
6000 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6001 hash_mode_chgd = 1; break;
6002 case IDX_RUNTIME: runtime = atoi (optarg);
6003 runtime_chgd = 1; break;
6004 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6005 attack_mode_chgd = 1; break;
6006 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6007 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6008 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6009 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6010 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6011 rp_gen_seed_chgd = 1; break;
6012 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6013 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6014 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6015 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6016 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6017 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6018 case IDX_OUTFILE: outfile = optarg; break;
6019 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6020 outfile_format_chgd = 1; break;
6021 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6022 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6023 case IDX_HEX_CHARSET: hex_charset = 1; break;
6024 case IDX_HEX_SALT: hex_salt = 1; break;
6025 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6026 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6027 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6028 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6029 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6030 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6031 opencl_vector_width_chgd = 1; break;
6032 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6033 workload_profile_chgd = 1; break;
6034 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6035 kernel_accel_chgd = 1; break;
6036 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6037 kernel_loops_chgd = 1; break;
6038 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6039 #ifdef HAVE_HWMON
6040 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
6041 #ifdef HAVE_ADL
6042 gpu_temp_abort_chgd = 1;
6043 #endif
6044 break;
6045 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
6046 #ifdef HAVE_ADL
6047 gpu_temp_retain_chgd = 1;
6048 #endif
6049 break;
6050 #ifdef HAVE_ADL
6051 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6052 #endif
6053 #endif // HAVE_HWMON
6054 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6055 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6056 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6057 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6058 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6059 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6060 case IDX_SEPARATOR: separator = optarg[0]; break;
6061 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6062 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6063 case IDX_INCREMENT: increment = 1; break;
6064 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6065 increment_min_chgd = 1; break;
6066 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6067 increment_max_chgd = 1; break;
6068 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6069 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6070 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6071 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6072
6073 default:
6074 log_error ("ERROR: Invalid argument specified");
6075 return (-1);
6076 }
6077 }
6078
6079 if (optopt != 0)
6080 {
6081 log_error ("ERROR: Invalid argument specified");
6082
6083 return (-1);
6084 }
6085
6086 /**
6087 * Inform user things getting started,
6088 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6089 * - we do not need to check algorithm_pos
6090 */
6091
6092 if (quiet == 0)
6093 {
6094 if (benchmark == 1)
6095 {
6096 if (machine_readable == 0)
6097 {
6098 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6099 log_info ("");
6100 }
6101 else
6102 {
6103 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6104 }
6105 }
6106 else if (restore == 1)
6107 {
6108 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6109 log_info ("");
6110 }
6111 else
6112 {
6113 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6114 log_info ("");
6115 }
6116 }
6117
6118 /**
6119 * sanity check
6120 */
6121
6122 if (attack_mode > 7)
6123 {
6124 log_error ("ERROR: Invalid attack-mode specified");
6125
6126 return (-1);
6127 }
6128
6129 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6130 {
6131 log_error ("ERROR: Invalid runtime specified");
6132
6133 return (-1);
6134 }
6135
6136 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
6137 {
6138 log_error ("ERROR: Invalid hash-type specified");
6139
6140 return (-1);
6141 }
6142
6143 // renamed hash modes
6144
6145 if (hash_mode_chgd)
6146 {
6147 int n = -1;
6148
6149 switch (hash_mode)
6150 {
6151 case 123: n = 124;
6152 break;
6153 }
6154
6155 if (n >= 0)
6156 {
6157 log_error ("Old -m specified, use -m %d instead", n);
6158
6159 return (-1);
6160 }
6161 }
6162
6163 if (username == 1)
6164 {
6165 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6166 {
6167 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6168
6169 return (-1);
6170 }
6171 }
6172
6173 if (outfile_format > 16)
6174 {
6175 log_error ("ERROR: Invalid outfile-format specified");
6176
6177 return (-1);
6178 }
6179
6180 if (left == 1)
6181 {
6182 if (outfile_format_chgd == 1)
6183 {
6184 if (outfile_format > 1)
6185 {
6186 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6187
6188 return (-1);
6189 }
6190 }
6191 else
6192 {
6193 outfile_format = OUTFILE_FMT_HASH;
6194 }
6195 }
6196
6197 if (show == 1)
6198 {
6199 if (outfile_format_chgd == 1)
6200 {
6201 if ((outfile_format > 7) && (outfile_format < 16))
6202 {
6203 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6204
6205 return (-1);
6206 }
6207 }
6208 }
6209
6210 if (increment_min < INCREMENT_MIN)
6211 {
6212 log_error ("ERROR: Invalid increment-min specified");
6213
6214 return (-1);
6215 }
6216
6217 if (increment_max > INCREMENT_MAX)
6218 {
6219 log_error ("ERROR: Invalid increment-max specified");
6220
6221 return (-1);
6222 }
6223
6224 if (increment_min > increment_max)
6225 {
6226 log_error ("ERROR: Invalid increment-min specified");
6227
6228 return (-1);
6229 }
6230
6231 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6232 {
6233 log_error ("ERROR: increment is not allowed in attack-mode 0");
6234
6235 return (-1);
6236 }
6237
6238 if ((increment == 0) && (increment_min_chgd == 1))
6239 {
6240 log_error ("ERROR: increment-min is only supported together with increment switch");
6241
6242 return (-1);
6243 }
6244
6245 if ((increment == 0) && (increment_max_chgd == 1))
6246 {
6247 log_error ("ERROR: increment-max is only supported together with increment switch");
6248
6249 return (-1);
6250 }
6251
6252 if (rp_files_cnt && rp_gen)
6253 {
6254 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6255
6256 return (-1);
6257 }
6258
6259 if (rp_files_cnt || rp_gen)
6260 {
6261 if (attack_mode != ATTACK_MODE_STRAIGHT)
6262 {
6263 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6264
6265 return (-1);
6266 }
6267 }
6268
6269 if (rp_gen_func_min > rp_gen_func_max)
6270 {
6271 log_error ("ERROR: Invalid rp-gen-func-min specified");
6272
6273 return (-1);
6274 }
6275
6276 if (kernel_accel_chgd == 1)
6277 {
6278 if (force == 0)
6279 {
6280 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6281 log_info ("Please consider using the option -w instead");
6282 log_info ("You can use --force to override this but do not post error reports if you do so");
6283 log_info ("");
6284
6285 return (-1);
6286 }
6287
6288 if (kernel_accel < 1)
6289 {
6290 log_error ("ERROR: Invalid kernel-accel specified");
6291
6292 return (-1);
6293 }
6294
6295 if (kernel_accel > 1024)
6296 {
6297 log_error ("ERROR: Invalid kernel-accel specified");
6298
6299 return (-1);
6300 }
6301 }
6302
6303 if (kernel_loops_chgd == 1)
6304 {
6305 if (force == 0)
6306 {
6307 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6308 log_info ("Please consider using the option -w instead");
6309 log_info ("You can use --force to override this but do not post error reports if you do so");
6310 log_info ("");
6311
6312 return (-1);
6313 }
6314
6315 if (kernel_loops < 1)
6316 {
6317 log_error ("ERROR: Invalid kernel-loops specified");
6318
6319 return (-1);
6320 }
6321
6322 if (kernel_loops > 1024)
6323 {
6324 log_error ("ERROR: Invalid kernel-loops specified");
6325
6326 return (-1);
6327 }
6328 }
6329
6330 if ((workload_profile < 1) || (workload_profile > 4))
6331 {
6332 log_error ("ERROR: workload-profile %i not available", workload_profile);
6333
6334 return (-1);
6335 }
6336
6337 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6338 {
6339 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6340
6341 return (-1);
6342 }
6343
6344 if (show == 1 || left == 1)
6345 {
6346 attack_mode = ATTACK_MODE_NONE;
6347
6348 if (remove == 1)
6349 {
6350 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6351
6352 return (-1);
6353 }
6354
6355 if (potfile_disable == 1)
6356 {
6357 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6358
6359 return (-1);
6360 }
6361 }
6362
6363 uint attack_kern = ATTACK_KERN_NONE;
6364
6365 switch (attack_mode)
6366 {
6367 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6368 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6369 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6370 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6371 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6372 }
6373
6374 if (benchmark == 0)
6375 {
6376 if (keyspace == 1)
6377 {
6378 int num_additional_params = 1;
6379
6380 if (attack_kern == ATTACK_KERN_COMBI)
6381 {
6382 num_additional_params = 2;
6383 }
6384
6385 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6386
6387 if (keyspace_wordlist_specified == 0) optind--;
6388 }
6389
6390 if (attack_kern == ATTACK_KERN_NONE)
6391 {
6392 if ((optind + 1) != myargc)
6393 {
6394 usage_mini_print (myargv[0]);
6395
6396 return (-1);
6397 }
6398 }
6399 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6400 {
6401 if ((optind + 1) > myargc)
6402 {
6403 usage_mini_print (myargv[0]);
6404
6405 return (-1);
6406 }
6407 }
6408 else if (attack_kern == ATTACK_KERN_COMBI)
6409 {
6410 if ((optind + 3) != myargc)
6411 {
6412 usage_mini_print (myargv[0]);
6413
6414 return (-1);
6415 }
6416 }
6417 else if (attack_kern == ATTACK_KERN_BF)
6418 {
6419 if ((optind + 1) > myargc)
6420 {
6421 usage_mini_print (myargv[0]);
6422
6423 return (-1);
6424 }
6425 }
6426 else
6427 {
6428 usage_mini_print (myargv[0]);
6429
6430 return (-1);
6431 }
6432 }
6433 else
6434 {
6435 if (myargv[optind] != 0)
6436 {
6437 log_error ("ERROR: Invalid argument for benchmark mode specified");
6438
6439 return (-1);
6440 }
6441
6442 if (attack_mode_chgd == 1)
6443 {
6444 if (attack_mode != ATTACK_MODE_BF)
6445 {
6446 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6447
6448 return (-1);
6449 }
6450 }
6451 }
6452
6453 if (skip != 0 && limit != 0)
6454 {
6455 limit += skip;
6456 }
6457
6458 if (keyspace == 1)
6459 {
6460 if (show == 1)
6461 {
6462 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6463
6464 return (-1);
6465 }
6466 else if (left == 1)
6467 {
6468 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6469
6470 return (-1);
6471 }
6472
6473 potfile_disable = 1;
6474
6475 restore_disable = 1;
6476
6477 restore = 0;
6478
6479 weak_hash_threshold = 0;
6480
6481 quiet = 1;
6482 }
6483
6484 if (remove_timer_chgd == 1)
6485 {
6486 if (remove == 0)
6487 {
6488 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6489
6490 return (-1);
6491 }
6492
6493 if (remove_timer < 1)
6494 {
6495 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6496
6497 return (-1);
6498 }
6499 }
6500
6501 if (loopback == 1)
6502 {
6503 if (attack_mode == ATTACK_MODE_STRAIGHT)
6504 {
6505 if ((rp_files_cnt == 0) && (rp_gen == 0))
6506 {
6507 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6508
6509 return (-1);
6510 }
6511 }
6512 else
6513 {
6514 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6515
6516 return (-1);
6517 }
6518 }
6519
6520 if (debug_mode > 0)
6521 {
6522 if (attack_mode != ATTACK_MODE_STRAIGHT)
6523 {
6524 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6525
6526 return (-1);
6527 }
6528
6529 if ((rp_files_cnt == 0) && (rp_gen == 0))
6530 {
6531 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6532
6533 return (-1);
6534 }
6535 }
6536
6537 if (debug_mode > 4)
6538 {
6539 log_error ("ERROR: Invalid debug-mode specified");
6540
6541 return (-1);
6542 }
6543
6544 if (debug_file != NULL)
6545 {
6546 if (debug_mode < 1)
6547 {
6548 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6549
6550 return (-1);
6551 }
6552 }
6553
6554 if (induction_dir != NULL)
6555 {
6556 if (attack_mode == ATTACK_MODE_BF)
6557 {
6558 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6559
6560 return (-1);
6561 }
6562 }
6563
6564 if (attack_mode != ATTACK_MODE_STRAIGHT)
6565 {
6566 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6567 {
6568 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6569
6570 return (-1);
6571 }
6572
6573 weak_hash_threshold = 0;
6574 }
6575
6576 /**
6577 * induction directory
6578 */
6579
6580 char *induction_directory = NULL;
6581
6582 if (attack_mode != ATTACK_MODE_BF)
6583 {
6584 if (induction_dir == NULL)
6585 {
6586 induction_directory = (char *) mymalloc (session_size);
6587
6588 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6589
6590 // create induction folder if it does not already exist
6591
6592 if (keyspace == 0)
6593 {
6594 if (rmdir (induction_directory) == -1)
6595 {
6596 if (errno == ENOENT)
6597 {
6598 // good, we can ignore
6599 }
6600 else if (errno == ENOTEMPTY)
6601 {
6602 char *induction_directory_mv = (char *) mymalloc (session_size);
6603
6604 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6605
6606 if (rename (induction_directory, induction_directory_mv) != 0)
6607 {
6608 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6609
6610 return (-1);
6611 }
6612 }
6613 else
6614 {
6615 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6616
6617 return (-1);
6618 }
6619 }
6620
6621 if (mkdir (induction_directory, 0700) == -1)
6622 {
6623 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6624
6625 return (-1);
6626 }
6627 }
6628 }
6629 else
6630 {
6631 induction_directory = induction_dir;
6632 }
6633 }
6634
6635 data.induction_directory = induction_directory;
6636
6637 /**
6638 * loopback
6639 */
6640
6641 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6642
6643 char *loopback_file = (char *) mymalloc (loopback_size);
6644
6645 /**
6646 * tuning db
6647 */
6648
6649 char tuning_db_file[256] = { 0 };
6650
6651 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6652
6653 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6654
6655 /**
6656 * outfile-check directory
6657 */
6658
6659 char *outfile_check_directory = NULL;
6660
6661 if (outfile_check_dir == NULL)
6662 {
6663 outfile_check_directory = (char *) mymalloc (session_size);
6664
6665 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6666 }
6667 else
6668 {
6669 outfile_check_directory = outfile_check_dir;
6670 }
6671
6672 data.outfile_check_directory = outfile_check_directory;
6673
6674 if (keyspace == 0)
6675 {
6676 struct stat outfile_check_stat;
6677
6678 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6679 {
6680 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6681
6682 if (is_dir == 0)
6683 {
6684 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6685
6686 return (-1);
6687 }
6688 }
6689 else if (outfile_check_dir == NULL)
6690 {
6691 if (mkdir (outfile_check_directory, 0700) == -1)
6692 {
6693 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6694
6695 return (-1);
6696 }
6697 }
6698 }
6699
6700 /**
6701 * special other stuff
6702 */
6703
6704 if (hash_mode == 9710)
6705 {
6706 outfile_format = 5;
6707 outfile_format_chgd = 1;
6708 }
6709
6710 if (hash_mode == 9810)
6711 {
6712 outfile_format = 5;
6713 outfile_format_chgd = 1;
6714 }
6715
6716 if (hash_mode == 10410)
6717 {
6718 outfile_format = 5;
6719 outfile_format_chgd = 1;
6720 }
6721
6722 /**
6723 * store stuff
6724 */
6725
6726 data.hash_mode = hash_mode;
6727 data.restore = restore;
6728 data.restore_timer = restore_timer;
6729 data.restore_disable = restore_disable;
6730 data.status = status;
6731 data.status_timer = status_timer;
6732 data.machine_readable = machine_readable;
6733 data.loopback = loopback;
6734 data.runtime = runtime;
6735 data.remove = remove;
6736 data.remove_timer = remove_timer;
6737 data.debug_mode = debug_mode;
6738 data.debug_file = debug_file;
6739 data.username = username;
6740 data.quiet = quiet;
6741 data.outfile = outfile;
6742 data.outfile_format = outfile_format;
6743 data.outfile_autohex = outfile_autohex;
6744 data.hex_charset = hex_charset;
6745 data.hex_salt = hex_salt;
6746 data.hex_wordlist = hex_wordlist;
6747 data.separator = separator;
6748 data.rp_files = rp_files;
6749 data.rp_files_cnt = rp_files_cnt;
6750 data.rp_gen = rp_gen;
6751 data.rp_gen_seed = rp_gen_seed;
6752 data.force = force;
6753 data.benchmark = benchmark;
6754 data.skip = skip;
6755 data.limit = limit;
6756 #ifdef HAVE_HWMON
6757 #ifdef HAVE_ADL
6758 data.powertune_enable = powertune_enable;
6759 #endif
6760 #endif
6761 data.logfile_disable = logfile_disable;
6762 data.truecrypt_keyfiles = truecrypt_keyfiles;
6763 data.veracrypt_keyfiles = veracrypt_keyfiles;
6764 data.veracrypt_pim = veracrypt_pim;
6765 data.scrypt_tmto = scrypt_tmto;
6766 data.workload_profile = workload_profile;
6767
6768 /**
6769 * cpu affinity
6770 */
6771
6772 if (cpu_affinity)
6773 {
6774 set_cpu_affinity (cpu_affinity);
6775 }
6776
6777 if (rp_gen_seed_chgd == 0)
6778 {
6779 srand (proc_start);
6780 }
6781 else
6782 {
6783 srand (rp_gen_seed);
6784 }
6785
6786 /**
6787 * logfile init
6788 */
6789
6790 if (logfile_disable == 0)
6791 {
6792 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6793
6794 char *logfile = (char *) mymalloc (logfile_size);
6795
6796 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6797
6798 data.logfile = logfile;
6799
6800 char *topid = logfile_generate_topid ();
6801
6802 data.topid = topid;
6803 }
6804
6805 // logfile_append() checks for logfile_disable internally to make it easier from here
6806
6807 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6808 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6809 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6810 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6811 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6812 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6813 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6814 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6815 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6816 #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));
6817
6818 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6819 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6820 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6821 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6822 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6823 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6824 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6825 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6826
6827 logfile_top_msg ("START");
6828
6829 logfile_top_uint (attack_mode);
6830 logfile_top_uint (attack_kern);
6831 logfile_top_uint (benchmark);
6832 logfile_top_uint (bitmap_min);
6833 logfile_top_uint (bitmap_max);
6834 logfile_top_uint (debug_mode);
6835 logfile_top_uint (force);
6836 logfile_top_uint (kernel_accel);
6837 logfile_top_uint (kernel_loops);
6838 logfile_top_uint (gpu_temp_disable);
6839 #ifdef HAVE_HWMON
6840 logfile_top_uint (gpu_temp_abort);
6841 logfile_top_uint (gpu_temp_retain);
6842 #endif
6843 logfile_top_uint (hash_mode);
6844 logfile_top_uint (hex_charset);
6845 logfile_top_uint (hex_salt);
6846 logfile_top_uint (hex_wordlist);
6847 logfile_top_uint (increment);
6848 logfile_top_uint (increment_max);
6849 logfile_top_uint (increment_min);
6850 logfile_top_uint (keyspace);
6851 logfile_top_uint (left);
6852 logfile_top_uint (logfile_disable);
6853 logfile_top_uint (loopback);
6854 logfile_top_uint (markov_classic);
6855 logfile_top_uint (markov_disable);
6856 logfile_top_uint (markov_threshold);
6857 logfile_top_uint (outfile_autohex);
6858 logfile_top_uint (outfile_check_timer);
6859 logfile_top_uint (outfile_format);
6860 logfile_top_uint (potfile_disable);
6861 logfile_top_string (potfile_path);
6862 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6863 logfile_top_uint (powertune_enable);
6864 #endif
6865 logfile_top_uint (scrypt_tmto);
6866 logfile_top_uint (quiet);
6867 logfile_top_uint (remove);
6868 logfile_top_uint (remove_timer);
6869 logfile_top_uint (restore);
6870 logfile_top_uint (restore_disable);
6871 logfile_top_uint (restore_timer);
6872 logfile_top_uint (rp_gen);
6873 logfile_top_uint (rp_gen_func_max);
6874 logfile_top_uint (rp_gen_func_min);
6875 logfile_top_uint (rp_gen_seed);
6876 logfile_top_uint (runtime);
6877 logfile_top_uint (segment_size);
6878 logfile_top_uint (show);
6879 logfile_top_uint (status);
6880 logfile_top_uint (machine_readable);
6881 logfile_top_uint (status_timer);
6882 logfile_top_uint (usage);
6883 logfile_top_uint (username);
6884 logfile_top_uint (version);
6885 logfile_top_uint (weak_hash_threshold);
6886 logfile_top_uint (workload_profile);
6887 logfile_top_uint64 (limit);
6888 logfile_top_uint64 (skip);
6889 logfile_top_char (separator);
6890 logfile_top_string (cpu_affinity);
6891 logfile_top_string (custom_charset_1);
6892 logfile_top_string (custom_charset_2);
6893 logfile_top_string (custom_charset_3);
6894 logfile_top_string (custom_charset_4);
6895 logfile_top_string (debug_file);
6896 logfile_top_string (opencl_devices);
6897 logfile_top_string (opencl_platforms);
6898 logfile_top_string (opencl_device_types);
6899 logfile_top_uint (opencl_vector_width);
6900 logfile_top_string (induction_dir);
6901 logfile_top_string (markov_hcstat);
6902 logfile_top_string (outfile);
6903 logfile_top_string (outfile_check_dir);
6904 logfile_top_string (rule_buf_l);
6905 logfile_top_string (rule_buf_r);
6906 logfile_top_string (session);
6907 logfile_top_string (truecrypt_keyfiles);
6908 logfile_top_string (veracrypt_keyfiles);
6909 logfile_top_uint (veracrypt_pim);
6910
6911 /**
6912 * Init OpenCL library loader
6913 */
6914
6915 if (keyspace == 0)
6916 {
6917 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6918
6919 ocl_init (ocl);
6920
6921 data.ocl = ocl;
6922 }
6923
6924 /**
6925 * OpenCL platform selection
6926 */
6927
6928 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6929
6930 /**
6931 * OpenCL device selection
6932 */
6933
6934 u32 devices_filter = setup_devices_filter (opencl_devices);
6935
6936 /**
6937 * OpenCL device type selection
6938 */
6939
6940 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6941
6942 /**
6943 * benchmark
6944 */
6945
6946 if (benchmark == 1)
6947 {
6948 /**
6949 * disable useless stuff for benchmark
6950 */
6951
6952 status_timer = 0;
6953 restore_timer = 0;
6954 restore_disable = 1;
6955 potfile_disable = 1;
6956 weak_hash_threshold = 0;
6957 gpu_temp_disable = 1;
6958
6959 #ifdef HAVE_HWMON
6960 #ifdef HAVE_ADL
6961 powertune_enable = 1;
6962 #endif
6963 #endif
6964
6965 data.status_timer = status_timer;
6966 data.restore_timer = restore_timer;
6967 data.restore_disable = restore_disable;
6968
6969 /**
6970 * force attack mode to be bruteforce
6971 */
6972
6973 attack_mode = ATTACK_MODE_BF;
6974 attack_kern = ATTACK_KERN_BF;
6975
6976 if (workload_profile_chgd == 0)
6977 {
6978 workload_profile = 3;
6979
6980 data.workload_profile = workload_profile;
6981 }
6982 }
6983
6984 /**
6985 * config
6986 */
6987
6988 uint hash_type = 0;
6989 uint salt_type = 0;
6990 uint attack_exec = 0;
6991 uint opts_type = 0;
6992 uint kern_type = 0;
6993 uint dgst_size = 0;
6994 uint esalt_size = 0;
6995 uint opti_type = 0;
6996 uint dgst_pos0 = -1;
6997 uint dgst_pos1 = -1;
6998 uint dgst_pos2 = -1;
6999 uint dgst_pos3 = -1;
7000
7001 int (*parse_func) (char *, uint, hash_t *);
7002 int (*sort_by_digest) (const void *, const void *);
7003
7004 uint algorithm_pos = 0;
7005 uint algorithm_max = 1;
7006
7007 uint *algorithms = default_benchmark_algorithms;
7008
7009 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7010
7011 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7012 {
7013 /*
7014 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7015 * the following algos are skipped entirely
7016 */
7017
7018 if (algorithm_pos > 0)
7019 {
7020 local_free (rd);
7021
7022 rd = init_restore (argc, argv);
7023
7024 data.rd = rd;
7025 }
7026
7027 /**
7028 * update hash_mode in case of multihash benchmark
7029 */
7030
7031 if (benchmark == 1)
7032 {
7033 if (hash_mode_chgd == 0)
7034 {
7035 hash_mode = algorithms[algorithm_pos];
7036
7037 data.hash_mode = hash_mode;
7038 }
7039
7040 quiet = 1;
7041
7042 data.quiet = quiet;
7043 }
7044
7045 switch (hash_mode)
7046 {
7047 case 0: hash_type = HASH_TYPE_MD5;
7048 salt_type = SALT_TYPE_NONE;
7049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7050 opts_type = OPTS_TYPE_PT_GENERATE_LE
7051 | OPTS_TYPE_PT_ADD80
7052 | OPTS_TYPE_PT_ADDBITS14;
7053 kern_type = KERN_TYPE_MD5;
7054 dgst_size = DGST_SIZE_4_4;
7055 parse_func = md5_parse_hash;
7056 sort_by_digest = sort_by_digest_4_4;
7057 opti_type = OPTI_TYPE_ZERO_BYTE
7058 | OPTI_TYPE_PRECOMPUTE_INIT
7059 | OPTI_TYPE_PRECOMPUTE_MERKLE
7060 | OPTI_TYPE_MEET_IN_MIDDLE
7061 | OPTI_TYPE_EARLY_SKIP
7062 | OPTI_TYPE_NOT_ITERATED
7063 | OPTI_TYPE_NOT_SALTED
7064 | OPTI_TYPE_RAW_HASH;
7065 dgst_pos0 = 0;
7066 dgst_pos1 = 3;
7067 dgst_pos2 = 2;
7068 dgst_pos3 = 1;
7069 break;
7070
7071 case 10: hash_type = HASH_TYPE_MD5;
7072 salt_type = SALT_TYPE_INTERN;
7073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7074 opts_type = OPTS_TYPE_PT_GENERATE_LE
7075 | OPTS_TYPE_ST_ADD80
7076 | OPTS_TYPE_ST_ADDBITS14;
7077 kern_type = KERN_TYPE_MD5_PWSLT;
7078 dgst_size = DGST_SIZE_4_4;
7079 parse_func = md5s_parse_hash;
7080 sort_by_digest = sort_by_digest_4_4;
7081 opti_type = OPTI_TYPE_ZERO_BYTE
7082 | OPTI_TYPE_PRECOMPUTE_INIT
7083 | OPTI_TYPE_PRECOMPUTE_MERKLE
7084 | OPTI_TYPE_MEET_IN_MIDDLE
7085 | OPTI_TYPE_EARLY_SKIP
7086 | OPTI_TYPE_NOT_ITERATED
7087 | OPTI_TYPE_APPENDED_SALT
7088 | OPTI_TYPE_RAW_HASH;
7089 dgst_pos0 = 0;
7090 dgst_pos1 = 3;
7091 dgst_pos2 = 2;
7092 dgst_pos3 = 1;
7093 break;
7094
7095 case 11: hash_type = HASH_TYPE_MD5;
7096 salt_type = SALT_TYPE_INTERN;
7097 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7098 opts_type = OPTS_TYPE_PT_GENERATE_LE
7099 | OPTS_TYPE_ST_ADD80
7100 | OPTS_TYPE_ST_ADDBITS14;
7101 kern_type = KERN_TYPE_MD5_PWSLT;
7102 dgst_size = DGST_SIZE_4_4;
7103 parse_func = joomla_parse_hash;
7104 sort_by_digest = sort_by_digest_4_4;
7105 opti_type = OPTI_TYPE_ZERO_BYTE
7106 | OPTI_TYPE_PRECOMPUTE_INIT
7107 | OPTI_TYPE_PRECOMPUTE_MERKLE
7108 | OPTI_TYPE_MEET_IN_MIDDLE
7109 | OPTI_TYPE_EARLY_SKIP
7110 | OPTI_TYPE_NOT_ITERATED
7111 | OPTI_TYPE_APPENDED_SALT
7112 | OPTI_TYPE_RAW_HASH;
7113 dgst_pos0 = 0;
7114 dgst_pos1 = 3;
7115 dgst_pos2 = 2;
7116 dgst_pos3 = 1;
7117 break;
7118
7119 case 12: hash_type = HASH_TYPE_MD5;
7120 salt_type = SALT_TYPE_INTERN;
7121 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7122 opts_type = OPTS_TYPE_PT_GENERATE_LE
7123 | OPTS_TYPE_ST_ADD80
7124 | OPTS_TYPE_ST_ADDBITS14;
7125 kern_type = KERN_TYPE_MD5_PWSLT;
7126 dgst_size = DGST_SIZE_4_4;
7127 parse_func = postgresql_parse_hash;
7128 sort_by_digest = sort_by_digest_4_4;
7129 opti_type = OPTI_TYPE_ZERO_BYTE
7130 | OPTI_TYPE_PRECOMPUTE_INIT
7131 | OPTI_TYPE_PRECOMPUTE_MERKLE
7132 | OPTI_TYPE_MEET_IN_MIDDLE
7133 | OPTI_TYPE_EARLY_SKIP
7134 | OPTI_TYPE_NOT_ITERATED
7135 | OPTI_TYPE_APPENDED_SALT
7136 | OPTI_TYPE_RAW_HASH;
7137 dgst_pos0 = 0;
7138 dgst_pos1 = 3;
7139 dgst_pos2 = 2;
7140 dgst_pos3 = 1;
7141 break;
7142
7143 case 20: hash_type = HASH_TYPE_MD5;
7144 salt_type = SALT_TYPE_INTERN;
7145 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7146 opts_type = OPTS_TYPE_PT_GENERATE_LE
7147 | OPTS_TYPE_PT_ADD80
7148 | OPTS_TYPE_PT_ADDBITS14;
7149 kern_type = KERN_TYPE_MD5_SLTPW;
7150 dgst_size = DGST_SIZE_4_4;
7151 parse_func = md5s_parse_hash;
7152 sort_by_digest = sort_by_digest_4_4;
7153 opti_type = OPTI_TYPE_ZERO_BYTE
7154 | OPTI_TYPE_PRECOMPUTE_INIT
7155 | OPTI_TYPE_PRECOMPUTE_MERKLE
7156 | OPTI_TYPE_EARLY_SKIP
7157 | OPTI_TYPE_NOT_ITERATED
7158 | OPTI_TYPE_PREPENDED_SALT
7159 | OPTI_TYPE_RAW_HASH;
7160 dgst_pos0 = 0;
7161 dgst_pos1 = 3;
7162 dgst_pos2 = 2;
7163 dgst_pos3 = 1;
7164 break;
7165
7166 case 21: hash_type = HASH_TYPE_MD5;
7167 salt_type = SALT_TYPE_INTERN;
7168 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7169 opts_type = OPTS_TYPE_PT_GENERATE_LE
7170 | OPTS_TYPE_PT_ADD80
7171 | OPTS_TYPE_PT_ADDBITS14;
7172 kern_type = KERN_TYPE_MD5_SLTPW;
7173 dgst_size = DGST_SIZE_4_4;
7174 parse_func = osc_parse_hash;
7175 sort_by_digest = sort_by_digest_4_4;
7176 opti_type = OPTI_TYPE_ZERO_BYTE
7177 | OPTI_TYPE_PRECOMPUTE_INIT
7178 | OPTI_TYPE_PRECOMPUTE_MERKLE
7179 | OPTI_TYPE_EARLY_SKIP
7180 | OPTI_TYPE_NOT_ITERATED
7181 | OPTI_TYPE_PREPENDED_SALT
7182 | OPTI_TYPE_RAW_HASH;
7183 dgst_pos0 = 0;
7184 dgst_pos1 = 3;
7185 dgst_pos2 = 2;
7186 dgst_pos3 = 1;
7187 break;
7188
7189 case 22: hash_type = HASH_TYPE_MD5;
7190 salt_type = SALT_TYPE_EMBEDDED;
7191 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7192 opts_type = OPTS_TYPE_PT_GENERATE_LE
7193 | OPTS_TYPE_PT_ADD80
7194 | OPTS_TYPE_PT_ADDBITS14;
7195 kern_type = KERN_TYPE_MD5_SLTPW;
7196 dgst_size = DGST_SIZE_4_4;
7197 parse_func = netscreen_parse_hash;
7198 sort_by_digest = sort_by_digest_4_4;
7199 opti_type = OPTI_TYPE_ZERO_BYTE
7200 | OPTI_TYPE_PRECOMPUTE_INIT
7201 | OPTI_TYPE_PRECOMPUTE_MERKLE
7202 | OPTI_TYPE_EARLY_SKIP
7203 | OPTI_TYPE_NOT_ITERATED
7204 | OPTI_TYPE_PREPENDED_SALT
7205 | OPTI_TYPE_RAW_HASH;
7206 dgst_pos0 = 0;
7207 dgst_pos1 = 3;
7208 dgst_pos2 = 2;
7209 dgst_pos3 = 1;
7210 break;
7211
7212 case 23: hash_type = HASH_TYPE_MD5;
7213 salt_type = SALT_TYPE_EMBEDDED;
7214 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7215 opts_type = OPTS_TYPE_PT_GENERATE_LE
7216 | OPTS_TYPE_PT_ADD80
7217 | OPTS_TYPE_PT_ADDBITS14;
7218 kern_type = KERN_TYPE_MD5_SLTPW;
7219 dgst_size = DGST_SIZE_4_4;
7220 parse_func = skype_parse_hash;
7221 sort_by_digest = sort_by_digest_4_4;
7222 opti_type = OPTI_TYPE_ZERO_BYTE
7223 | OPTI_TYPE_PRECOMPUTE_INIT
7224 | OPTI_TYPE_PRECOMPUTE_MERKLE
7225 | OPTI_TYPE_EARLY_SKIP
7226 | OPTI_TYPE_NOT_ITERATED
7227 | OPTI_TYPE_PREPENDED_SALT
7228 | OPTI_TYPE_RAW_HASH;
7229 dgst_pos0 = 0;
7230 dgst_pos1 = 3;
7231 dgst_pos2 = 2;
7232 dgst_pos3 = 1;
7233 break;
7234
7235 case 30: hash_type = HASH_TYPE_MD5;
7236 salt_type = SALT_TYPE_INTERN;
7237 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7238 opts_type = OPTS_TYPE_PT_GENERATE_LE
7239 | OPTS_TYPE_PT_UNICODE
7240 | OPTS_TYPE_ST_ADD80
7241 | OPTS_TYPE_ST_ADDBITS14;
7242 kern_type = KERN_TYPE_MD5_PWUSLT;
7243 dgst_size = DGST_SIZE_4_4;
7244 parse_func = md5s_parse_hash;
7245 sort_by_digest = sort_by_digest_4_4;
7246 opti_type = OPTI_TYPE_ZERO_BYTE
7247 | OPTI_TYPE_PRECOMPUTE_INIT
7248 | OPTI_TYPE_PRECOMPUTE_MERKLE
7249 | OPTI_TYPE_MEET_IN_MIDDLE
7250 | OPTI_TYPE_EARLY_SKIP
7251 | OPTI_TYPE_NOT_ITERATED
7252 | OPTI_TYPE_APPENDED_SALT
7253 | OPTI_TYPE_RAW_HASH;
7254 dgst_pos0 = 0;
7255 dgst_pos1 = 3;
7256 dgst_pos2 = 2;
7257 dgst_pos3 = 1;
7258 break;
7259
7260 case 40: hash_type = HASH_TYPE_MD5;
7261 salt_type = SALT_TYPE_INTERN;
7262 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7263 opts_type = OPTS_TYPE_PT_GENERATE_LE
7264 | OPTS_TYPE_PT_ADD80
7265 | OPTS_TYPE_PT_ADDBITS14
7266 | OPTS_TYPE_PT_UNICODE;
7267 kern_type = KERN_TYPE_MD5_SLTPWU;
7268 dgst_size = DGST_SIZE_4_4;
7269 parse_func = md5s_parse_hash;
7270 sort_by_digest = sort_by_digest_4_4;
7271 opti_type = OPTI_TYPE_ZERO_BYTE
7272 | OPTI_TYPE_PRECOMPUTE_INIT
7273 | OPTI_TYPE_PRECOMPUTE_MERKLE
7274 | OPTI_TYPE_EARLY_SKIP
7275 | OPTI_TYPE_NOT_ITERATED
7276 | OPTI_TYPE_PREPENDED_SALT
7277 | OPTI_TYPE_RAW_HASH;
7278 dgst_pos0 = 0;
7279 dgst_pos1 = 3;
7280 dgst_pos2 = 2;
7281 dgst_pos3 = 1;
7282 break;
7283
7284 case 50: hash_type = HASH_TYPE_MD5;
7285 salt_type = SALT_TYPE_INTERN;
7286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7287 opts_type = OPTS_TYPE_PT_GENERATE_LE
7288 | OPTS_TYPE_ST_ADD80
7289 | OPTS_TYPE_ST_ADDBITS14;
7290 kern_type = KERN_TYPE_HMACMD5_PW;
7291 dgst_size = DGST_SIZE_4_4;
7292 parse_func = hmacmd5_parse_hash;
7293 sort_by_digest = sort_by_digest_4_4;
7294 opti_type = OPTI_TYPE_ZERO_BYTE
7295 | OPTI_TYPE_NOT_ITERATED;
7296 dgst_pos0 = 0;
7297 dgst_pos1 = 3;
7298 dgst_pos2 = 2;
7299 dgst_pos3 = 1;
7300 break;
7301
7302 case 60: hash_type = HASH_TYPE_MD5;
7303 salt_type = SALT_TYPE_INTERN;
7304 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7305 opts_type = OPTS_TYPE_PT_GENERATE_LE
7306 | OPTS_TYPE_PT_ADD80
7307 | OPTS_TYPE_PT_ADDBITS14;
7308 kern_type = KERN_TYPE_HMACMD5_SLT;
7309 dgst_size = DGST_SIZE_4_4;
7310 parse_func = hmacmd5_parse_hash;
7311 sort_by_digest = sort_by_digest_4_4;
7312 opti_type = OPTI_TYPE_ZERO_BYTE
7313 | OPTI_TYPE_NOT_ITERATED;
7314 dgst_pos0 = 0;
7315 dgst_pos1 = 3;
7316 dgst_pos2 = 2;
7317 dgst_pos3 = 1;
7318 break;
7319
7320 case 100: hash_type = HASH_TYPE_SHA1;
7321 salt_type = SALT_TYPE_NONE;
7322 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7323 opts_type = OPTS_TYPE_PT_GENERATE_BE
7324 | OPTS_TYPE_PT_ADD80
7325 | OPTS_TYPE_PT_ADDBITS15;
7326 kern_type = KERN_TYPE_SHA1;
7327 dgst_size = DGST_SIZE_4_5;
7328 parse_func = sha1_parse_hash;
7329 sort_by_digest = sort_by_digest_4_5;
7330 opti_type = OPTI_TYPE_ZERO_BYTE
7331 | OPTI_TYPE_PRECOMPUTE_INIT
7332 | OPTI_TYPE_PRECOMPUTE_MERKLE
7333 | OPTI_TYPE_EARLY_SKIP
7334 | OPTI_TYPE_NOT_ITERATED
7335 | OPTI_TYPE_NOT_SALTED
7336 | OPTI_TYPE_RAW_HASH;
7337 dgst_pos0 = 3;
7338 dgst_pos1 = 4;
7339 dgst_pos2 = 2;
7340 dgst_pos3 = 1;
7341 break;
7342
7343 case 101: hash_type = HASH_TYPE_SHA1;
7344 salt_type = SALT_TYPE_NONE;
7345 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7346 opts_type = OPTS_TYPE_PT_GENERATE_BE
7347 | OPTS_TYPE_PT_ADD80
7348 | OPTS_TYPE_PT_ADDBITS15;
7349 kern_type = KERN_TYPE_SHA1;
7350 dgst_size = DGST_SIZE_4_5;
7351 parse_func = sha1b64_parse_hash;
7352 sort_by_digest = sort_by_digest_4_5;
7353 opti_type = OPTI_TYPE_ZERO_BYTE
7354 | OPTI_TYPE_PRECOMPUTE_INIT
7355 | OPTI_TYPE_PRECOMPUTE_MERKLE
7356 | OPTI_TYPE_EARLY_SKIP
7357 | OPTI_TYPE_NOT_ITERATED
7358 | OPTI_TYPE_NOT_SALTED
7359 | OPTI_TYPE_RAW_HASH;
7360 dgst_pos0 = 3;
7361 dgst_pos1 = 4;
7362 dgst_pos2 = 2;
7363 dgst_pos3 = 1;
7364 break;
7365
7366 case 110: hash_type = HASH_TYPE_SHA1;
7367 salt_type = SALT_TYPE_INTERN;
7368 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7369 opts_type = OPTS_TYPE_PT_GENERATE_BE
7370 | OPTS_TYPE_ST_ADD80
7371 | OPTS_TYPE_ST_ADDBITS15;
7372 kern_type = KERN_TYPE_SHA1_PWSLT;
7373 dgst_size = DGST_SIZE_4_5;
7374 parse_func = sha1s_parse_hash;
7375 sort_by_digest = sort_by_digest_4_5;
7376 opti_type = OPTI_TYPE_ZERO_BYTE
7377 | OPTI_TYPE_PRECOMPUTE_INIT
7378 | OPTI_TYPE_PRECOMPUTE_MERKLE
7379 | OPTI_TYPE_EARLY_SKIP
7380 | OPTI_TYPE_NOT_ITERATED
7381 | OPTI_TYPE_APPENDED_SALT
7382 | OPTI_TYPE_RAW_HASH;
7383 dgst_pos0 = 3;
7384 dgst_pos1 = 4;
7385 dgst_pos2 = 2;
7386 dgst_pos3 = 1;
7387 break;
7388
7389 case 111: hash_type = HASH_TYPE_SHA1;
7390 salt_type = SALT_TYPE_EMBEDDED;
7391 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7392 opts_type = OPTS_TYPE_PT_GENERATE_BE
7393 | OPTS_TYPE_ST_ADD80
7394 | OPTS_TYPE_ST_ADDBITS15;
7395 kern_type = KERN_TYPE_SHA1_PWSLT;
7396 dgst_size = DGST_SIZE_4_5;
7397 parse_func = sha1b64s_parse_hash;
7398 sort_by_digest = sort_by_digest_4_5;
7399 opti_type = OPTI_TYPE_ZERO_BYTE
7400 | OPTI_TYPE_PRECOMPUTE_INIT
7401 | OPTI_TYPE_PRECOMPUTE_MERKLE
7402 | OPTI_TYPE_EARLY_SKIP
7403 | OPTI_TYPE_NOT_ITERATED
7404 | OPTI_TYPE_APPENDED_SALT
7405 | OPTI_TYPE_RAW_HASH;
7406 dgst_pos0 = 3;
7407 dgst_pos1 = 4;
7408 dgst_pos2 = 2;
7409 dgst_pos3 = 1;
7410 break;
7411
7412 case 112: hash_type = HASH_TYPE_SHA1;
7413 salt_type = SALT_TYPE_INTERN;
7414 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7415 opts_type = OPTS_TYPE_PT_GENERATE_BE
7416 | OPTS_TYPE_ST_ADD80
7417 | OPTS_TYPE_ST_ADDBITS15
7418 | OPTS_TYPE_ST_HEX;
7419 kern_type = KERN_TYPE_SHA1_PWSLT;
7420 dgst_size = DGST_SIZE_4_5;
7421 parse_func = oracles_parse_hash;
7422 sort_by_digest = sort_by_digest_4_5;
7423 opti_type = OPTI_TYPE_ZERO_BYTE
7424 | OPTI_TYPE_PRECOMPUTE_INIT
7425 | OPTI_TYPE_PRECOMPUTE_MERKLE
7426 | OPTI_TYPE_EARLY_SKIP
7427 | OPTI_TYPE_NOT_ITERATED
7428 | OPTI_TYPE_APPENDED_SALT
7429 | OPTI_TYPE_RAW_HASH;
7430 dgst_pos0 = 3;
7431 dgst_pos1 = 4;
7432 dgst_pos2 = 2;
7433 dgst_pos3 = 1;
7434 break;
7435
7436 case 120: hash_type = HASH_TYPE_SHA1;
7437 salt_type = SALT_TYPE_INTERN;
7438 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7439 opts_type = OPTS_TYPE_PT_GENERATE_BE
7440 | OPTS_TYPE_PT_ADD80
7441 | OPTS_TYPE_PT_ADDBITS15;
7442 kern_type = KERN_TYPE_SHA1_SLTPW;
7443 dgst_size = DGST_SIZE_4_5;
7444 parse_func = sha1s_parse_hash;
7445 sort_by_digest = sort_by_digest_4_5;
7446 opti_type = OPTI_TYPE_ZERO_BYTE
7447 | OPTI_TYPE_PRECOMPUTE_INIT
7448 | OPTI_TYPE_PRECOMPUTE_MERKLE
7449 | OPTI_TYPE_EARLY_SKIP
7450 | OPTI_TYPE_NOT_ITERATED
7451 | OPTI_TYPE_PREPENDED_SALT
7452 | OPTI_TYPE_RAW_HASH;
7453 dgst_pos0 = 3;
7454 dgst_pos1 = 4;
7455 dgst_pos2 = 2;
7456 dgst_pos3 = 1;
7457 break;
7458
7459 case 121: hash_type = HASH_TYPE_SHA1;
7460 salt_type = SALT_TYPE_INTERN;
7461 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7462 opts_type = OPTS_TYPE_PT_GENERATE_BE
7463 | OPTS_TYPE_PT_ADD80
7464 | OPTS_TYPE_PT_ADDBITS15
7465 | OPTS_TYPE_ST_LOWER;
7466 kern_type = KERN_TYPE_SHA1_SLTPW;
7467 dgst_size = DGST_SIZE_4_5;
7468 parse_func = smf_parse_hash;
7469 sort_by_digest = sort_by_digest_4_5;
7470 opti_type = OPTI_TYPE_ZERO_BYTE
7471 | OPTI_TYPE_PRECOMPUTE_INIT
7472 | OPTI_TYPE_PRECOMPUTE_MERKLE
7473 | OPTI_TYPE_EARLY_SKIP
7474 | OPTI_TYPE_NOT_ITERATED
7475 | OPTI_TYPE_PREPENDED_SALT
7476 | OPTI_TYPE_RAW_HASH;
7477 dgst_pos0 = 3;
7478 dgst_pos1 = 4;
7479 dgst_pos2 = 2;
7480 dgst_pos3 = 1;
7481 break;
7482
7483 case 122: hash_type = HASH_TYPE_SHA1;
7484 salt_type = SALT_TYPE_EMBEDDED;
7485 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7486 opts_type = OPTS_TYPE_PT_GENERATE_BE
7487 | OPTS_TYPE_PT_ADD80
7488 | OPTS_TYPE_PT_ADDBITS15
7489 | OPTS_TYPE_ST_HEX;
7490 kern_type = KERN_TYPE_SHA1_SLTPW;
7491 dgst_size = DGST_SIZE_4_5;
7492 parse_func = osx1_parse_hash;
7493 sort_by_digest = sort_by_digest_4_5;
7494 opti_type = OPTI_TYPE_ZERO_BYTE
7495 | OPTI_TYPE_PRECOMPUTE_INIT
7496 | OPTI_TYPE_PRECOMPUTE_MERKLE
7497 | OPTI_TYPE_EARLY_SKIP
7498 | OPTI_TYPE_NOT_ITERATED
7499 | OPTI_TYPE_PREPENDED_SALT
7500 | OPTI_TYPE_RAW_HASH;
7501 dgst_pos0 = 3;
7502 dgst_pos1 = 4;
7503 dgst_pos2 = 2;
7504 dgst_pos3 = 1;
7505 break;
7506
7507 case 124: hash_type = HASH_TYPE_SHA1;
7508 salt_type = SALT_TYPE_EMBEDDED;
7509 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7510 opts_type = OPTS_TYPE_PT_GENERATE_BE
7511 | OPTS_TYPE_PT_ADD80
7512 | OPTS_TYPE_PT_ADDBITS15;
7513 kern_type = KERN_TYPE_SHA1_SLTPW;
7514 dgst_size = DGST_SIZE_4_5;
7515 parse_func = djangosha1_parse_hash;
7516 sort_by_digest = sort_by_digest_4_5;
7517 opti_type = OPTI_TYPE_ZERO_BYTE
7518 | OPTI_TYPE_PRECOMPUTE_INIT
7519 | OPTI_TYPE_PRECOMPUTE_MERKLE
7520 | OPTI_TYPE_EARLY_SKIP
7521 | OPTI_TYPE_NOT_ITERATED
7522 | OPTI_TYPE_PREPENDED_SALT
7523 | OPTI_TYPE_RAW_HASH;
7524 dgst_pos0 = 3;
7525 dgst_pos1 = 4;
7526 dgst_pos2 = 2;
7527 dgst_pos3 = 1;
7528 break;
7529
7530 case 125: hash_type = HASH_TYPE_SHA1;
7531 salt_type = SALT_TYPE_EMBEDDED;
7532 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7533 opts_type = OPTS_TYPE_PT_GENERATE_BE
7534 | OPTS_TYPE_PT_ADD80
7535 | OPTS_TYPE_PT_ADDBITS15
7536 | OPTS_TYPE_ST_HEX;
7537 kern_type = KERN_TYPE_SHA1_SLTPW;
7538 dgst_size = DGST_SIZE_4_5;
7539 parse_func = arubaos_parse_hash;
7540 sort_by_digest = sort_by_digest_4_5;
7541 opti_type = OPTI_TYPE_ZERO_BYTE
7542 | OPTI_TYPE_PRECOMPUTE_INIT
7543 | OPTI_TYPE_PRECOMPUTE_MERKLE
7544 | OPTI_TYPE_EARLY_SKIP
7545 | OPTI_TYPE_NOT_ITERATED
7546 | OPTI_TYPE_PREPENDED_SALT
7547 | OPTI_TYPE_RAW_HASH;
7548 dgst_pos0 = 3;
7549 dgst_pos1 = 4;
7550 dgst_pos2 = 2;
7551 dgst_pos3 = 1;
7552 break;
7553
7554 case 130: hash_type = HASH_TYPE_SHA1;
7555 salt_type = SALT_TYPE_INTERN;
7556 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7557 opts_type = OPTS_TYPE_PT_GENERATE_BE
7558 | OPTS_TYPE_PT_UNICODE
7559 | OPTS_TYPE_ST_ADD80
7560 | OPTS_TYPE_ST_ADDBITS15;
7561 kern_type = KERN_TYPE_SHA1_PWUSLT;
7562 dgst_size = DGST_SIZE_4_5;
7563 parse_func = sha1s_parse_hash;
7564 sort_by_digest = sort_by_digest_4_5;
7565 opti_type = OPTI_TYPE_ZERO_BYTE
7566 | OPTI_TYPE_PRECOMPUTE_INIT
7567 | OPTI_TYPE_PRECOMPUTE_MERKLE
7568 | OPTI_TYPE_EARLY_SKIP
7569 | OPTI_TYPE_NOT_ITERATED
7570 | OPTI_TYPE_APPENDED_SALT
7571 | OPTI_TYPE_RAW_HASH;
7572 dgst_pos0 = 3;
7573 dgst_pos1 = 4;
7574 dgst_pos2 = 2;
7575 dgst_pos3 = 1;
7576 break;
7577
7578 case 131: hash_type = HASH_TYPE_SHA1;
7579 salt_type = SALT_TYPE_EMBEDDED;
7580 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7581 opts_type = OPTS_TYPE_PT_GENERATE_BE
7582 | OPTS_TYPE_PT_UNICODE
7583 | OPTS_TYPE_PT_UPPER
7584 | OPTS_TYPE_ST_ADD80
7585 | OPTS_TYPE_ST_ADDBITS15
7586 | OPTS_TYPE_ST_HEX;
7587 kern_type = KERN_TYPE_SHA1_PWUSLT;
7588 dgst_size = DGST_SIZE_4_5;
7589 parse_func = mssql2000_parse_hash;
7590 sort_by_digest = sort_by_digest_4_5;
7591 opti_type = OPTI_TYPE_ZERO_BYTE
7592 | OPTI_TYPE_PRECOMPUTE_INIT
7593 | OPTI_TYPE_PRECOMPUTE_MERKLE
7594 | OPTI_TYPE_EARLY_SKIP
7595 | OPTI_TYPE_NOT_ITERATED
7596 | OPTI_TYPE_APPENDED_SALT
7597 | OPTI_TYPE_RAW_HASH;
7598 dgst_pos0 = 3;
7599 dgst_pos1 = 4;
7600 dgst_pos2 = 2;
7601 dgst_pos3 = 1;
7602 break;
7603
7604 case 132: hash_type = HASH_TYPE_SHA1;
7605 salt_type = SALT_TYPE_EMBEDDED;
7606 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7607 opts_type = OPTS_TYPE_PT_GENERATE_BE
7608 | OPTS_TYPE_PT_UNICODE
7609 | OPTS_TYPE_ST_ADD80
7610 | OPTS_TYPE_ST_ADDBITS15
7611 | OPTS_TYPE_ST_HEX;
7612 kern_type = KERN_TYPE_SHA1_PWUSLT;
7613 dgst_size = DGST_SIZE_4_5;
7614 parse_func = mssql2005_parse_hash;
7615 sort_by_digest = sort_by_digest_4_5;
7616 opti_type = OPTI_TYPE_ZERO_BYTE
7617 | OPTI_TYPE_PRECOMPUTE_INIT
7618 | OPTI_TYPE_PRECOMPUTE_MERKLE
7619 | OPTI_TYPE_EARLY_SKIP
7620 | OPTI_TYPE_NOT_ITERATED
7621 | OPTI_TYPE_APPENDED_SALT
7622 | OPTI_TYPE_RAW_HASH;
7623 dgst_pos0 = 3;
7624 dgst_pos1 = 4;
7625 dgst_pos2 = 2;
7626 dgst_pos3 = 1;
7627 break;
7628
7629 case 133: hash_type = HASH_TYPE_SHA1;
7630 salt_type = SALT_TYPE_EMBEDDED;
7631 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7632 opts_type = OPTS_TYPE_PT_GENERATE_BE
7633 | OPTS_TYPE_PT_UNICODE
7634 | OPTS_TYPE_ST_ADD80
7635 | OPTS_TYPE_ST_ADDBITS15;
7636 kern_type = KERN_TYPE_SHA1_PWUSLT;
7637 dgst_size = DGST_SIZE_4_5;
7638 parse_func = peoplesoft_parse_hash;
7639 sort_by_digest = sort_by_digest_4_5;
7640 opti_type = OPTI_TYPE_ZERO_BYTE
7641 | OPTI_TYPE_PRECOMPUTE_INIT
7642 | OPTI_TYPE_PRECOMPUTE_MERKLE
7643 | OPTI_TYPE_EARLY_SKIP
7644 | OPTI_TYPE_NOT_ITERATED
7645 | OPTI_TYPE_APPENDED_SALT
7646 | OPTI_TYPE_RAW_HASH;
7647 dgst_pos0 = 3;
7648 dgst_pos1 = 4;
7649 dgst_pos2 = 2;
7650 dgst_pos3 = 1;
7651 break;
7652
7653 case 140: hash_type = HASH_TYPE_SHA1;
7654 salt_type = SALT_TYPE_INTERN;
7655 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7656 opts_type = OPTS_TYPE_PT_GENERATE_BE
7657 | OPTS_TYPE_PT_ADD80
7658 | OPTS_TYPE_PT_ADDBITS15
7659 | OPTS_TYPE_PT_UNICODE;
7660 kern_type = KERN_TYPE_SHA1_SLTPWU;
7661 dgst_size = DGST_SIZE_4_5;
7662 parse_func = sha1s_parse_hash;
7663 sort_by_digest = sort_by_digest_4_5;
7664 opti_type = OPTI_TYPE_ZERO_BYTE
7665 | OPTI_TYPE_PRECOMPUTE_INIT
7666 | OPTI_TYPE_PRECOMPUTE_MERKLE
7667 | OPTI_TYPE_EARLY_SKIP
7668 | OPTI_TYPE_NOT_ITERATED
7669 | OPTI_TYPE_PREPENDED_SALT
7670 | OPTI_TYPE_RAW_HASH;
7671 dgst_pos0 = 3;
7672 dgst_pos1 = 4;
7673 dgst_pos2 = 2;
7674 dgst_pos3 = 1;
7675 break;
7676
7677 case 141: hash_type = HASH_TYPE_SHA1;
7678 salt_type = SALT_TYPE_EMBEDDED;
7679 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7680 opts_type = OPTS_TYPE_PT_GENERATE_BE
7681 | OPTS_TYPE_PT_ADD80
7682 | OPTS_TYPE_PT_ADDBITS15
7683 | OPTS_TYPE_PT_UNICODE
7684 | OPTS_TYPE_ST_BASE64;
7685 kern_type = KERN_TYPE_SHA1_SLTPWU;
7686 dgst_size = DGST_SIZE_4_5;
7687 parse_func = episerver_parse_hash;
7688 sort_by_digest = sort_by_digest_4_5;
7689 opti_type = OPTI_TYPE_ZERO_BYTE
7690 | OPTI_TYPE_PRECOMPUTE_INIT
7691 | OPTI_TYPE_PRECOMPUTE_MERKLE
7692 | OPTI_TYPE_EARLY_SKIP
7693 | OPTI_TYPE_NOT_ITERATED
7694 | OPTI_TYPE_PREPENDED_SALT
7695 | OPTI_TYPE_RAW_HASH;
7696 dgst_pos0 = 3;
7697 dgst_pos1 = 4;
7698 dgst_pos2 = 2;
7699 dgst_pos3 = 1;
7700 break;
7701
7702 case 150: hash_type = HASH_TYPE_SHA1;
7703 salt_type = SALT_TYPE_INTERN;
7704 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7705 opts_type = OPTS_TYPE_PT_GENERATE_BE
7706 | OPTS_TYPE_ST_ADD80
7707 | OPTS_TYPE_ST_ADDBITS15;
7708 kern_type = KERN_TYPE_HMACSHA1_PW;
7709 dgst_size = DGST_SIZE_4_5;
7710 parse_func = hmacsha1_parse_hash;
7711 sort_by_digest = sort_by_digest_4_5;
7712 opti_type = OPTI_TYPE_ZERO_BYTE
7713 | OPTI_TYPE_NOT_ITERATED;
7714 dgst_pos0 = 3;
7715 dgst_pos1 = 4;
7716 dgst_pos2 = 2;
7717 dgst_pos3 = 1;
7718 break;
7719
7720 case 160: hash_type = HASH_TYPE_SHA1;
7721 salt_type = SALT_TYPE_INTERN;
7722 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7723 opts_type = OPTS_TYPE_PT_GENERATE_BE
7724 | OPTS_TYPE_PT_ADD80
7725 | OPTS_TYPE_PT_ADDBITS15;
7726 kern_type = KERN_TYPE_HMACSHA1_SLT;
7727 dgst_size = DGST_SIZE_4_5;
7728 parse_func = hmacsha1_parse_hash;
7729 sort_by_digest = sort_by_digest_4_5;
7730 opti_type = OPTI_TYPE_ZERO_BYTE
7731 | OPTI_TYPE_NOT_ITERATED;
7732 dgst_pos0 = 3;
7733 dgst_pos1 = 4;
7734 dgst_pos2 = 2;
7735 dgst_pos3 = 1;
7736 break;
7737
7738 case 190: hash_type = HASH_TYPE_SHA1;
7739 salt_type = SALT_TYPE_NONE;
7740 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7741 opts_type = OPTS_TYPE_PT_GENERATE_BE
7742 | OPTS_TYPE_PT_ADD80
7743 | OPTS_TYPE_PT_ADDBITS15;
7744 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7745 dgst_size = DGST_SIZE_4_5;
7746 parse_func = sha1linkedin_parse_hash;
7747 sort_by_digest = sort_by_digest_4_5;
7748 opti_type = OPTI_TYPE_ZERO_BYTE
7749 | OPTI_TYPE_PRECOMPUTE_INIT
7750 | OPTI_TYPE_EARLY_SKIP
7751 | OPTI_TYPE_NOT_ITERATED
7752 | OPTI_TYPE_NOT_SALTED;
7753 dgst_pos0 = 0;
7754 dgst_pos1 = 4;
7755 dgst_pos2 = 3;
7756 dgst_pos3 = 2;
7757 break;
7758
7759 case 200: hash_type = HASH_TYPE_MYSQL;
7760 salt_type = SALT_TYPE_NONE;
7761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7762 opts_type = 0;
7763 kern_type = KERN_TYPE_MYSQL;
7764 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7765 parse_func = mysql323_parse_hash;
7766 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7767 opti_type = OPTI_TYPE_ZERO_BYTE;
7768 dgst_pos0 = 0;
7769 dgst_pos1 = 1;
7770 dgst_pos2 = 2;
7771 dgst_pos3 = 3;
7772 break;
7773
7774 case 300: hash_type = HASH_TYPE_SHA1;
7775 salt_type = SALT_TYPE_NONE;
7776 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7777 opts_type = OPTS_TYPE_PT_GENERATE_BE
7778 | OPTS_TYPE_PT_ADD80
7779 | OPTS_TYPE_PT_ADDBITS15;
7780 kern_type = KERN_TYPE_MYSQL41;
7781 dgst_size = DGST_SIZE_4_5;
7782 parse_func = sha1_parse_hash;
7783 sort_by_digest = sort_by_digest_4_5;
7784 opti_type = OPTI_TYPE_ZERO_BYTE
7785 | OPTI_TYPE_PRECOMPUTE_INIT
7786 | OPTI_TYPE_PRECOMPUTE_MERKLE
7787 | OPTI_TYPE_EARLY_SKIP
7788 | OPTI_TYPE_NOT_ITERATED
7789 | OPTI_TYPE_NOT_SALTED;
7790 dgst_pos0 = 3;
7791 dgst_pos1 = 4;
7792 dgst_pos2 = 2;
7793 dgst_pos3 = 1;
7794 break;
7795
7796 case 400: hash_type = HASH_TYPE_MD5;
7797 salt_type = SALT_TYPE_EMBEDDED;
7798 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7799 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7800 kern_type = KERN_TYPE_PHPASS;
7801 dgst_size = DGST_SIZE_4_4;
7802 parse_func = phpass_parse_hash;
7803 sort_by_digest = sort_by_digest_4_4;
7804 opti_type = OPTI_TYPE_ZERO_BYTE
7805 | OPTI_TYPE_SLOW_HASH_SIMD;
7806 dgst_pos0 = 0;
7807 dgst_pos1 = 1;
7808 dgst_pos2 = 2;
7809 dgst_pos3 = 3;
7810 break;
7811
7812 case 500: hash_type = HASH_TYPE_MD5;
7813 salt_type = SALT_TYPE_EMBEDDED;
7814 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7815 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7816 kern_type = KERN_TYPE_MD5CRYPT;
7817 dgst_size = DGST_SIZE_4_4;
7818 parse_func = md5crypt_parse_hash;
7819 sort_by_digest = sort_by_digest_4_4;
7820 opti_type = OPTI_TYPE_ZERO_BYTE;
7821 dgst_pos0 = 0;
7822 dgst_pos1 = 1;
7823 dgst_pos2 = 2;
7824 dgst_pos3 = 3;
7825 break;
7826
7827 case 501: hash_type = HASH_TYPE_MD5;
7828 salt_type = SALT_TYPE_EMBEDDED;
7829 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7830 opts_type = OPTS_TYPE_PT_GENERATE_LE
7831 | OPTS_TYPE_HASH_COPY;
7832 kern_type = KERN_TYPE_MD5CRYPT;
7833 dgst_size = DGST_SIZE_4_4;
7834 parse_func = juniper_parse_hash;
7835 sort_by_digest = sort_by_digest_4_4;
7836 opti_type = OPTI_TYPE_ZERO_BYTE;
7837 dgst_pos0 = 0;
7838 dgst_pos1 = 1;
7839 dgst_pos2 = 2;
7840 dgst_pos3 = 3;
7841 break;
7842
7843 case 900: hash_type = HASH_TYPE_MD4;
7844 salt_type = SALT_TYPE_NONE;
7845 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7846 opts_type = OPTS_TYPE_PT_GENERATE_LE
7847 | OPTS_TYPE_PT_ADD80
7848 | OPTS_TYPE_PT_ADDBITS14;
7849 kern_type = KERN_TYPE_MD4;
7850 dgst_size = DGST_SIZE_4_4;
7851 parse_func = md4_parse_hash;
7852 sort_by_digest = sort_by_digest_4_4;
7853 opti_type = OPTI_TYPE_ZERO_BYTE
7854 | OPTI_TYPE_PRECOMPUTE_INIT
7855 | OPTI_TYPE_PRECOMPUTE_MERKLE
7856 | OPTI_TYPE_MEET_IN_MIDDLE
7857 | OPTI_TYPE_EARLY_SKIP
7858 | OPTI_TYPE_NOT_ITERATED
7859 | OPTI_TYPE_NOT_SALTED
7860 | OPTI_TYPE_RAW_HASH;
7861 dgst_pos0 = 0;
7862 dgst_pos1 = 3;
7863 dgst_pos2 = 2;
7864 dgst_pos3 = 1;
7865 break;
7866
7867 case 1000: hash_type = HASH_TYPE_MD4;
7868 salt_type = SALT_TYPE_NONE;
7869 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7870 opts_type = OPTS_TYPE_PT_GENERATE_LE
7871 | OPTS_TYPE_PT_ADD80
7872 | OPTS_TYPE_PT_ADDBITS14
7873 | OPTS_TYPE_PT_UNICODE;
7874 kern_type = KERN_TYPE_MD4_PWU;
7875 dgst_size = DGST_SIZE_4_4;
7876 parse_func = md4_parse_hash;
7877 sort_by_digest = sort_by_digest_4_4;
7878 opti_type = OPTI_TYPE_ZERO_BYTE
7879 | OPTI_TYPE_PRECOMPUTE_INIT
7880 | OPTI_TYPE_PRECOMPUTE_MERKLE
7881 | OPTI_TYPE_MEET_IN_MIDDLE
7882 | OPTI_TYPE_EARLY_SKIP
7883 | OPTI_TYPE_NOT_ITERATED
7884 | OPTI_TYPE_NOT_SALTED
7885 | OPTI_TYPE_RAW_HASH;
7886 dgst_pos0 = 0;
7887 dgst_pos1 = 3;
7888 dgst_pos2 = 2;
7889 dgst_pos3 = 1;
7890 break;
7891
7892 case 1100: hash_type = HASH_TYPE_MD4;
7893 salt_type = SALT_TYPE_INTERN;
7894 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7895 opts_type = OPTS_TYPE_PT_GENERATE_LE
7896 | OPTS_TYPE_PT_ADD80
7897 | OPTS_TYPE_PT_ADDBITS14
7898 | OPTS_TYPE_PT_UNICODE
7899 | OPTS_TYPE_ST_ADD80
7900 | OPTS_TYPE_ST_UNICODE
7901 | OPTS_TYPE_ST_LOWER;
7902 kern_type = KERN_TYPE_MD44_PWUSLT;
7903 dgst_size = DGST_SIZE_4_4;
7904 parse_func = dcc_parse_hash;
7905 sort_by_digest = sort_by_digest_4_4;
7906 opti_type = OPTI_TYPE_ZERO_BYTE
7907 | OPTI_TYPE_PRECOMPUTE_INIT
7908 | OPTI_TYPE_PRECOMPUTE_MERKLE
7909 | OPTI_TYPE_EARLY_SKIP
7910 | OPTI_TYPE_NOT_ITERATED;
7911 dgst_pos0 = 0;
7912 dgst_pos1 = 3;
7913 dgst_pos2 = 2;
7914 dgst_pos3 = 1;
7915 break;
7916
7917 case 1400: hash_type = HASH_TYPE_SHA256;
7918 salt_type = SALT_TYPE_NONE;
7919 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7920 opts_type = OPTS_TYPE_PT_GENERATE_BE
7921 | OPTS_TYPE_PT_ADD80
7922 | OPTS_TYPE_PT_ADDBITS15;
7923 kern_type = KERN_TYPE_SHA256;
7924 dgst_size = DGST_SIZE_4_8;
7925 parse_func = sha256_parse_hash;
7926 sort_by_digest = sort_by_digest_4_8;
7927 opti_type = OPTI_TYPE_ZERO_BYTE
7928 | OPTI_TYPE_PRECOMPUTE_INIT
7929 | OPTI_TYPE_PRECOMPUTE_MERKLE
7930 | OPTI_TYPE_EARLY_SKIP
7931 | OPTI_TYPE_NOT_ITERATED
7932 | OPTI_TYPE_NOT_SALTED
7933 | OPTI_TYPE_RAW_HASH;
7934 dgst_pos0 = 3;
7935 dgst_pos1 = 7;
7936 dgst_pos2 = 2;
7937 dgst_pos3 = 6;
7938 break;
7939
7940 case 1410: hash_type = HASH_TYPE_SHA256;
7941 salt_type = SALT_TYPE_INTERN;
7942 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7943 opts_type = OPTS_TYPE_PT_GENERATE_BE
7944 | OPTS_TYPE_ST_ADD80
7945 | OPTS_TYPE_ST_ADDBITS15;
7946 kern_type = KERN_TYPE_SHA256_PWSLT;
7947 dgst_size = DGST_SIZE_4_8;
7948 parse_func = sha256s_parse_hash;
7949 sort_by_digest = sort_by_digest_4_8;
7950 opti_type = OPTI_TYPE_ZERO_BYTE
7951 | OPTI_TYPE_PRECOMPUTE_INIT
7952 | OPTI_TYPE_PRECOMPUTE_MERKLE
7953 | OPTI_TYPE_EARLY_SKIP
7954 | OPTI_TYPE_NOT_ITERATED
7955 | OPTI_TYPE_APPENDED_SALT
7956 | OPTI_TYPE_RAW_HASH;
7957 dgst_pos0 = 3;
7958 dgst_pos1 = 7;
7959 dgst_pos2 = 2;
7960 dgst_pos3 = 6;
7961 break;
7962
7963 case 1420: hash_type = HASH_TYPE_SHA256;
7964 salt_type = SALT_TYPE_INTERN;
7965 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7966 opts_type = OPTS_TYPE_PT_GENERATE_BE
7967 | OPTS_TYPE_PT_ADD80
7968 | OPTS_TYPE_PT_ADDBITS15;
7969 kern_type = KERN_TYPE_SHA256_SLTPW;
7970 dgst_size = DGST_SIZE_4_8;
7971 parse_func = sha256s_parse_hash;
7972 sort_by_digest = sort_by_digest_4_8;
7973 opti_type = OPTI_TYPE_ZERO_BYTE
7974 | OPTI_TYPE_PRECOMPUTE_INIT
7975 | OPTI_TYPE_PRECOMPUTE_MERKLE
7976 | OPTI_TYPE_EARLY_SKIP
7977 | OPTI_TYPE_NOT_ITERATED
7978 | OPTI_TYPE_PREPENDED_SALT
7979 | OPTI_TYPE_RAW_HASH;
7980 dgst_pos0 = 3;
7981 dgst_pos1 = 7;
7982 dgst_pos2 = 2;
7983 dgst_pos3 = 6;
7984 break;
7985
7986 case 1421: hash_type = HASH_TYPE_SHA256;
7987 salt_type = SALT_TYPE_EMBEDDED;
7988 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7989 opts_type = OPTS_TYPE_PT_GENERATE_BE
7990 | OPTS_TYPE_PT_ADD80
7991 | OPTS_TYPE_PT_ADDBITS15;
7992 kern_type = KERN_TYPE_SHA256_SLTPW;
7993 dgst_size = DGST_SIZE_4_8;
7994 parse_func = hmailserver_parse_hash;
7995 sort_by_digest = sort_by_digest_4_8;
7996 opti_type = OPTI_TYPE_ZERO_BYTE
7997 | OPTI_TYPE_PRECOMPUTE_INIT
7998 | OPTI_TYPE_PRECOMPUTE_MERKLE
7999 | OPTI_TYPE_EARLY_SKIP
8000 | OPTI_TYPE_NOT_ITERATED
8001 | OPTI_TYPE_PREPENDED_SALT
8002 | OPTI_TYPE_RAW_HASH;
8003 dgst_pos0 = 3;
8004 dgst_pos1 = 7;
8005 dgst_pos2 = 2;
8006 dgst_pos3 = 6;
8007 break;
8008
8009 case 1430: hash_type = HASH_TYPE_SHA256;
8010 salt_type = SALT_TYPE_INTERN;
8011 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8012 opts_type = OPTS_TYPE_PT_GENERATE_BE
8013 | OPTS_TYPE_PT_UNICODE
8014 | OPTS_TYPE_ST_ADD80
8015 | OPTS_TYPE_ST_ADDBITS15;
8016 kern_type = KERN_TYPE_SHA256_PWUSLT;
8017 dgst_size = DGST_SIZE_4_8;
8018 parse_func = sha256s_parse_hash;
8019 sort_by_digest = sort_by_digest_4_8;
8020 opti_type = OPTI_TYPE_ZERO_BYTE
8021 | OPTI_TYPE_PRECOMPUTE_INIT
8022 | OPTI_TYPE_PRECOMPUTE_MERKLE
8023 | OPTI_TYPE_EARLY_SKIP
8024 | OPTI_TYPE_NOT_ITERATED
8025 | OPTI_TYPE_APPENDED_SALT
8026 | OPTI_TYPE_RAW_HASH;
8027 dgst_pos0 = 3;
8028 dgst_pos1 = 7;
8029 dgst_pos2 = 2;
8030 dgst_pos3 = 6;
8031 break;
8032
8033 case 1440: hash_type = HASH_TYPE_SHA256;
8034 salt_type = SALT_TYPE_INTERN;
8035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8036 opts_type = OPTS_TYPE_PT_GENERATE_BE
8037 | OPTS_TYPE_PT_ADD80
8038 | OPTS_TYPE_PT_ADDBITS15
8039 | OPTS_TYPE_PT_UNICODE;
8040 kern_type = KERN_TYPE_SHA256_SLTPWU;
8041 dgst_size = DGST_SIZE_4_8;
8042 parse_func = sha256s_parse_hash;
8043 sort_by_digest = sort_by_digest_4_8;
8044 opti_type = OPTI_TYPE_ZERO_BYTE
8045 | OPTI_TYPE_PRECOMPUTE_INIT
8046 | OPTI_TYPE_PRECOMPUTE_MERKLE
8047 | OPTI_TYPE_EARLY_SKIP
8048 | OPTI_TYPE_NOT_ITERATED
8049 | OPTI_TYPE_PREPENDED_SALT
8050 | OPTI_TYPE_RAW_HASH;
8051 dgst_pos0 = 3;
8052 dgst_pos1 = 7;
8053 dgst_pos2 = 2;
8054 dgst_pos3 = 6;
8055 break;
8056
8057 case 1441: hash_type = HASH_TYPE_SHA256;
8058 salt_type = SALT_TYPE_EMBEDDED;
8059 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8060 opts_type = OPTS_TYPE_PT_GENERATE_BE
8061 | OPTS_TYPE_PT_ADD80
8062 | OPTS_TYPE_PT_ADDBITS15
8063 | OPTS_TYPE_PT_UNICODE
8064 | OPTS_TYPE_ST_BASE64;
8065 kern_type = KERN_TYPE_SHA256_SLTPWU;
8066 dgst_size = DGST_SIZE_4_8;
8067 parse_func = episerver4_parse_hash;
8068 sort_by_digest = sort_by_digest_4_8;
8069 opti_type = OPTI_TYPE_ZERO_BYTE
8070 | OPTI_TYPE_PRECOMPUTE_INIT
8071 | OPTI_TYPE_PRECOMPUTE_MERKLE
8072 | OPTI_TYPE_EARLY_SKIP
8073 | OPTI_TYPE_NOT_ITERATED
8074 | OPTI_TYPE_PREPENDED_SALT
8075 | OPTI_TYPE_RAW_HASH;
8076 dgst_pos0 = 3;
8077 dgst_pos1 = 7;
8078 dgst_pos2 = 2;
8079 dgst_pos3 = 6;
8080 break;
8081
8082 case 1450: hash_type = HASH_TYPE_SHA256;
8083 salt_type = SALT_TYPE_INTERN;
8084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8085 opts_type = OPTS_TYPE_PT_GENERATE_BE
8086 | OPTS_TYPE_ST_ADD80;
8087 kern_type = KERN_TYPE_HMACSHA256_PW;
8088 dgst_size = DGST_SIZE_4_8;
8089 parse_func = hmacsha256_parse_hash;
8090 sort_by_digest = sort_by_digest_4_8;
8091 opti_type = OPTI_TYPE_ZERO_BYTE
8092 | OPTI_TYPE_NOT_ITERATED;
8093 dgst_pos0 = 3;
8094 dgst_pos1 = 7;
8095 dgst_pos2 = 2;
8096 dgst_pos3 = 6;
8097 break;
8098
8099 case 1460: hash_type = HASH_TYPE_SHA256;
8100 salt_type = SALT_TYPE_INTERN;
8101 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8102 opts_type = OPTS_TYPE_PT_GENERATE_BE
8103 | OPTS_TYPE_PT_ADD80
8104 | OPTS_TYPE_PT_ADDBITS15;
8105 kern_type = KERN_TYPE_HMACSHA256_SLT;
8106 dgst_size = DGST_SIZE_4_8;
8107 parse_func = hmacsha256_parse_hash;
8108 sort_by_digest = sort_by_digest_4_8;
8109 opti_type = OPTI_TYPE_ZERO_BYTE
8110 | OPTI_TYPE_NOT_ITERATED;
8111 dgst_pos0 = 3;
8112 dgst_pos1 = 7;
8113 dgst_pos2 = 2;
8114 dgst_pos3 = 6;
8115 break;
8116
8117 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8118 salt_type = SALT_TYPE_EMBEDDED;
8119 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8120 opts_type = OPTS_TYPE_PT_GENERATE_LE
8121 | OPTS_TYPE_PT_BITSLICE;
8122 kern_type = KERN_TYPE_DESCRYPT;
8123 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8124 parse_func = descrypt_parse_hash;
8125 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8126 opti_type = OPTI_TYPE_ZERO_BYTE
8127 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8128 dgst_pos0 = 0;
8129 dgst_pos1 = 1;
8130 dgst_pos2 = 2;
8131 dgst_pos3 = 3;
8132 break;
8133
8134 case 1600: hash_type = HASH_TYPE_MD5;
8135 salt_type = SALT_TYPE_EMBEDDED;
8136 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8137 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8138 kern_type = KERN_TYPE_APR1CRYPT;
8139 dgst_size = DGST_SIZE_4_4;
8140 parse_func = md5apr1_parse_hash;
8141 sort_by_digest = sort_by_digest_4_4;
8142 opti_type = OPTI_TYPE_ZERO_BYTE;
8143 dgst_pos0 = 0;
8144 dgst_pos1 = 1;
8145 dgst_pos2 = 2;
8146 dgst_pos3 = 3;
8147 break;
8148
8149 case 1700: hash_type = HASH_TYPE_SHA512;
8150 salt_type = SALT_TYPE_NONE;
8151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8152 opts_type = OPTS_TYPE_PT_GENERATE_BE
8153 | OPTS_TYPE_PT_ADD80
8154 | OPTS_TYPE_PT_ADDBITS15;
8155 kern_type = KERN_TYPE_SHA512;
8156 dgst_size = DGST_SIZE_8_8;
8157 parse_func = sha512_parse_hash;
8158 sort_by_digest = sort_by_digest_8_8;
8159 opti_type = OPTI_TYPE_ZERO_BYTE
8160 | OPTI_TYPE_PRECOMPUTE_INIT
8161 | OPTI_TYPE_PRECOMPUTE_MERKLE
8162 | OPTI_TYPE_EARLY_SKIP
8163 | OPTI_TYPE_NOT_ITERATED
8164 | OPTI_TYPE_NOT_SALTED
8165 | OPTI_TYPE_USES_BITS_64
8166 | OPTI_TYPE_RAW_HASH;
8167 dgst_pos0 = 14;
8168 dgst_pos1 = 15;
8169 dgst_pos2 = 6;
8170 dgst_pos3 = 7;
8171 break;
8172
8173 case 1710: hash_type = HASH_TYPE_SHA512;
8174 salt_type = SALT_TYPE_INTERN;
8175 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8176 opts_type = OPTS_TYPE_PT_GENERATE_BE
8177 | OPTS_TYPE_ST_ADD80
8178 | OPTS_TYPE_ST_ADDBITS15;
8179 kern_type = KERN_TYPE_SHA512_PWSLT;
8180 dgst_size = DGST_SIZE_8_8;
8181 parse_func = sha512s_parse_hash;
8182 sort_by_digest = sort_by_digest_8_8;
8183 opti_type = OPTI_TYPE_ZERO_BYTE
8184 | OPTI_TYPE_PRECOMPUTE_INIT
8185 | OPTI_TYPE_PRECOMPUTE_MERKLE
8186 | OPTI_TYPE_EARLY_SKIP
8187 | OPTI_TYPE_NOT_ITERATED
8188 | OPTI_TYPE_APPENDED_SALT
8189 | OPTI_TYPE_USES_BITS_64
8190 | OPTI_TYPE_RAW_HASH;
8191 dgst_pos0 = 14;
8192 dgst_pos1 = 15;
8193 dgst_pos2 = 6;
8194 dgst_pos3 = 7;
8195 break;
8196
8197 case 1711: hash_type = HASH_TYPE_SHA512;
8198 salt_type = SALT_TYPE_EMBEDDED;
8199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8200 opts_type = OPTS_TYPE_PT_GENERATE_BE
8201 | OPTS_TYPE_ST_ADD80
8202 | OPTS_TYPE_ST_ADDBITS15;
8203 kern_type = KERN_TYPE_SHA512_PWSLT;
8204 dgst_size = DGST_SIZE_8_8;
8205 parse_func = sha512b64s_parse_hash;
8206 sort_by_digest = sort_by_digest_8_8;
8207 opti_type = OPTI_TYPE_ZERO_BYTE
8208 | OPTI_TYPE_PRECOMPUTE_INIT
8209 | OPTI_TYPE_PRECOMPUTE_MERKLE
8210 | OPTI_TYPE_EARLY_SKIP
8211 | OPTI_TYPE_NOT_ITERATED
8212 | OPTI_TYPE_APPENDED_SALT
8213 | OPTI_TYPE_USES_BITS_64
8214 | OPTI_TYPE_RAW_HASH;
8215 dgst_pos0 = 14;
8216 dgst_pos1 = 15;
8217 dgst_pos2 = 6;
8218 dgst_pos3 = 7;
8219 break;
8220
8221 case 1720: hash_type = HASH_TYPE_SHA512;
8222 salt_type = SALT_TYPE_INTERN;
8223 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8224 opts_type = OPTS_TYPE_PT_GENERATE_BE
8225 | OPTS_TYPE_PT_ADD80
8226 | OPTS_TYPE_PT_ADDBITS15;
8227 kern_type = KERN_TYPE_SHA512_SLTPW;
8228 dgst_size = DGST_SIZE_8_8;
8229 parse_func = sha512s_parse_hash;
8230 sort_by_digest = sort_by_digest_8_8;
8231 opti_type = OPTI_TYPE_ZERO_BYTE
8232 | OPTI_TYPE_PRECOMPUTE_INIT
8233 | OPTI_TYPE_PRECOMPUTE_MERKLE
8234 | OPTI_TYPE_EARLY_SKIP
8235 | OPTI_TYPE_NOT_ITERATED
8236 | OPTI_TYPE_PREPENDED_SALT
8237 | OPTI_TYPE_USES_BITS_64
8238 | OPTI_TYPE_RAW_HASH;
8239 dgst_pos0 = 14;
8240 dgst_pos1 = 15;
8241 dgst_pos2 = 6;
8242 dgst_pos3 = 7;
8243 break;
8244
8245 case 1722: hash_type = HASH_TYPE_SHA512;
8246 salt_type = SALT_TYPE_EMBEDDED;
8247 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8248 opts_type = OPTS_TYPE_PT_GENERATE_BE
8249 | OPTS_TYPE_PT_ADD80
8250 | OPTS_TYPE_PT_ADDBITS15
8251 | OPTS_TYPE_ST_HEX;
8252 kern_type = KERN_TYPE_SHA512_SLTPW;
8253 dgst_size = DGST_SIZE_8_8;
8254 parse_func = osx512_parse_hash;
8255 sort_by_digest = sort_by_digest_8_8;
8256 opti_type = OPTI_TYPE_ZERO_BYTE
8257 | OPTI_TYPE_PRECOMPUTE_INIT
8258 | OPTI_TYPE_PRECOMPUTE_MERKLE
8259 | OPTI_TYPE_EARLY_SKIP
8260 | OPTI_TYPE_NOT_ITERATED
8261 | OPTI_TYPE_PREPENDED_SALT
8262 | OPTI_TYPE_USES_BITS_64
8263 | OPTI_TYPE_RAW_HASH;
8264 dgst_pos0 = 14;
8265 dgst_pos1 = 15;
8266 dgst_pos2 = 6;
8267 dgst_pos3 = 7;
8268 break;
8269
8270 case 1730: hash_type = HASH_TYPE_SHA512;
8271 salt_type = SALT_TYPE_INTERN;
8272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8273 opts_type = OPTS_TYPE_PT_GENERATE_BE
8274 | OPTS_TYPE_PT_UNICODE
8275 | OPTS_TYPE_ST_ADD80
8276 | OPTS_TYPE_ST_ADDBITS15;
8277 kern_type = KERN_TYPE_SHA512_PWSLTU;
8278 dgst_size = DGST_SIZE_8_8;
8279 parse_func = sha512s_parse_hash;
8280 sort_by_digest = sort_by_digest_8_8;
8281 opti_type = OPTI_TYPE_ZERO_BYTE
8282 | OPTI_TYPE_PRECOMPUTE_INIT
8283 | OPTI_TYPE_PRECOMPUTE_MERKLE
8284 | OPTI_TYPE_EARLY_SKIP
8285 | OPTI_TYPE_NOT_ITERATED
8286 | OPTI_TYPE_APPENDED_SALT
8287 | OPTI_TYPE_USES_BITS_64
8288 | OPTI_TYPE_RAW_HASH;
8289 dgst_pos0 = 14;
8290 dgst_pos1 = 15;
8291 dgst_pos2 = 6;
8292 dgst_pos3 = 7;
8293 break;
8294
8295 case 1731: hash_type = HASH_TYPE_SHA512;
8296 salt_type = SALT_TYPE_EMBEDDED;
8297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8298 opts_type = OPTS_TYPE_PT_GENERATE_BE
8299 | OPTS_TYPE_PT_UNICODE
8300 | OPTS_TYPE_ST_ADD80
8301 | OPTS_TYPE_ST_ADDBITS15
8302 | OPTS_TYPE_ST_HEX;
8303 kern_type = KERN_TYPE_SHA512_PWSLTU;
8304 dgst_size = DGST_SIZE_8_8;
8305 parse_func = mssql2012_parse_hash;
8306 sort_by_digest = sort_by_digest_8_8;
8307 opti_type = OPTI_TYPE_ZERO_BYTE
8308 | OPTI_TYPE_PRECOMPUTE_INIT
8309 | OPTI_TYPE_PRECOMPUTE_MERKLE
8310 | OPTI_TYPE_EARLY_SKIP
8311 | OPTI_TYPE_NOT_ITERATED
8312 | OPTI_TYPE_APPENDED_SALT
8313 | OPTI_TYPE_USES_BITS_64
8314 | OPTI_TYPE_RAW_HASH;
8315 dgst_pos0 = 14;
8316 dgst_pos1 = 15;
8317 dgst_pos2 = 6;
8318 dgst_pos3 = 7;
8319 break;
8320
8321 case 1740: hash_type = HASH_TYPE_SHA512;
8322 salt_type = SALT_TYPE_INTERN;
8323 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8324 opts_type = OPTS_TYPE_PT_GENERATE_BE
8325 | OPTS_TYPE_PT_ADD80
8326 | OPTS_TYPE_PT_ADDBITS15
8327 | OPTS_TYPE_PT_UNICODE;
8328 kern_type = KERN_TYPE_SHA512_SLTPWU;
8329 dgst_size = DGST_SIZE_8_8;
8330 parse_func = sha512s_parse_hash;
8331 sort_by_digest = sort_by_digest_8_8;
8332 opti_type = OPTI_TYPE_ZERO_BYTE
8333 | OPTI_TYPE_PRECOMPUTE_INIT
8334 | OPTI_TYPE_PRECOMPUTE_MERKLE
8335 | OPTI_TYPE_EARLY_SKIP
8336 | OPTI_TYPE_NOT_ITERATED
8337 | OPTI_TYPE_PREPENDED_SALT
8338 | OPTI_TYPE_USES_BITS_64
8339 | OPTI_TYPE_RAW_HASH;
8340 dgst_pos0 = 14;
8341 dgst_pos1 = 15;
8342 dgst_pos2 = 6;
8343 dgst_pos3 = 7;
8344 break;
8345
8346 case 1750: hash_type = HASH_TYPE_SHA512;
8347 salt_type = SALT_TYPE_INTERN;
8348 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8349 opts_type = OPTS_TYPE_PT_GENERATE_BE
8350 | OPTS_TYPE_ST_ADD80;
8351 kern_type = KERN_TYPE_HMACSHA512_PW;
8352 dgst_size = DGST_SIZE_8_8;
8353 parse_func = hmacsha512_parse_hash;
8354 sort_by_digest = sort_by_digest_8_8;
8355 opti_type = OPTI_TYPE_ZERO_BYTE
8356 | OPTI_TYPE_USES_BITS_64
8357 | OPTI_TYPE_NOT_ITERATED;
8358 dgst_pos0 = 14;
8359 dgst_pos1 = 15;
8360 dgst_pos2 = 6;
8361 dgst_pos3 = 7;
8362 break;
8363
8364 case 1760: hash_type = HASH_TYPE_SHA512;
8365 salt_type = SALT_TYPE_INTERN;
8366 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8367 opts_type = OPTS_TYPE_PT_GENERATE_BE
8368 | OPTS_TYPE_PT_ADD80
8369 | OPTS_TYPE_PT_ADDBITS15;
8370 kern_type = KERN_TYPE_HMACSHA512_SLT;
8371 dgst_size = DGST_SIZE_8_8;
8372 parse_func = hmacsha512_parse_hash;
8373 sort_by_digest = sort_by_digest_8_8;
8374 opti_type = OPTI_TYPE_ZERO_BYTE
8375 | OPTI_TYPE_USES_BITS_64
8376 | OPTI_TYPE_NOT_ITERATED;
8377 dgst_pos0 = 14;
8378 dgst_pos1 = 15;
8379 dgst_pos2 = 6;
8380 dgst_pos3 = 7;
8381 break;
8382
8383 case 1800: hash_type = HASH_TYPE_SHA512;
8384 salt_type = SALT_TYPE_EMBEDDED;
8385 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8386 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8387 kern_type = KERN_TYPE_SHA512CRYPT;
8388 dgst_size = DGST_SIZE_8_8;
8389 parse_func = sha512crypt_parse_hash;
8390 sort_by_digest = sort_by_digest_8_8;
8391 opti_type = OPTI_TYPE_ZERO_BYTE
8392 | OPTI_TYPE_USES_BITS_64;
8393 dgst_pos0 = 0;
8394 dgst_pos1 = 1;
8395 dgst_pos2 = 2;
8396 dgst_pos3 = 3;
8397 break;
8398
8399 case 2100: hash_type = HASH_TYPE_DCC2;
8400 salt_type = SALT_TYPE_EMBEDDED;
8401 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8402 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8403 | OPTS_TYPE_ST_LOWER
8404 | OPTS_TYPE_ST_UNICODE;
8405 kern_type = KERN_TYPE_DCC2;
8406 dgst_size = DGST_SIZE_4_4;
8407 parse_func = dcc2_parse_hash;
8408 sort_by_digest = sort_by_digest_4_4;
8409 opti_type = OPTI_TYPE_ZERO_BYTE
8410 | OPTI_TYPE_SLOW_HASH_SIMD;
8411 dgst_pos0 = 0;
8412 dgst_pos1 = 1;
8413 dgst_pos2 = 2;
8414 dgst_pos3 = 3;
8415 break;
8416
8417 case 2400: hash_type = HASH_TYPE_MD5;
8418 salt_type = SALT_TYPE_NONE;
8419 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8420 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8421 kern_type = KERN_TYPE_MD5PIX;
8422 dgst_size = DGST_SIZE_4_4;
8423 parse_func = md5pix_parse_hash;
8424 sort_by_digest = sort_by_digest_4_4;
8425 opti_type = OPTI_TYPE_ZERO_BYTE
8426 | OPTI_TYPE_PRECOMPUTE_INIT
8427 | OPTI_TYPE_PRECOMPUTE_MERKLE
8428 | OPTI_TYPE_EARLY_SKIP
8429 | OPTI_TYPE_NOT_ITERATED
8430 | OPTI_TYPE_NOT_SALTED;
8431 dgst_pos0 = 0;
8432 dgst_pos1 = 3;
8433 dgst_pos2 = 2;
8434 dgst_pos3 = 1;
8435 break;
8436
8437 case 2410: hash_type = HASH_TYPE_MD5;
8438 salt_type = SALT_TYPE_INTERN;
8439 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8440 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8441 kern_type = KERN_TYPE_MD5ASA;
8442 dgst_size = DGST_SIZE_4_4;
8443 parse_func = md5asa_parse_hash;
8444 sort_by_digest = sort_by_digest_4_4;
8445 opti_type = OPTI_TYPE_ZERO_BYTE
8446 | OPTI_TYPE_PRECOMPUTE_INIT
8447 | OPTI_TYPE_PRECOMPUTE_MERKLE
8448 | OPTI_TYPE_EARLY_SKIP
8449 | OPTI_TYPE_NOT_ITERATED;
8450 dgst_pos0 = 0;
8451 dgst_pos1 = 3;
8452 dgst_pos2 = 2;
8453 dgst_pos3 = 1;
8454 break;
8455
8456 case 2500: hash_type = HASH_TYPE_WPA;
8457 salt_type = SALT_TYPE_EMBEDDED;
8458 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8459 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8460 kern_type = KERN_TYPE_WPA;
8461 dgst_size = DGST_SIZE_4_4;
8462 parse_func = wpa_parse_hash;
8463 sort_by_digest = sort_by_digest_4_4;
8464 opti_type = OPTI_TYPE_ZERO_BYTE
8465 | OPTI_TYPE_SLOW_HASH_SIMD;
8466 dgst_pos0 = 0;
8467 dgst_pos1 = 1;
8468 dgst_pos2 = 2;
8469 dgst_pos3 = 3;
8470 break;
8471
8472 case 2600: hash_type = HASH_TYPE_MD5;
8473 salt_type = SALT_TYPE_VIRTUAL;
8474 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8475 opts_type = OPTS_TYPE_PT_GENERATE_LE
8476 | OPTS_TYPE_PT_ADD80
8477 | OPTS_TYPE_PT_ADDBITS14
8478 | OPTS_TYPE_ST_ADD80;
8479 kern_type = KERN_TYPE_MD55_PWSLT1;
8480 dgst_size = DGST_SIZE_4_4;
8481 parse_func = md5md5_parse_hash;
8482 sort_by_digest = sort_by_digest_4_4;
8483 opti_type = OPTI_TYPE_ZERO_BYTE
8484 | OPTI_TYPE_PRECOMPUTE_INIT
8485 | OPTI_TYPE_PRECOMPUTE_MERKLE
8486 | OPTI_TYPE_EARLY_SKIP;
8487 dgst_pos0 = 0;
8488 dgst_pos1 = 3;
8489 dgst_pos2 = 2;
8490 dgst_pos3 = 1;
8491 break;
8492
8493 case 2611: hash_type = HASH_TYPE_MD5;
8494 salt_type = SALT_TYPE_INTERN;
8495 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8496 opts_type = OPTS_TYPE_PT_GENERATE_LE
8497 | OPTS_TYPE_PT_ADD80
8498 | OPTS_TYPE_PT_ADDBITS14
8499 | OPTS_TYPE_ST_ADD80;
8500 kern_type = KERN_TYPE_MD55_PWSLT1;
8501 dgst_size = DGST_SIZE_4_4;
8502 parse_func = vb3_parse_hash;
8503 sort_by_digest = sort_by_digest_4_4;
8504 opti_type = OPTI_TYPE_ZERO_BYTE
8505 | OPTI_TYPE_PRECOMPUTE_INIT
8506 | OPTI_TYPE_PRECOMPUTE_MERKLE
8507 | OPTI_TYPE_EARLY_SKIP;
8508 dgst_pos0 = 0;
8509 dgst_pos1 = 3;
8510 dgst_pos2 = 2;
8511 dgst_pos3 = 1;
8512 break;
8513
8514 case 2612: hash_type = HASH_TYPE_MD5;
8515 salt_type = SALT_TYPE_EMBEDDED;
8516 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8517 opts_type = OPTS_TYPE_PT_GENERATE_LE
8518 | OPTS_TYPE_PT_ADD80
8519 | OPTS_TYPE_PT_ADDBITS14
8520 | OPTS_TYPE_ST_ADD80
8521 | OPTS_TYPE_ST_HEX;
8522 kern_type = KERN_TYPE_MD55_PWSLT1;
8523 dgst_size = DGST_SIZE_4_4;
8524 parse_func = phps_parse_hash;
8525 sort_by_digest = sort_by_digest_4_4;
8526 opti_type = OPTI_TYPE_ZERO_BYTE
8527 | OPTI_TYPE_PRECOMPUTE_INIT
8528 | OPTI_TYPE_PRECOMPUTE_MERKLE
8529 | OPTI_TYPE_EARLY_SKIP;
8530 dgst_pos0 = 0;
8531 dgst_pos1 = 3;
8532 dgst_pos2 = 2;
8533 dgst_pos3 = 1;
8534 break;
8535
8536 case 2711: hash_type = HASH_TYPE_MD5;
8537 salt_type = SALT_TYPE_INTERN;
8538 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8539 opts_type = OPTS_TYPE_PT_GENERATE_LE
8540 | OPTS_TYPE_PT_ADD80
8541 | OPTS_TYPE_PT_ADDBITS14
8542 | OPTS_TYPE_ST_ADD80;
8543 kern_type = KERN_TYPE_MD55_PWSLT2;
8544 dgst_size = DGST_SIZE_4_4;
8545 parse_func = vb30_parse_hash;
8546 sort_by_digest = sort_by_digest_4_4;
8547 opti_type = OPTI_TYPE_ZERO_BYTE
8548 | OPTI_TYPE_PRECOMPUTE_INIT
8549 | OPTI_TYPE_EARLY_SKIP;
8550 dgst_pos0 = 0;
8551 dgst_pos1 = 3;
8552 dgst_pos2 = 2;
8553 dgst_pos3 = 1;
8554 break;
8555
8556 case 2811: hash_type = HASH_TYPE_MD5;
8557 salt_type = SALT_TYPE_INTERN;
8558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8559 opts_type = OPTS_TYPE_PT_GENERATE_LE
8560 | OPTS_TYPE_PT_ADD80
8561 | OPTS_TYPE_PT_ADDBITS14;
8562 kern_type = KERN_TYPE_MD55_SLTPW;
8563 dgst_size = DGST_SIZE_4_4;
8564 parse_func = ipb2_parse_hash;
8565 sort_by_digest = sort_by_digest_4_4;
8566 opti_type = OPTI_TYPE_ZERO_BYTE
8567 | OPTI_TYPE_PRECOMPUTE_INIT
8568 | OPTI_TYPE_EARLY_SKIP;
8569 dgst_pos0 = 0;
8570 dgst_pos1 = 3;
8571 dgst_pos2 = 2;
8572 dgst_pos3 = 1;
8573 break;
8574
8575 case 3000: hash_type = HASH_TYPE_LM;
8576 salt_type = SALT_TYPE_NONE;
8577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8578 opts_type = OPTS_TYPE_PT_GENERATE_LE
8579 | OPTS_TYPE_PT_UPPER
8580 | OPTS_TYPE_PT_BITSLICE;
8581 kern_type = KERN_TYPE_LM;
8582 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8583 parse_func = lm_parse_hash;
8584 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8585 opti_type = OPTI_TYPE_ZERO_BYTE
8586 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8587 dgst_pos0 = 0;
8588 dgst_pos1 = 1;
8589 dgst_pos2 = 2;
8590 dgst_pos3 = 3;
8591 break;
8592
8593 case 3100: hash_type = HASH_TYPE_ORACLEH;
8594 salt_type = SALT_TYPE_INTERN;
8595 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8596 opts_type = OPTS_TYPE_PT_GENERATE_LE
8597 | OPTS_TYPE_PT_UPPER
8598 | OPTS_TYPE_ST_UPPER;
8599 kern_type = KERN_TYPE_ORACLEH;
8600 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8601 parse_func = oracleh_parse_hash;
8602 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8603 opti_type = OPTI_TYPE_ZERO_BYTE;
8604 dgst_pos0 = 0;
8605 dgst_pos1 = 1;
8606 dgst_pos2 = 2;
8607 dgst_pos3 = 3;
8608 break;
8609
8610 case 3200: hash_type = HASH_TYPE_BCRYPT;
8611 salt_type = SALT_TYPE_EMBEDDED;
8612 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8613 opts_type = OPTS_TYPE_PT_GENERATE_LE
8614 | OPTS_TYPE_ST_GENERATE_LE;
8615 kern_type = KERN_TYPE_BCRYPT;
8616 dgst_size = DGST_SIZE_4_6;
8617 parse_func = bcrypt_parse_hash;
8618 sort_by_digest = sort_by_digest_4_6;
8619 opti_type = OPTI_TYPE_ZERO_BYTE;
8620 dgst_pos0 = 0;
8621 dgst_pos1 = 1;
8622 dgst_pos2 = 2;
8623 dgst_pos3 = 3;
8624 break;
8625
8626 case 3710: hash_type = HASH_TYPE_MD5;
8627 salt_type = SALT_TYPE_INTERN;
8628 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8629 opts_type = OPTS_TYPE_PT_GENERATE_LE
8630 | OPTS_TYPE_PT_ADD80
8631 | OPTS_TYPE_PT_ADDBITS14;
8632 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8633 dgst_size = DGST_SIZE_4_4;
8634 parse_func = md5s_parse_hash;
8635 sort_by_digest = sort_by_digest_4_4;
8636 opti_type = OPTI_TYPE_ZERO_BYTE
8637 | OPTI_TYPE_PRECOMPUTE_INIT
8638 | OPTI_TYPE_PRECOMPUTE_MERKLE
8639 | OPTI_TYPE_EARLY_SKIP;
8640 dgst_pos0 = 0;
8641 dgst_pos1 = 3;
8642 dgst_pos2 = 2;
8643 dgst_pos3 = 1;
8644 break;
8645
8646 case 3711: hash_type = HASH_TYPE_MD5;
8647 salt_type = SALT_TYPE_EMBEDDED;
8648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8649 opts_type = OPTS_TYPE_PT_GENERATE_LE
8650 | OPTS_TYPE_PT_ADD80
8651 | OPTS_TYPE_PT_ADDBITS14;
8652 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8653 dgst_size = DGST_SIZE_4_4;
8654 parse_func = mediawiki_b_parse_hash;
8655 sort_by_digest = sort_by_digest_4_4;
8656 opti_type = OPTI_TYPE_ZERO_BYTE
8657 | OPTI_TYPE_PRECOMPUTE_INIT
8658 | OPTI_TYPE_PRECOMPUTE_MERKLE
8659 | OPTI_TYPE_EARLY_SKIP;
8660 dgst_pos0 = 0;
8661 dgst_pos1 = 3;
8662 dgst_pos2 = 2;
8663 dgst_pos3 = 1;
8664 break;
8665
8666 case 3800: hash_type = HASH_TYPE_MD5;
8667 salt_type = SALT_TYPE_INTERN;
8668 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8669 opts_type = OPTS_TYPE_PT_GENERATE_LE
8670 | OPTS_TYPE_ST_ADDBITS14;
8671 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8672 dgst_size = DGST_SIZE_4_4;
8673 parse_func = md5s_parse_hash;
8674 sort_by_digest = sort_by_digest_4_4;
8675 opti_type = OPTI_TYPE_ZERO_BYTE
8676 | OPTI_TYPE_PRECOMPUTE_INIT
8677 | OPTI_TYPE_PRECOMPUTE_MERKLE
8678 | OPTI_TYPE_EARLY_SKIP
8679 | OPTI_TYPE_NOT_ITERATED
8680 | OPTI_TYPE_RAW_HASH;
8681 dgst_pos0 = 0;
8682 dgst_pos1 = 3;
8683 dgst_pos2 = 2;
8684 dgst_pos3 = 1;
8685 break;
8686
8687 case 4300: hash_type = HASH_TYPE_MD5;
8688 salt_type = SALT_TYPE_VIRTUAL;
8689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8690 opts_type = OPTS_TYPE_PT_GENERATE_LE
8691 | OPTS_TYPE_PT_ADD80
8692 | OPTS_TYPE_PT_ADDBITS14
8693 | OPTS_TYPE_ST_ADD80;
8694 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8695 dgst_size = DGST_SIZE_4_4;
8696 parse_func = md5md5_parse_hash;
8697 sort_by_digest = sort_by_digest_4_4;
8698 opti_type = OPTI_TYPE_ZERO_BYTE
8699 | OPTI_TYPE_PRECOMPUTE_INIT
8700 | OPTI_TYPE_PRECOMPUTE_MERKLE
8701 | OPTI_TYPE_EARLY_SKIP;
8702 dgst_pos0 = 0;
8703 dgst_pos1 = 3;
8704 dgst_pos2 = 2;
8705 dgst_pos3 = 1;
8706 break;
8707
8708
8709 case 4400: hash_type = HASH_TYPE_MD5;
8710 salt_type = SALT_TYPE_NONE;
8711 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8712 opts_type = OPTS_TYPE_PT_GENERATE_BE
8713 | OPTS_TYPE_PT_ADD80
8714 | OPTS_TYPE_PT_ADDBITS15;
8715 kern_type = KERN_TYPE_MD5_SHA1;
8716 dgst_size = DGST_SIZE_4_4;
8717 parse_func = md5_parse_hash;
8718 sort_by_digest = sort_by_digest_4_4;
8719 opti_type = OPTI_TYPE_ZERO_BYTE
8720 | OPTI_TYPE_PRECOMPUTE_INIT
8721 | OPTI_TYPE_PRECOMPUTE_MERKLE
8722 | OPTI_TYPE_EARLY_SKIP
8723 | OPTI_TYPE_NOT_ITERATED
8724 | OPTI_TYPE_NOT_SALTED
8725 | OPTI_TYPE_RAW_HASH;
8726 dgst_pos0 = 0;
8727 dgst_pos1 = 3;
8728 dgst_pos2 = 2;
8729 dgst_pos3 = 1;
8730 break;
8731
8732 case 4500: hash_type = HASH_TYPE_SHA1;
8733 salt_type = SALT_TYPE_NONE;
8734 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8735 opts_type = OPTS_TYPE_PT_GENERATE_BE
8736 | OPTS_TYPE_PT_ADD80
8737 | OPTS_TYPE_PT_ADDBITS15;
8738 kern_type = KERN_TYPE_SHA11;
8739 dgst_size = DGST_SIZE_4_5;
8740 parse_func = sha1_parse_hash;
8741 sort_by_digest = sort_by_digest_4_5;
8742 opti_type = OPTI_TYPE_ZERO_BYTE
8743 | OPTI_TYPE_PRECOMPUTE_INIT
8744 | OPTI_TYPE_PRECOMPUTE_MERKLE
8745 | OPTI_TYPE_EARLY_SKIP
8746 | OPTI_TYPE_NOT_SALTED;
8747 dgst_pos0 = 3;
8748 dgst_pos1 = 4;
8749 dgst_pos2 = 2;
8750 dgst_pos3 = 1;
8751 break;
8752
8753 case 4700: hash_type = HASH_TYPE_SHA1;
8754 salt_type = SALT_TYPE_NONE;
8755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8756 opts_type = OPTS_TYPE_PT_GENERATE_LE
8757 | OPTS_TYPE_PT_ADD80
8758 | OPTS_TYPE_PT_ADDBITS14;
8759 kern_type = KERN_TYPE_SHA1_MD5;
8760 dgst_size = DGST_SIZE_4_5;
8761 parse_func = sha1_parse_hash;
8762 sort_by_digest = sort_by_digest_4_5;
8763 opti_type = OPTI_TYPE_ZERO_BYTE
8764 | OPTI_TYPE_PRECOMPUTE_INIT
8765 | OPTI_TYPE_PRECOMPUTE_MERKLE
8766 | OPTI_TYPE_EARLY_SKIP
8767 | OPTI_TYPE_NOT_ITERATED
8768 | OPTI_TYPE_NOT_SALTED
8769 | OPTI_TYPE_RAW_HASH;
8770 dgst_pos0 = 3;
8771 dgst_pos1 = 4;
8772 dgst_pos2 = 2;
8773 dgst_pos3 = 1;
8774 break;
8775
8776 case 4800: hash_type = HASH_TYPE_MD5;
8777 salt_type = SALT_TYPE_EMBEDDED;
8778 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8779 opts_type = OPTS_TYPE_PT_GENERATE_LE
8780 | OPTS_TYPE_PT_ADDBITS14;
8781 kern_type = KERN_TYPE_MD5_CHAP;
8782 dgst_size = DGST_SIZE_4_4;
8783 parse_func = chap_parse_hash;
8784 sort_by_digest = sort_by_digest_4_4;
8785 opti_type = OPTI_TYPE_ZERO_BYTE
8786 | OPTI_TYPE_PRECOMPUTE_INIT
8787 | OPTI_TYPE_PRECOMPUTE_MERKLE
8788 | OPTI_TYPE_MEET_IN_MIDDLE
8789 | OPTI_TYPE_EARLY_SKIP
8790 | OPTI_TYPE_NOT_ITERATED
8791 | OPTI_TYPE_RAW_HASH;
8792 dgst_pos0 = 0;
8793 dgst_pos1 = 3;
8794 dgst_pos2 = 2;
8795 dgst_pos3 = 1;
8796 break;
8797
8798 case 4900: hash_type = HASH_TYPE_SHA1;
8799 salt_type = SALT_TYPE_INTERN;
8800 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8801 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8802 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8803 dgst_size = DGST_SIZE_4_5;
8804 parse_func = sha1s_parse_hash;
8805 sort_by_digest = sort_by_digest_4_5;
8806 opti_type = OPTI_TYPE_ZERO_BYTE
8807 | OPTI_TYPE_PRECOMPUTE_INIT
8808 | OPTI_TYPE_PRECOMPUTE_MERKLE
8809 | OPTI_TYPE_EARLY_SKIP;
8810 dgst_pos0 = 3;
8811 dgst_pos1 = 4;
8812 dgst_pos2 = 2;
8813 dgst_pos3 = 1;
8814 break;
8815
8816 case 5000: hash_type = HASH_TYPE_KECCAK;
8817 salt_type = SALT_TYPE_EMBEDDED;
8818 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8819 opts_type = OPTS_TYPE_PT_GENERATE_LE
8820 | OPTS_TYPE_PT_ADD01;
8821 kern_type = KERN_TYPE_KECCAK;
8822 dgst_size = DGST_SIZE_8_25;
8823 parse_func = keccak_parse_hash;
8824 sort_by_digest = sort_by_digest_8_25;
8825 opti_type = OPTI_TYPE_ZERO_BYTE
8826 | OPTI_TYPE_USES_BITS_64
8827 | OPTI_TYPE_RAW_HASH;
8828 dgst_pos0 = 2;
8829 dgst_pos1 = 3;
8830 dgst_pos2 = 4;
8831 dgst_pos3 = 5;
8832 break;
8833
8834 case 5100: hash_type = HASH_TYPE_MD5H;
8835 salt_type = SALT_TYPE_NONE;
8836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8837 opts_type = OPTS_TYPE_PT_GENERATE_LE
8838 | OPTS_TYPE_PT_ADD80
8839 | OPTS_TYPE_PT_ADDBITS14;
8840 kern_type = KERN_TYPE_MD5H;
8841 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8842 parse_func = md5half_parse_hash;
8843 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8844 opti_type = OPTI_TYPE_ZERO_BYTE
8845 | OPTI_TYPE_RAW_HASH;
8846 dgst_pos0 = 0;
8847 dgst_pos1 = 1;
8848 dgst_pos2 = 2;
8849 dgst_pos3 = 3;
8850 break;
8851
8852 case 5200: hash_type = HASH_TYPE_SHA256;
8853 salt_type = SALT_TYPE_EMBEDDED;
8854 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8855 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8856 kern_type = KERN_TYPE_PSAFE3;
8857 dgst_size = DGST_SIZE_4_8;
8858 parse_func = psafe3_parse_hash;
8859 sort_by_digest = sort_by_digest_4_8;
8860 opti_type = OPTI_TYPE_ZERO_BYTE;
8861 dgst_pos0 = 0;
8862 dgst_pos1 = 1;
8863 dgst_pos2 = 2;
8864 dgst_pos3 = 3;
8865 break;
8866
8867 case 5300: hash_type = HASH_TYPE_MD5;
8868 salt_type = SALT_TYPE_EMBEDDED;
8869 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8870 opts_type = OPTS_TYPE_PT_GENERATE_LE
8871 | OPTS_TYPE_ST_ADD80;
8872 kern_type = KERN_TYPE_IKEPSK_MD5;
8873 dgst_size = DGST_SIZE_4_4;
8874 parse_func = ikepsk_md5_parse_hash;
8875 sort_by_digest = sort_by_digest_4_4;
8876 opti_type = OPTI_TYPE_ZERO_BYTE;
8877 dgst_pos0 = 0;
8878 dgst_pos1 = 3;
8879 dgst_pos2 = 2;
8880 dgst_pos3 = 1;
8881 break;
8882
8883 case 5400: hash_type = HASH_TYPE_SHA1;
8884 salt_type = SALT_TYPE_EMBEDDED;
8885 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8886 opts_type = OPTS_TYPE_PT_GENERATE_BE
8887 | OPTS_TYPE_ST_ADD80;
8888 kern_type = KERN_TYPE_IKEPSK_SHA1;
8889 dgst_size = DGST_SIZE_4_5;
8890 parse_func = ikepsk_sha1_parse_hash;
8891 sort_by_digest = sort_by_digest_4_5;
8892 opti_type = OPTI_TYPE_ZERO_BYTE;
8893 dgst_pos0 = 3;
8894 dgst_pos1 = 4;
8895 dgst_pos2 = 2;
8896 dgst_pos3 = 1;
8897 break;
8898
8899 case 5500: hash_type = HASH_TYPE_NETNTLM;
8900 salt_type = SALT_TYPE_EMBEDDED;
8901 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8902 opts_type = OPTS_TYPE_PT_GENERATE_LE
8903 | OPTS_TYPE_PT_ADD80
8904 | OPTS_TYPE_PT_ADDBITS14
8905 | OPTS_TYPE_PT_UNICODE
8906 | OPTS_TYPE_ST_HEX;
8907 kern_type = KERN_TYPE_NETNTLMv1;
8908 dgst_size = DGST_SIZE_4_4;
8909 parse_func = netntlmv1_parse_hash;
8910 sort_by_digest = sort_by_digest_4_4;
8911 opti_type = OPTI_TYPE_ZERO_BYTE
8912 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8913 dgst_pos0 = 0;
8914 dgst_pos1 = 1;
8915 dgst_pos2 = 2;
8916 dgst_pos3 = 3;
8917 break;
8918
8919 case 5600: hash_type = HASH_TYPE_MD5;
8920 salt_type = SALT_TYPE_EMBEDDED;
8921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8922 opts_type = OPTS_TYPE_PT_GENERATE_LE
8923 | OPTS_TYPE_PT_ADD80
8924 | OPTS_TYPE_PT_ADDBITS14
8925 | OPTS_TYPE_PT_UNICODE;
8926 kern_type = KERN_TYPE_NETNTLMv2;
8927 dgst_size = DGST_SIZE_4_4;
8928 parse_func = netntlmv2_parse_hash;
8929 sort_by_digest = sort_by_digest_4_4;
8930 opti_type = OPTI_TYPE_ZERO_BYTE;
8931 dgst_pos0 = 0;
8932 dgst_pos1 = 3;
8933 dgst_pos2 = 2;
8934 dgst_pos3 = 1;
8935 break;
8936
8937 case 5700: hash_type = HASH_TYPE_SHA256;
8938 salt_type = SALT_TYPE_NONE;
8939 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8940 opts_type = OPTS_TYPE_PT_GENERATE_BE
8941 | OPTS_TYPE_PT_ADD80
8942 | OPTS_TYPE_PT_ADDBITS15;
8943 kern_type = KERN_TYPE_SHA256;
8944 dgst_size = DGST_SIZE_4_8;
8945 parse_func = cisco4_parse_hash;
8946 sort_by_digest = sort_by_digest_4_8;
8947 opti_type = OPTI_TYPE_ZERO_BYTE
8948 | OPTI_TYPE_PRECOMPUTE_INIT
8949 | OPTI_TYPE_PRECOMPUTE_MERKLE
8950 | OPTI_TYPE_EARLY_SKIP
8951 | OPTI_TYPE_NOT_ITERATED
8952 | OPTI_TYPE_NOT_SALTED
8953 | OPTI_TYPE_RAW_HASH;
8954 dgst_pos0 = 3;
8955 dgst_pos1 = 7;
8956 dgst_pos2 = 2;
8957 dgst_pos3 = 6;
8958 break;
8959
8960 case 5800: hash_type = HASH_TYPE_SHA1;
8961 salt_type = SALT_TYPE_INTERN;
8962 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8963 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8964 | OPTS_TYPE_ST_ADD80;
8965 kern_type = KERN_TYPE_ANDROIDPIN;
8966 dgst_size = DGST_SIZE_4_5;
8967 parse_func = androidpin_parse_hash;
8968 sort_by_digest = sort_by_digest_4_5;
8969 opti_type = OPTI_TYPE_ZERO_BYTE;
8970 dgst_pos0 = 0;
8971 dgst_pos1 = 1;
8972 dgst_pos2 = 2;
8973 dgst_pos3 = 3;
8974 break;
8975
8976 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8977 salt_type = SALT_TYPE_NONE;
8978 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8979 opts_type = OPTS_TYPE_PT_GENERATE_LE
8980 | OPTS_TYPE_PT_ADD80;
8981 kern_type = KERN_TYPE_RIPEMD160;
8982 dgst_size = DGST_SIZE_4_5;
8983 parse_func = ripemd160_parse_hash;
8984 sort_by_digest = sort_by_digest_4_5;
8985 opti_type = OPTI_TYPE_ZERO_BYTE;
8986 dgst_pos0 = 0;
8987 dgst_pos1 = 1;
8988 dgst_pos2 = 2;
8989 dgst_pos3 = 3;
8990 break;
8991
8992 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8993 salt_type = SALT_TYPE_NONE;
8994 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8995 opts_type = OPTS_TYPE_PT_GENERATE_BE
8996 | OPTS_TYPE_PT_ADD80;
8997 kern_type = KERN_TYPE_WHIRLPOOL;
8998 dgst_size = DGST_SIZE_4_16;
8999 parse_func = whirlpool_parse_hash;
9000 sort_by_digest = sort_by_digest_4_16;
9001 opti_type = OPTI_TYPE_ZERO_BYTE;
9002 dgst_pos0 = 0;
9003 dgst_pos1 = 1;
9004 dgst_pos2 = 2;
9005 dgst_pos3 = 3;
9006 break;
9007
9008 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9009 salt_type = SALT_TYPE_EMBEDDED;
9010 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9011 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9012 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9013 dgst_size = DGST_SIZE_4_5;
9014 parse_func = truecrypt_parse_hash_2k;
9015 sort_by_digest = sort_by_digest_4_5;
9016 opti_type = OPTI_TYPE_ZERO_BYTE;
9017 dgst_pos0 = 0;
9018 dgst_pos1 = 1;
9019 dgst_pos2 = 2;
9020 dgst_pos3 = 3;
9021 break;
9022
9023 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9024 salt_type = SALT_TYPE_EMBEDDED;
9025 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9026 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9027 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9028 dgst_size = DGST_SIZE_4_5;
9029 parse_func = truecrypt_parse_hash_2k;
9030 sort_by_digest = sort_by_digest_4_5;
9031 opti_type = OPTI_TYPE_ZERO_BYTE;
9032 dgst_pos0 = 0;
9033 dgst_pos1 = 1;
9034 dgst_pos2 = 2;
9035 dgst_pos3 = 3;
9036 break;
9037
9038 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9039 salt_type = SALT_TYPE_EMBEDDED;
9040 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9041 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9042 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9043 dgst_size = DGST_SIZE_4_5;
9044 parse_func = truecrypt_parse_hash_2k;
9045 sort_by_digest = sort_by_digest_4_5;
9046 opti_type = OPTI_TYPE_ZERO_BYTE;
9047 dgst_pos0 = 0;
9048 dgst_pos1 = 1;
9049 dgst_pos2 = 2;
9050 dgst_pos3 = 3;
9051 break;
9052
9053 case 6221: hash_type = HASH_TYPE_SHA512;
9054 salt_type = SALT_TYPE_EMBEDDED;
9055 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9056 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9057 kern_type = KERN_TYPE_TCSHA512_XTS512;
9058 dgst_size = DGST_SIZE_8_8;
9059 parse_func = truecrypt_parse_hash_1k;
9060 sort_by_digest = sort_by_digest_8_8;
9061 opti_type = OPTI_TYPE_ZERO_BYTE
9062 | OPTI_TYPE_USES_BITS_64;
9063 dgst_pos0 = 0;
9064 dgst_pos1 = 1;
9065 dgst_pos2 = 2;
9066 dgst_pos3 = 3;
9067 break;
9068
9069 case 6222: hash_type = HASH_TYPE_SHA512;
9070 salt_type = SALT_TYPE_EMBEDDED;
9071 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9072 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9073 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9074 dgst_size = DGST_SIZE_8_8;
9075 parse_func = truecrypt_parse_hash_1k;
9076 sort_by_digest = sort_by_digest_8_8;
9077 opti_type = OPTI_TYPE_ZERO_BYTE
9078 | OPTI_TYPE_USES_BITS_64;
9079 dgst_pos0 = 0;
9080 dgst_pos1 = 1;
9081 dgst_pos2 = 2;
9082 dgst_pos3 = 3;
9083 break;
9084
9085 case 6223: hash_type = HASH_TYPE_SHA512;
9086 salt_type = SALT_TYPE_EMBEDDED;
9087 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9088 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9089 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9090 dgst_size = DGST_SIZE_8_8;
9091 parse_func = truecrypt_parse_hash_1k;
9092 sort_by_digest = sort_by_digest_8_8;
9093 opti_type = OPTI_TYPE_ZERO_BYTE
9094 | OPTI_TYPE_USES_BITS_64;
9095 dgst_pos0 = 0;
9096 dgst_pos1 = 1;
9097 dgst_pos2 = 2;
9098 dgst_pos3 = 3;
9099 break;
9100
9101 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9102 salt_type = SALT_TYPE_EMBEDDED;
9103 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9104 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9105 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9106 dgst_size = DGST_SIZE_4_8;
9107 parse_func = truecrypt_parse_hash_1k;
9108 sort_by_digest = sort_by_digest_4_8;
9109 opti_type = OPTI_TYPE_ZERO_BYTE;
9110 dgst_pos0 = 0;
9111 dgst_pos1 = 1;
9112 dgst_pos2 = 2;
9113 dgst_pos3 = 3;
9114 break;
9115
9116 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9117 salt_type = SALT_TYPE_EMBEDDED;
9118 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9119 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9120 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9121 dgst_size = DGST_SIZE_4_8;
9122 parse_func = truecrypt_parse_hash_1k;
9123 sort_by_digest = sort_by_digest_4_8;
9124 opti_type = OPTI_TYPE_ZERO_BYTE;
9125 dgst_pos0 = 0;
9126 dgst_pos1 = 1;
9127 dgst_pos2 = 2;
9128 dgst_pos3 = 3;
9129 break;
9130
9131 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9132 salt_type = SALT_TYPE_EMBEDDED;
9133 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9134 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9135 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9136 dgst_size = DGST_SIZE_4_8;
9137 parse_func = truecrypt_parse_hash_1k;
9138 sort_by_digest = sort_by_digest_4_8;
9139 opti_type = OPTI_TYPE_ZERO_BYTE;
9140 dgst_pos0 = 0;
9141 dgst_pos1 = 1;
9142 dgst_pos2 = 2;
9143 dgst_pos3 = 3;
9144 break;
9145
9146 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9147 salt_type = SALT_TYPE_EMBEDDED;
9148 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9149 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9150 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9151 dgst_size = DGST_SIZE_4_5;
9152 parse_func = truecrypt_parse_hash_1k;
9153 sort_by_digest = sort_by_digest_4_5;
9154 opti_type = OPTI_TYPE_ZERO_BYTE;
9155 dgst_pos0 = 0;
9156 dgst_pos1 = 1;
9157 dgst_pos2 = 2;
9158 dgst_pos3 = 3;
9159 break;
9160
9161 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9162 salt_type = SALT_TYPE_EMBEDDED;
9163 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9164 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9165 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9166 dgst_size = DGST_SIZE_4_5;
9167 parse_func = truecrypt_parse_hash_1k;
9168 sort_by_digest = sort_by_digest_4_5;
9169 opti_type = OPTI_TYPE_ZERO_BYTE;
9170 dgst_pos0 = 0;
9171 dgst_pos1 = 1;
9172 dgst_pos2 = 2;
9173 dgst_pos3 = 3;
9174 break;
9175
9176 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9177 salt_type = SALT_TYPE_EMBEDDED;
9178 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9179 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9180 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9181 dgst_size = DGST_SIZE_4_5;
9182 parse_func = truecrypt_parse_hash_1k;
9183 sort_by_digest = sort_by_digest_4_5;
9184 opti_type = OPTI_TYPE_ZERO_BYTE;
9185 dgst_pos0 = 0;
9186 dgst_pos1 = 1;
9187 dgst_pos2 = 2;
9188 dgst_pos3 = 3;
9189 break;
9190
9191 case 6300: hash_type = HASH_TYPE_MD5;
9192 salt_type = SALT_TYPE_EMBEDDED;
9193 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9194 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9195 kern_type = KERN_TYPE_MD5AIX;
9196 dgst_size = DGST_SIZE_4_4;
9197 parse_func = md5aix_parse_hash;
9198 sort_by_digest = sort_by_digest_4_4;
9199 opti_type = OPTI_TYPE_ZERO_BYTE;
9200 dgst_pos0 = 0;
9201 dgst_pos1 = 1;
9202 dgst_pos2 = 2;
9203 dgst_pos3 = 3;
9204 break;
9205
9206 case 6400: hash_type = HASH_TYPE_SHA256;
9207 salt_type = SALT_TYPE_EMBEDDED;
9208 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9209 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9210 kern_type = KERN_TYPE_SHA256AIX;
9211 dgst_size = DGST_SIZE_4_8;
9212 parse_func = sha256aix_parse_hash;
9213 sort_by_digest = sort_by_digest_4_8;
9214 opti_type = OPTI_TYPE_ZERO_BYTE;
9215 dgst_pos0 = 0;
9216 dgst_pos1 = 1;
9217 dgst_pos2 = 2;
9218 dgst_pos3 = 3;
9219 break;
9220
9221 case 6500: hash_type = HASH_TYPE_SHA512;
9222 salt_type = SALT_TYPE_EMBEDDED;
9223 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9224 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9225 kern_type = KERN_TYPE_SHA512AIX;
9226 dgst_size = DGST_SIZE_8_8;
9227 parse_func = sha512aix_parse_hash;
9228 sort_by_digest = sort_by_digest_8_8;
9229 opti_type = OPTI_TYPE_ZERO_BYTE
9230 | OPTI_TYPE_USES_BITS_64;
9231 dgst_pos0 = 0;
9232 dgst_pos1 = 1;
9233 dgst_pos2 = 2;
9234 dgst_pos3 = 3;
9235 break;
9236
9237 case 6600: hash_type = HASH_TYPE_AES;
9238 salt_type = SALT_TYPE_EMBEDDED;
9239 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9240 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9241 kern_type = KERN_TYPE_AGILEKEY;
9242 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9243 parse_func = agilekey_parse_hash;
9244 sort_by_digest = sort_by_digest_4_5;
9245 opti_type = OPTI_TYPE_ZERO_BYTE;
9246 dgst_pos0 = 0;
9247 dgst_pos1 = 1;
9248 dgst_pos2 = 2;
9249 dgst_pos3 = 3;
9250 break;
9251
9252 case 6700: hash_type = HASH_TYPE_SHA1;
9253 salt_type = SALT_TYPE_EMBEDDED;
9254 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9255 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9256 kern_type = KERN_TYPE_SHA1AIX;
9257 dgst_size = DGST_SIZE_4_5;
9258 parse_func = sha1aix_parse_hash;
9259 sort_by_digest = sort_by_digest_4_5;
9260 opti_type = OPTI_TYPE_ZERO_BYTE;
9261 dgst_pos0 = 0;
9262 dgst_pos1 = 1;
9263 dgst_pos2 = 2;
9264 dgst_pos3 = 3;
9265 break;
9266
9267 case 6800: hash_type = HASH_TYPE_AES;
9268 salt_type = SALT_TYPE_EMBEDDED;
9269 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9270 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9271 kern_type = KERN_TYPE_LASTPASS;
9272 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9273 parse_func = lastpass_parse_hash;
9274 sort_by_digest = sort_by_digest_4_8;
9275 opti_type = OPTI_TYPE_ZERO_BYTE;
9276 dgst_pos0 = 0;
9277 dgst_pos1 = 1;
9278 dgst_pos2 = 2;
9279 dgst_pos3 = 3;
9280 break;
9281
9282 case 6900: hash_type = HASH_TYPE_GOST;
9283 salt_type = SALT_TYPE_NONE;
9284 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9285 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9286 kern_type = KERN_TYPE_GOST;
9287 dgst_size = DGST_SIZE_4_8;
9288 parse_func = gost_parse_hash;
9289 sort_by_digest = sort_by_digest_4_8;
9290 opti_type = OPTI_TYPE_ZERO_BYTE;
9291 dgst_pos0 = 0;
9292 dgst_pos1 = 1;
9293 dgst_pos2 = 2;
9294 dgst_pos3 = 3;
9295 break;
9296
9297 case 7100: hash_type = HASH_TYPE_SHA512;
9298 salt_type = SALT_TYPE_EMBEDDED;
9299 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9300 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9301 kern_type = KERN_TYPE_PBKDF2_SHA512;
9302 dgst_size = DGST_SIZE_8_16;
9303 parse_func = sha512osx_parse_hash;
9304 sort_by_digest = sort_by_digest_8_16;
9305 opti_type = OPTI_TYPE_ZERO_BYTE
9306 | OPTI_TYPE_USES_BITS_64
9307 | OPTI_TYPE_SLOW_HASH_SIMD;
9308 dgst_pos0 = 0;
9309 dgst_pos1 = 1;
9310 dgst_pos2 = 2;
9311 dgst_pos3 = 3;
9312 break;
9313
9314 case 7200: hash_type = HASH_TYPE_SHA512;
9315 salt_type = SALT_TYPE_EMBEDDED;
9316 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9317 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9318 kern_type = KERN_TYPE_PBKDF2_SHA512;
9319 dgst_size = DGST_SIZE_8_16;
9320 parse_func = sha512grub_parse_hash;
9321 sort_by_digest = sort_by_digest_8_16;
9322 opti_type = OPTI_TYPE_ZERO_BYTE
9323 | OPTI_TYPE_USES_BITS_64
9324 | OPTI_TYPE_SLOW_HASH_SIMD;
9325 dgst_pos0 = 0;
9326 dgst_pos1 = 1;
9327 dgst_pos2 = 2;
9328 dgst_pos3 = 3;
9329 break;
9330
9331 case 7300: hash_type = HASH_TYPE_SHA1;
9332 salt_type = SALT_TYPE_EMBEDDED;
9333 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9334 opts_type = OPTS_TYPE_PT_GENERATE_BE
9335 | OPTS_TYPE_ST_ADD80
9336 | OPTS_TYPE_ST_ADDBITS15;
9337 kern_type = KERN_TYPE_RAKP;
9338 dgst_size = DGST_SIZE_4_5;
9339 parse_func = rakp_parse_hash;
9340 sort_by_digest = sort_by_digest_4_5;
9341 opti_type = OPTI_TYPE_ZERO_BYTE
9342 | OPTI_TYPE_NOT_ITERATED;
9343 dgst_pos0 = 3;
9344 dgst_pos1 = 4;
9345 dgst_pos2 = 2;
9346 dgst_pos3 = 1;
9347 break;
9348
9349 case 7400: hash_type = HASH_TYPE_SHA256;
9350 salt_type = SALT_TYPE_EMBEDDED;
9351 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9352 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9353 kern_type = KERN_TYPE_SHA256CRYPT;
9354 dgst_size = DGST_SIZE_4_8;
9355 parse_func = sha256crypt_parse_hash;
9356 sort_by_digest = sort_by_digest_4_8;
9357 opti_type = OPTI_TYPE_ZERO_BYTE;
9358 dgst_pos0 = 0;
9359 dgst_pos1 = 1;
9360 dgst_pos2 = 2;
9361 dgst_pos3 = 3;
9362 break;
9363
9364 case 7500: hash_type = HASH_TYPE_KRB5PA;
9365 salt_type = SALT_TYPE_EMBEDDED;
9366 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9367 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9368 kern_type = KERN_TYPE_KRB5PA;
9369 dgst_size = DGST_SIZE_4_4;
9370 parse_func = krb5pa_parse_hash;
9371 sort_by_digest = sort_by_digest_4_4;
9372 opti_type = OPTI_TYPE_ZERO_BYTE
9373 | OPTI_TYPE_NOT_ITERATED;
9374 dgst_pos0 = 0;
9375 dgst_pos1 = 1;
9376 dgst_pos2 = 2;
9377 dgst_pos3 = 3;
9378 break;
9379
9380 case 7600: hash_type = HASH_TYPE_SHA1;
9381 salt_type = SALT_TYPE_INTERN;
9382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9383 opts_type = OPTS_TYPE_PT_GENERATE_BE
9384 | OPTS_TYPE_PT_ADD80
9385 | OPTS_TYPE_PT_ADDBITS15;
9386 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9387 dgst_size = DGST_SIZE_4_5;
9388 parse_func = redmine_parse_hash;
9389 sort_by_digest = sort_by_digest_4_5;
9390 opti_type = OPTI_TYPE_ZERO_BYTE
9391 | OPTI_TYPE_PRECOMPUTE_INIT
9392 | OPTI_TYPE_EARLY_SKIP
9393 | OPTI_TYPE_NOT_ITERATED
9394 | OPTI_TYPE_PREPENDED_SALT;
9395 dgst_pos0 = 3;
9396 dgst_pos1 = 4;
9397 dgst_pos2 = 2;
9398 dgst_pos3 = 1;
9399 break;
9400
9401 case 7700: hash_type = HASH_TYPE_SAPB;
9402 salt_type = SALT_TYPE_EMBEDDED;
9403 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9404 opts_type = OPTS_TYPE_PT_GENERATE_LE
9405 | OPTS_TYPE_PT_UPPER
9406 | OPTS_TYPE_ST_UPPER;
9407 kern_type = KERN_TYPE_SAPB;
9408 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9409 parse_func = sapb_parse_hash;
9410 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9411 opti_type = OPTI_TYPE_ZERO_BYTE
9412 | OPTI_TYPE_PRECOMPUTE_INIT
9413 | OPTI_TYPE_NOT_ITERATED;
9414 dgst_pos0 = 0;
9415 dgst_pos1 = 1;
9416 dgst_pos2 = 2;
9417 dgst_pos3 = 3;
9418 break;
9419
9420 case 7800: hash_type = HASH_TYPE_SAPG;
9421 salt_type = SALT_TYPE_EMBEDDED;
9422 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9423 opts_type = OPTS_TYPE_PT_GENERATE_BE
9424 | OPTS_TYPE_ST_ADD80
9425 | OPTS_TYPE_ST_UPPER;
9426 kern_type = KERN_TYPE_SAPG;
9427 dgst_size = DGST_SIZE_4_5;
9428 parse_func = sapg_parse_hash;
9429 sort_by_digest = sort_by_digest_4_5;
9430 opti_type = OPTI_TYPE_ZERO_BYTE
9431 | OPTI_TYPE_PRECOMPUTE_INIT
9432 | OPTI_TYPE_NOT_ITERATED;
9433 dgst_pos0 = 3;
9434 dgst_pos1 = 4;
9435 dgst_pos2 = 2;
9436 dgst_pos3 = 1;
9437 break;
9438
9439 case 7900: hash_type = HASH_TYPE_SHA512;
9440 salt_type = SALT_TYPE_EMBEDDED;
9441 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9442 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9443 kern_type = KERN_TYPE_DRUPAL7;
9444 dgst_size = DGST_SIZE_8_8;
9445 parse_func = drupal7_parse_hash;
9446 sort_by_digest = sort_by_digest_8_8;
9447 opti_type = OPTI_TYPE_ZERO_BYTE
9448 | OPTI_TYPE_USES_BITS_64;
9449 dgst_pos0 = 0;
9450 dgst_pos1 = 1;
9451 dgst_pos2 = 2;
9452 dgst_pos3 = 3;
9453 break;
9454
9455 case 8000: hash_type = HASH_TYPE_SHA256;
9456 salt_type = SALT_TYPE_EMBEDDED;
9457 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9458 opts_type = OPTS_TYPE_PT_GENERATE_BE
9459 | OPTS_TYPE_PT_UNICODE
9460 | OPTS_TYPE_ST_ADD80
9461 | OPTS_TYPE_ST_HEX;
9462 kern_type = KERN_TYPE_SYBASEASE;
9463 dgst_size = DGST_SIZE_4_8;
9464 parse_func = sybasease_parse_hash;
9465 sort_by_digest = sort_by_digest_4_8;
9466 opti_type = OPTI_TYPE_ZERO_BYTE
9467 | OPTI_TYPE_PRECOMPUTE_INIT
9468 | OPTI_TYPE_EARLY_SKIP
9469 | OPTI_TYPE_NOT_ITERATED
9470 | OPTI_TYPE_RAW_HASH;
9471 dgst_pos0 = 3;
9472 dgst_pos1 = 7;
9473 dgst_pos2 = 2;
9474 dgst_pos3 = 6;
9475 break;
9476
9477 case 8100: hash_type = HASH_TYPE_SHA1;
9478 salt_type = SALT_TYPE_EMBEDDED;
9479 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9480 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9481 kern_type = KERN_TYPE_NETSCALER;
9482 dgst_size = DGST_SIZE_4_5;
9483 parse_func = netscaler_parse_hash;
9484 sort_by_digest = sort_by_digest_4_5;
9485 opti_type = OPTI_TYPE_ZERO_BYTE
9486 | OPTI_TYPE_PRECOMPUTE_INIT
9487 | OPTI_TYPE_PRECOMPUTE_MERKLE
9488 | OPTI_TYPE_EARLY_SKIP
9489 | OPTI_TYPE_NOT_ITERATED
9490 | OPTI_TYPE_PREPENDED_SALT
9491 | OPTI_TYPE_RAW_HASH;
9492 dgst_pos0 = 3;
9493 dgst_pos1 = 4;
9494 dgst_pos2 = 2;
9495 dgst_pos3 = 1;
9496 break;
9497
9498 case 8200: hash_type = HASH_TYPE_SHA256;
9499 salt_type = SALT_TYPE_EMBEDDED;
9500 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9501 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9502 kern_type = KERN_TYPE_CLOUDKEY;
9503 dgst_size = DGST_SIZE_4_8;
9504 parse_func = cloudkey_parse_hash;
9505 sort_by_digest = sort_by_digest_4_8;
9506 opti_type = OPTI_TYPE_ZERO_BYTE;
9507 dgst_pos0 = 0;
9508 dgst_pos1 = 1;
9509 dgst_pos2 = 2;
9510 dgst_pos3 = 3;
9511 break;
9512
9513 case 8300: hash_type = HASH_TYPE_SHA1;
9514 salt_type = SALT_TYPE_EMBEDDED;
9515 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9516 opts_type = OPTS_TYPE_PT_GENERATE_BE
9517 | OPTS_TYPE_ST_HEX
9518 | OPTS_TYPE_ST_ADD80;
9519 kern_type = KERN_TYPE_NSEC3;
9520 dgst_size = DGST_SIZE_4_5;
9521 parse_func = nsec3_parse_hash;
9522 sort_by_digest = sort_by_digest_4_5;
9523 opti_type = OPTI_TYPE_ZERO_BYTE;
9524 dgst_pos0 = 3;
9525 dgst_pos1 = 4;
9526 dgst_pos2 = 2;
9527 dgst_pos3 = 1;
9528 break;
9529
9530 case 8400: hash_type = HASH_TYPE_SHA1;
9531 salt_type = SALT_TYPE_INTERN;
9532 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9533 opts_type = OPTS_TYPE_PT_GENERATE_BE
9534 | OPTS_TYPE_PT_ADD80
9535 | OPTS_TYPE_PT_ADDBITS15;
9536 kern_type = KERN_TYPE_WBB3;
9537 dgst_size = DGST_SIZE_4_5;
9538 parse_func = wbb3_parse_hash;
9539 sort_by_digest = sort_by_digest_4_5;
9540 opti_type = OPTI_TYPE_ZERO_BYTE
9541 | OPTI_TYPE_PRECOMPUTE_INIT
9542 | OPTI_TYPE_NOT_ITERATED;
9543 dgst_pos0 = 3;
9544 dgst_pos1 = 4;
9545 dgst_pos2 = 2;
9546 dgst_pos3 = 1;
9547 break;
9548
9549 case 8500: hash_type = HASH_TYPE_DESRACF;
9550 salt_type = SALT_TYPE_EMBEDDED;
9551 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9552 opts_type = OPTS_TYPE_PT_GENERATE_LE
9553 | OPTS_TYPE_ST_UPPER;
9554 kern_type = KERN_TYPE_RACF;
9555 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9556 parse_func = racf_parse_hash;
9557 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9558 opti_type = OPTI_TYPE_ZERO_BYTE
9559 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9560 dgst_pos0 = 0;
9561 dgst_pos1 = 1;
9562 dgst_pos2 = 2;
9563 dgst_pos3 = 3;
9564 break;
9565
9566 case 8600: hash_type = HASH_TYPE_LOTUS5;
9567 salt_type = SALT_TYPE_NONE;
9568 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9569 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9570 kern_type = KERN_TYPE_LOTUS5;
9571 dgst_size = DGST_SIZE_4_4;
9572 parse_func = lotus5_parse_hash;
9573 sort_by_digest = sort_by_digest_4_4;
9574 opti_type = OPTI_TYPE_EARLY_SKIP
9575 | OPTI_TYPE_NOT_ITERATED
9576 | OPTI_TYPE_NOT_SALTED
9577 | OPTI_TYPE_RAW_HASH;
9578 dgst_pos0 = 0;
9579 dgst_pos1 = 1;
9580 dgst_pos2 = 2;
9581 dgst_pos3 = 3;
9582 break;
9583
9584 case 8700: hash_type = HASH_TYPE_LOTUS6;
9585 salt_type = SALT_TYPE_EMBEDDED;
9586 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9587 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9588 kern_type = KERN_TYPE_LOTUS6;
9589 dgst_size = DGST_SIZE_4_4;
9590 parse_func = lotus6_parse_hash;
9591 sort_by_digest = sort_by_digest_4_4;
9592 opti_type = OPTI_TYPE_EARLY_SKIP
9593 | OPTI_TYPE_NOT_ITERATED
9594 | OPTI_TYPE_RAW_HASH;
9595 dgst_pos0 = 0;
9596 dgst_pos1 = 1;
9597 dgst_pos2 = 2;
9598 dgst_pos3 = 3;
9599 break;
9600
9601 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9602 salt_type = SALT_TYPE_EMBEDDED;
9603 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9604 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9605 kern_type = KERN_TYPE_ANDROIDFDE;
9606 dgst_size = DGST_SIZE_4_4;
9607 parse_func = androidfde_parse_hash;
9608 sort_by_digest = sort_by_digest_4_4;
9609 opti_type = OPTI_TYPE_ZERO_BYTE;
9610 dgst_pos0 = 0;
9611 dgst_pos1 = 1;
9612 dgst_pos2 = 2;
9613 dgst_pos3 = 3;
9614 break;
9615
9616 case 8900: hash_type = HASH_TYPE_SCRYPT;
9617 salt_type = SALT_TYPE_EMBEDDED;
9618 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9619 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9620 kern_type = KERN_TYPE_SCRYPT;
9621 dgst_size = DGST_SIZE_4_8;
9622 parse_func = scrypt_parse_hash;
9623 sort_by_digest = sort_by_digest_4_8;
9624 opti_type = OPTI_TYPE_ZERO_BYTE;
9625 dgst_pos0 = 0;
9626 dgst_pos1 = 1;
9627 dgst_pos2 = 2;
9628 dgst_pos3 = 3;
9629 break;
9630
9631 case 9000: hash_type = HASH_TYPE_SHA1;
9632 salt_type = SALT_TYPE_EMBEDDED;
9633 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9634 opts_type = OPTS_TYPE_PT_GENERATE_LE
9635 | OPTS_TYPE_ST_GENERATE_LE;
9636 kern_type = KERN_TYPE_PSAFE2;
9637 dgst_size = DGST_SIZE_4_5;
9638 parse_func = psafe2_parse_hash;
9639 sort_by_digest = sort_by_digest_4_5;
9640 opti_type = OPTI_TYPE_ZERO_BYTE;
9641 dgst_pos0 = 0;
9642 dgst_pos1 = 1;
9643 dgst_pos2 = 2;
9644 dgst_pos3 = 3;
9645 break;
9646
9647 case 9100: hash_type = HASH_TYPE_LOTUS8;
9648 salt_type = SALT_TYPE_EMBEDDED;
9649 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9650 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9651 kern_type = KERN_TYPE_LOTUS8;
9652 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9653 parse_func = lotus8_parse_hash;
9654 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9655 opti_type = OPTI_TYPE_ZERO_BYTE;
9656 dgst_pos0 = 0;
9657 dgst_pos1 = 1;
9658 dgst_pos2 = 2;
9659 dgst_pos3 = 3;
9660 break;
9661
9662 case 9200: hash_type = HASH_TYPE_SHA256;
9663 salt_type = SALT_TYPE_EMBEDDED;
9664 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9665 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9666 kern_type = KERN_TYPE_PBKDF2_SHA256;
9667 dgst_size = DGST_SIZE_4_32;
9668 parse_func = cisco8_parse_hash;
9669 sort_by_digest = sort_by_digest_4_32;
9670 opti_type = OPTI_TYPE_ZERO_BYTE
9671 | OPTI_TYPE_SLOW_HASH_SIMD;
9672 dgst_pos0 = 0;
9673 dgst_pos1 = 1;
9674 dgst_pos2 = 2;
9675 dgst_pos3 = 3;
9676 break;
9677
9678 case 9300: hash_type = HASH_TYPE_SCRYPT;
9679 salt_type = SALT_TYPE_EMBEDDED;
9680 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9681 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9682 kern_type = KERN_TYPE_SCRYPT;
9683 dgst_size = DGST_SIZE_4_8;
9684 parse_func = cisco9_parse_hash;
9685 sort_by_digest = sort_by_digest_4_8;
9686 opti_type = OPTI_TYPE_ZERO_BYTE;
9687 dgst_pos0 = 0;
9688 dgst_pos1 = 1;
9689 dgst_pos2 = 2;
9690 dgst_pos3 = 3;
9691 break;
9692
9693 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9694 salt_type = SALT_TYPE_EMBEDDED;
9695 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9696 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9697 kern_type = KERN_TYPE_OFFICE2007;
9698 dgst_size = DGST_SIZE_4_4;
9699 parse_func = office2007_parse_hash;
9700 sort_by_digest = sort_by_digest_4_4;
9701 opti_type = OPTI_TYPE_ZERO_BYTE;
9702 dgst_pos0 = 0;
9703 dgst_pos1 = 1;
9704 dgst_pos2 = 2;
9705 dgst_pos3 = 3;
9706 break;
9707
9708 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9709 salt_type = SALT_TYPE_EMBEDDED;
9710 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9711 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9712 kern_type = KERN_TYPE_OFFICE2010;
9713 dgst_size = DGST_SIZE_4_4;
9714 parse_func = office2010_parse_hash;
9715 sort_by_digest = sort_by_digest_4_4;
9716 opti_type = OPTI_TYPE_ZERO_BYTE;
9717 dgst_pos0 = 0;
9718 dgst_pos1 = 1;
9719 dgst_pos2 = 2;
9720 dgst_pos3 = 3;
9721 break;
9722
9723 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9724 salt_type = SALT_TYPE_EMBEDDED;
9725 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9726 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9727 kern_type = KERN_TYPE_OFFICE2013;
9728 dgst_size = DGST_SIZE_4_4;
9729 parse_func = office2013_parse_hash;
9730 sort_by_digest = sort_by_digest_4_4;
9731 opti_type = OPTI_TYPE_ZERO_BYTE;
9732 dgst_pos0 = 0;
9733 dgst_pos1 = 1;
9734 dgst_pos2 = 2;
9735 dgst_pos3 = 3;
9736 break;
9737
9738 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9739 salt_type = SALT_TYPE_EMBEDDED;
9740 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9741 opts_type = OPTS_TYPE_PT_GENERATE_LE
9742 | OPTS_TYPE_PT_ADD80
9743 | OPTS_TYPE_PT_UNICODE;
9744 kern_type = KERN_TYPE_OLDOFFICE01;
9745 dgst_size = DGST_SIZE_4_4;
9746 parse_func = oldoffice01_parse_hash;
9747 sort_by_digest = sort_by_digest_4_4;
9748 opti_type = OPTI_TYPE_ZERO_BYTE
9749 | OPTI_TYPE_PRECOMPUTE_INIT
9750 | OPTI_TYPE_NOT_ITERATED;
9751 dgst_pos0 = 0;
9752 dgst_pos1 = 1;
9753 dgst_pos2 = 2;
9754 dgst_pos3 = 3;
9755 break;
9756
9757 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9758 salt_type = SALT_TYPE_EMBEDDED;
9759 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9760 opts_type = OPTS_TYPE_PT_GENERATE_LE
9761 | OPTS_TYPE_PT_ADD80;
9762 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9763 dgst_size = DGST_SIZE_4_4;
9764 parse_func = oldoffice01cm1_parse_hash;
9765 sort_by_digest = sort_by_digest_4_4;
9766 opti_type = OPTI_TYPE_ZERO_BYTE
9767 | OPTI_TYPE_PRECOMPUTE_INIT
9768 | OPTI_TYPE_NOT_ITERATED;
9769 dgst_pos0 = 0;
9770 dgst_pos1 = 1;
9771 dgst_pos2 = 2;
9772 dgst_pos3 = 3;
9773 break;
9774
9775 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9776 salt_type = SALT_TYPE_EMBEDDED;
9777 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9778 opts_type = OPTS_TYPE_PT_GENERATE_LE
9779 | OPTS_TYPE_PT_ADD80
9780 | OPTS_TYPE_PT_UNICODE
9781 | OPTS_TYPE_PT_NEVERCRACK;
9782 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9783 dgst_size = DGST_SIZE_4_4;
9784 parse_func = oldoffice01cm2_parse_hash;
9785 sort_by_digest = sort_by_digest_4_4;
9786 opti_type = OPTI_TYPE_ZERO_BYTE
9787 | OPTI_TYPE_PRECOMPUTE_INIT
9788 | OPTI_TYPE_NOT_ITERATED;
9789 dgst_pos0 = 0;
9790 dgst_pos1 = 1;
9791 dgst_pos2 = 2;
9792 dgst_pos3 = 3;
9793 break;
9794
9795 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9796 salt_type = SALT_TYPE_EMBEDDED;
9797 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9798 opts_type = OPTS_TYPE_PT_GENERATE_BE
9799 | OPTS_TYPE_PT_ADD80
9800 | OPTS_TYPE_PT_UNICODE;
9801 kern_type = KERN_TYPE_OLDOFFICE34;
9802 dgst_size = DGST_SIZE_4_4;
9803 parse_func = oldoffice34_parse_hash;
9804 sort_by_digest = sort_by_digest_4_4;
9805 opti_type = OPTI_TYPE_ZERO_BYTE
9806 | OPTI_TYPE_PRECOMPUTE_INIT
9807 | OPTI_TYPE_NOT_ITERATED;
9808 dgst_pos0 = 0;
9809 dgst_pos1 = 1;
9810 dgst_pos2 = 2;
9811 dgst_pos3 = 3;
9812 break;
9813
9814 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9815 salt_type = SALT_TYPE_EMBEDDED;
9816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9817 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9818 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9819 dgst_size = DGST_SIZE_4_4;
9820 parse_func = oldoffice34cm1_parse_hash;
9821 sort_by_digest = sort_by_digest_4_4;
9822 opti_type = OPTI_TYPE_ZERO_BYTE
9823 | OPTI_TYPE_PRECOMPUTE_INIT
9824 | OPTI_TYPE_NOT_ITERATED;
9825 dgst_pos0 = 0;
9826 dgst_pos1 = 1;
9827 dgst_pos2 = 2;
9828 dgst_pos3 = 3;
9829 break;
9830
9831 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9832 salt_type = SALT_TYPE_EMBEDDED;
9833 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9834 opts_type = OPTS_TYPE_PT_GENERATE_BE
9835 | OPTS_TYPE_PT_ADD80
9836 | OPTS_TYPE_PT_UNICODE
9837 | OPTS_TYPE_PT_NEVERCRACK;
9838 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9839 dgst_size = DGST_SIZE_4_4;
9840 parse_func = oldoffice34cm2_parse_hash;
9841 sort_by_digest = sort_by_digest_4_4;
9842 opti_type = OPTI_TYPE_ZERO_BYTE
9843 | OPTI_TYPE_PRECOMPUTE_INIT
9844 | OPTI_TYPE_NOT_ITERATED;
9845 dgst_pos0 = 0;
9846 dgst_pos1 = 1;
9847 dgst_pos2 = 2;
9848 dgst_pos3 = 3;
9849 break;
9850
9851 case 9900: hash_type = HASH_TYPE_MD5;
9852 salt_type = SALT_TYPE_NONE;
9853 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9854 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9855 kern_type = KERN_TYPE_RADMIN2;
9856 dgst_size = DGST_SIZE_4_4;
9857 parse_func = radmin2_parse_hash;
9858 sort_by_digest = sort_by_digest_4_4;
9859 opti_type = OPTI_TYPE_ZERO_BYTE
9860 | OPTI_TYPE_PRECOMPUTE_INIT
9861 | OPTI_TYPE_EARLY_SKIP
9862 | OPTI_TYPE_NOT_ITERATED
9863 | OPTI_TYPE_NOT_SALTED;
9864 dgst_pos0 = 0;
9865 dgst_pos1 = 3;
9866 dgst_pos2 = 2;
9867 dgst_pos3 = 1;
9868 break;
9869
9870 case 10000: hash_type = HASH_TYPE_SHA256;
9871 salt_type = SALT_TYPE_EMBEDDED;
9872 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9873 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9874 kern_type = KERN_TYPE_PBKDF2_SHA256;
9875 dgst_size = DGST_SIZE_4_32;
9876 parse_func = djangopbkdf2_parse_hash;
9877 sort_by_digest = sort_by_digest_4_32;
9878 opti_type = OPTI_TYPE_ZERO_BYTE
9879 | OPTI_TYPE_SLOW_HASH_SIMD;
9880 dgst_pos0 = 0;
9881 dgst_pos1 = 1;
9882 dgst_pos2 = 2;
9883 dgst_pos3 = 3;
9884 break;
9885
9886 case 10100: hash_type = HASH_TYPE_SIPHASH;
9887 salt_type = SALT_TYPE_EMBEDDED;
9888 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9889 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9890 kern_type = KERN_TYPE_SIPHASH;
9891 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9892 parse_func = siphash_parse_hash;
9893 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9894 opti_type = OPTI_TYPE_ZERO_BYTE
9895 | OPTI_TYPE_NOT_ITERATED
9896 | OPTI_TYPE_RAW_HASH;
9897 dgst_pos0 = 0;
9898 dgst_pos1 = 1;
9899 dgst_pos2 = 2;
9900 dgst_pos3 = 3;
9901 break;
9902
9903 case 10200: hash_type = HASH_TYPE_MD5;
9904 salt_type = SALT_TYPE_EMBEDDED;
9905 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9906 opts_type = OPTS_TYPE_PT_GENERATE_LE
9907 | OPTS_TYPE_ST_ADD80
9908 | OPTS_TYPE_ST_ADDBITS14;
9909 kern_type = KERN_TYPE_HMACMD5_PW;
9910 dgst_size = DGST_SIZE_4_4;
9911 parse_func = crammd5_parse_hash;
9912 sort_by_digest = sort_by_digest_4_4;
9913 opti_type = OPTI_TYPE_ZERO_BYTE
9914 | OPTI_TYPE_NOT_ITERATED;
9915 dgst_pos0 = 0;
9916 dgst_pos1 = 3;
9917 dgst_pos2 = 2;
9918 dgst_pos3 = 1;
9919 break;
9920
9921 case 10300: hash_type = HASH_TYPE_SHA1;
9922 salt_type = SALT_TYPE_EMBEDDED;
9923 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9924 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9925 kern_type = KERN_TYPE_SAPH_SHA1;
9926 dgst_size = DGST_SIZE_4_5;
9927 parse_func = saph_sha1_parse_hash;
9928 sort_by_digest = sort_by_digest_4_5;
9929 opti_type = OPTI_TYPE_ZERO_BYTE;
9930 dgst_pos0 = 0;
9931 dgst_pos1 = 1;
9932 dgst_pos2 = 2;
9933 dgst_pos3 = 3;
9934 break;
9935
9936 case 10400: hash_type = HASH_TYPE_PDFU16;
9937 salt_type = SALT_TYPE_EMBEDDED;
9938 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9939 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9940 kern_type = KERN_TYPE_PDF11;
9941 dgst_size = DGST_SIZE_4_4;
9942 parse_func = pdf11_parse_hash;
9943 sort_by_digest = sort_by_digest_4_4;
9944 opti_type = OPTI_TYPE_ZERO_BYTE
9945 | OPTI_TYPE_NOT_ITERATED;
9946 dgst_pos0 = 0;
9947 dgst_pos1 = 1;
9948 dgst_pos2 = 2;
9949 dgst_pos3 = 3;
9950 break;
9951
9952 case 10410: hash_type = HASH_TYPE_PDFU16;
9953 salt_type = SALT_TYPE_EMBEDDED;
9954 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9955 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9956 kern_type = KERN_TYPE_PDF11CM1;
9957 dgst_size = DGST_SIZE_4_4;
9958 parse_func = pdf11cm1_parse_hash;
9959 sort_by_digest = sort_by_digest_4_4;
9960 opti_type = OPTI_TYPE_ZERO_BYTE
9961 | OPTI_TYPE_NOT_ITERATED;
9962 dgst_pos0 = 0;
9963 dgst_pos1 = 1;
9964 dgst_pos2 = 2;
9965 dgst_pos3 = 3;
9966 break;
9967
9968 case 10420: hash_type = HASH_TYPE_PDFU16;
9969 salt_type = SALT_TYPE_EMBEDDED;
9970 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9971 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9972 kern_type = KERN_TYPE_PDF11CM2;
9973 dgst_size = DGST_SIZE_4_4;
9974 parse_func = pdf11cm2_parse_hash;
9975 sort_by_digest = sort_by_digest_4_4;
9976 opti_type = OPTI_TYPE_ZERO_BYTE
9977 | OPTI_TYPE_NOT_ITERATED;
9978 dgst_pos0 = 0;
9979 dgst_pos1 = 1;
9980 dgst_pos2 = 2;
9981 dgst_pos3 = 3;
9982 break;
9983
9984 case 10500: hash_type = HASH_TYPE_PDFU16;
9985 salt_type = SALT_TYPE_EMBEDDED;
9986 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9987 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9988 kern_type = KERN_TYPE_PDF14;
9989 dgst_size = DGST_SIZE_4_4;
9990 parse_func = pdf14_parse_hash;
9991 sort_by_digest = sort_by_digest_4_4;
9992 opti_type = OPTI_TYPE_ZERO_BYTE
9993 | OPTI_TYPE_NOT_ITERATED;
9994 dgst_pos0 = 0;
9995 dgst_pos1 = 1;
9996 dgst_pos2 = 2;
9997 dgst_pos3 = 3;
9998 break;
9999
10000 case 10600: hash_type = HASH_TYPE_SHA256;
10001 salt_type = SALT_TYPE_EMBEDDED;
10002 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10003 opts_type = OPTS_TYPE_PT_GENERATE_BE
10004 | OPTS_TYPE_ST_ADD80
10005 | OPTS_TYPE_ST_ADDBITS15
10006 | OPTS_TYPE_HASH_COPY;
10007 kern_type = KERN_TYPE_SHA256_PWSLT;
10008 dgst_size = DGST_SIZE_4_8;
10009 parse_func = pdf17l3_parse_hash;
10010 sort_by_digest = sort_by_digest_4_8;
10011 opti_type = OPTI_TYPE_ZERO_BYTE
10012 | OPTI_TYPE_PRECOMPUTE_INIT
10013 | OPTI_TYPE_PRECOMPUTE_MERKLE
10014 | OPTI_TYPE_EARLY_SKIP
10015 | OPTI_TYPE_NOT_ITERATED
10016 | OPTI_TYPE_APPENDED_SALT
10017 | OPTI_TYPE_RAW_HASH;
10018 dgst_pos0 = 3;
10019 dgst_pos1 = 7;
10020 dgst_pos2 = 2;
10021 dgst_pos3 = 6;
10022 break;
10023
10024 case 10700: hash_type = HASH_TYPE_PDFU32;
10025 salt_type = SALT_TYPE_EMBEDDED;
10026 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10027 opts_type = OPTS_TYPE_PT_GENERATE_LE
10028 | OPTS_TYPE_HASH_COPY;
10029 kern_type = KERN_TYPE_PDF17L8;
10030 dgst_size = DGST_SIZE_4_8;
10031 parse_func = pdf17l8_parse_hash;
10032 sort_by_digest = sort_by_digest_4_8;
10033 opti_type = OPTI_TYPE_ZERO_BYTE
10034 | OPTI_TYPE_NOT_ITERATED;
10035 dgst_pos0 = 0;
10036 dgst_pos1 = 1;
10037 dgst_pos2 = 2;
10038 dgst_pos3 = 3;
10039 break;
10040
10041 case 10800: hash_type = HASH_TYPE_SHA384;
10042 salt_type = SALT_TYPE_NONE;
10043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10044 opts_type = OPTS_TYPE_PT_GENERATE_BE
10045 | OPTS_TYPE_PT_ADD80
10046 | OPTS_TYPE_PT_ADDBITS15;
10047 kern_type = KERN_TYPE_SHA384;
10048 dgst_size = DGST_SIZE_8_8;
10049 parse_func = sha384_parse_hash;
10050 sort_by_digest = sort_by_digest_8_8;
10051 opti_type = OPTI_TYPE_ZERO_BYTE
10052 | OPTI_TYPE_PRECOMPUTE_INIT
10053 | OPTI_TYPE_PRECOMPUTE_MERKLE
10054 | OPTI_TYPE_EARLY_SKIP
10055 | OPTI_TYPE_NOT_ITERATED
10056 | OPTI_TYPE_NOT_SALTED
10057 | OPTI_TYPE_USES_BITS_64
10058 | OPTI_TYPE_RAW_HASH;
10059 dgst_pos0 = 6;
10060 dgst_pos1 = 7;
10061 dgst_pos2 = 4;
10062 dgst_pos3 = 5;
10063 break;
10064
10065 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10066 salt_type = SALT_TYPE_EMBEDDED;
10067 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10068 opts_type = OPTS_TYPE_PT_GENERATE_LE
10069 | OPTS_TYPE_ST_BASE64
10070 | OPTS_TYPE_HASH_COPY;
10071 kern_type = KERN_TYPE_PBKDF2_SHA256;
10072 dgst_size = DGST_SIZE_4_32;
10073 parse_func = pbkdf2_sha256_parse_hash;
10074 sort_by_digest = sort_by_digest_4_32;
10075 opti_type = OPTI_TYPE_ZERO_BYTE
10076 | OPTI_TYPE_SLOW_HASH_SIMD;
10077 dgst_pos0 = 0;
10078 dgst_pos1 = 1;
10079 dgst_pos2 = 2;
10080 dgst_pos3 = 3;
10081 break;
10082
10083 case 11000: hash_type = HASH_TYPE_MD5;
10084 salt_type = SALT_TYPE_INTERN;
10085 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10086 opts_type = OPTS_TYPE_PT_GENERATE_LE
10087 | OPTS_TYPE_PT_ADD80;
10088 kern_type = KERN_TYPE_PRESTASHOP;
10089 dgst_size = DGST_SIZE_4_4;
10090 parse_func = prestashop_parse_hash;
10091 sort_by_digest = sort_by_digest_4_4;
10092 opti_type = OPTI_TYPE_ZERO_BYTE
10093 | OPTI_TYPE_PRECOMPUTE_INIT
10094 | OPTI_TYPE_NOT_ITERATED
10095 | OPTI_TYPE_PREPENDED_SALT;
10096 dgst_pos0 = 0;
10097 dgst_pos1 = 3;
10098 dgst_pos2 = 2;
10099 dgst_pos3 = 1;
10100 break;
10101
10102 case 11100: hash_type = HASH_TYPE_MD5;
10103 salt_type = SALT_TYPE_EMBEDDED;
10104 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10105 opts_type = OPTS_TYPE_PT_GENERATE_LE
10106 | OPTS_TYPE_ST_ADD80;
10107 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10108 dgst_size = DGST_SIZE_4_4;
10109 parse_func = postgresql_auth_parse_hash;
10110 sort_by_digest = sort_by_digest_4_4;
10111 opti_type = OPTI_TYPE_ZERO_BYTE
10112 | OPTI_TYPE_PRECOMPUTE_INIT
10113 | OPTI_TYPE_PRECOMPUTE_MERKLE
10114 | OPTI_TYPE_EARLY_SKIP;
10115 dgst_pos0 = 0;
10116 dgst_pos1 = 3;
10117 dgst_pos2 = 2;
10118 dgst_pos3 = 1;
10119 break;
10120
10121 case 11200: hash_type = HASH_TYPE_SHA1;
10122 salt_type = SALT_TYPE_EMBEDDED;
10123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10124 opts_type = OPTS_TYPE_PT_GENERATE_BE
10125 | OPTS_TYPE_PT_ADD80
10126 | OPTS_TYPE_ST_HEX;
10127 kern_type = KERN_TYPE_MYSQL_AUTH;
10128 dgst_size = DGST_SIZE_4_5;
10129 parse_func = mysql_auth_parse_hash;
10130 sort_by_digest = sort_by_digest_4_5;
10131 opti_type = OPTI_TYPE_ZERO_BYTE
10132 | OPTI_TYPE_EARLY_SKIP;
10133 dgst_pos0 = 3;
10134 dgst_pos1 = 4;
10135 dgst_pos2 = 2;
10136 dgst_pos3 = 1;
10137 break;
10138
10139 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10140 salt_type = SALT_TYPE_EMBEDDED;
10141 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10142 opts_type = OPTS_TYPE_PT_GENERATE_LE
10143 | OPTS_TYPE_ST_HEX
10144 | OPTS_TYPE_ST_ADD80;
10145 kern_type = KERN_TYPE_BITCOIN_WALLET;
10146 dgst_size = DGST_SIZE_4_4;
10147 parse_func = bitcoin_wallet_parse_hash;
10148 sort_by_digest = sort_by_digest_4_4;
10149 opti_type = OPTI_TYPE_ZERO_BYTE;
10150 dgst_pos0 = 0;
10151 dgst_pos1 = 1;
10152 dgst_pos2 = 2;
10153 dgst_pos3 = 3;
10154 break;
10155
10156 case 11400: hash_type = HASH_TYPE_MD5;
10157 salt_type = SALT_TYPE_EMBEDDED;
10158 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10159 opts_type = OPTS_TYPE_PT_GENERATE_LE
10160 | OPTS_TYPE_PT_ADD80
10161 | OPTS_TYPE_HASH_COPY;
10162 kern_type = KERN_TYPE_SIP_AUTH;
10163 dgst_size = DGST_SIZE_4_4;
10164 parse_func = sip_auth_parse_hash;
10165 sort_by_digest = sort_by_digest_4_4;
10166 opti_type = OPTI_TYPE_ZERO_BYTE;
10167 dgst_pos0 = 0;
10168 dgst_pos1 = 3;
10169 dgst_pos2 = 2;
10170 dgst_pos3 = 1;
10171 break;
10172
10173 case 11500: hash_type = HASH_TYPE_CRC32;
10174 salt_type = SALT_TYPE_INTERN;
10175 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10176 opts_type = OPTS_TYPE_PT_GENERATE_LE
10177 | OPTS_TYPE_ST_GENERATE_LE
10178 | OPTS_TYPE_ST_HEX;
10179 kern_type = KERN_TYPE_CRC32;
10180 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10181 parse_func = crc32_parse_hash;
10182 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10183 opti_type = OPTI_TYPE_ZERO_BYTE;
10184 dgst_pos0 = 0;
10185 dgst_pos1 = 1;
10186 dgst_pos2 = 2;
10187 dgst_pos3 = 3;
10188 break;
10189
10190 case 11600: hash_type = HASH_TYPE_AES;
10191 salt_type = SALT_TYPE_EMBEDDED;
10192 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10193 opts_type = OPTS_TYPE_PT_GENERATE_LE
10194 | OPTS_TYPE_PT_NEVERCRACK;
10195 kern_type = KERN_TYPE_SEVEN_ZIP;
10196 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10197 parse_func = seven_zip_parse_hash;
10198 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10199 opti_type = OPTI_TYPE_ZERO_BYTE;
10200 dgst_pos0 = 0;
10201 dgst_pos1 = 1;
10202 dgst_pos2 = 2;
10203 dgst_pos3 = 3;
10204 break;
10205
10206 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10207 salt_type = SALT_TYPE_NONE;
10208 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10209 opts_type = OPTS_TYPE_PT_GENERATE_LE
10210 | OPTS_TYPE_PT_ADD01;
10211 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10212 dgst_size = DGST_SIZE_4_8;
10213 parse_func = gost2012sbog_256_parse_hash;
10214 sort_by_digest = sort_by_digest_4_8;
10215 opti_type = OPTI_TYPE_ZERO_BYTE;
10216 dgst_pos0 = 0;
10217 dgst_pos1 = 1;
10218 dgst_pos2 = 2;
10219 dgst_pos3 = 3;
10220 break;
10221
10222 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10223 salt_type = SALT_TYPE_NONE;
10224 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10225 opts_type = OPTS_TYPE_PT_GENERATE_LE
10226 | OPTS_TYPE_PT_ADD01;
10227 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10228 dgst_size = DGST_SIZE_4_16;
10229 parse_func = gost2012sbog_512_parse_hash;
10230 sort_by_digest = sort_by_digest_4_16;
10231 opti_type = OPTI_TYPE_ZERO_BYTE;
10232 dgst_pos0 = 0;
10233 dgst_pos1 = 1;
10234 dgst_pos2 = 2;
10235 dgst_pos3 = 3;
10236 break;
10237
10238 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10239 salt_type = SALT_TYPE_EMBEDDED;
10240 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10241 opts_type = OPTS_TYPE_PT_GENERATE_LE
10242 | OPTS_TYPE_ST_BASE64
10243 | OPTS_TYPE_HASH_COPY;
10244 kern_type = KERN_TYPE_PBKDF2_MD5;
10245 dgst_size = DGST_SIZE_4_32;
10246 parse_func = pbkdf2_md5_parse_hash;
10247 sort_by_digest = sort_by_digest_4_32;
10248 opti_type = OPTI_TYPE_ZERO_BYTE
10249 | OPTI_TYPE_SLOW_HASH_SIMD;
10250 dgst_pos0 = 0;
10251 dgst_pos1 = 1;
10252 dgst_pos2 = 2;
10253 dgst_pos3 = 3;
10254 break;
10255
10256 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10257 salt_type = SALT_TYPE_EMBEDDED;
10258 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10259 opts_type = OPTS_TYPE_PT_GENERATE_LE
10260 | OPTS_TYPE_ST_BASE64
10261 | OPTS_TYPE_HASH_COPY;
10262 kern_type = KERN_TYPE_PBKDF2_SHA1;
10263 dgst_size = DGST_SIZE_4_32;
10264 parse_func = pbkdf2_sha1_parse_hash;
10265 sort_by_digest = sort_by_digest_4_32;
10266 opti_type = OPTI_TYPE_ZERO_BYTE
10267 | OPTI_TYPE_SLOW_HASH_SIMD;
10268 dgst_pos0 = 0;
10269 dgst_pos1 = 1;
10270 dgst_pos2 = 2;
10271 dgst_pos3 = 3;
10272 break;
10273
10274 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10275 salt_type = SALT_TYPE_EMBEDDED;
10276 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10277 opts_type = OPTS_TYPE_PT_GENERATE_LE
10278 | OPTS_TYPE_ST_BASE64
10279 | OPTS_TYPE_HASH_COPY;
10280 kern_type = KERN_TYPE_PBKDF2_SHA512;
10281 dgst_size = DGST_SIZE_8_16;
10282 parse_func = pbkdf2_sha512_parse_hash;
10283 sort_by_digest = sort_by_digest_8_16;
10284 opti_type = OPTI_TYPE_ZERO_BYTE
10285 | OPTI_TYPE_USES_BITS_64
10286 | OPTI_TYPE_SLOW_HASH_SIMD;
10287 dgst_pos0 = 0;
10288 dgst_pos1 = 1;
10289 dgst_pos2 = 2;
10290 dgst_pos3 = 3;
10291 break;
10292
10293 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10294 salt_type = SALT_TYPE_EMBEDDED;
10295 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10296 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10297 kern_type = KERN_TYPE_ECRYPTFS;
10298 dgst_size = DGST_SIZE_8_8;
10299 parse_func = ecryptfs_parse_hash;
10300 sort_by_digest = sort_by_digest_8_8;
10301 opti_type = OPTI_TYPE_ZERO_BYTE
10302 | OPTI_TYPE_USES_BITS_64;
10303 dgst_pos0 = 0;
10304 dgst_pos1 = 1;
10305 dgst_pos2 = 2;
10306 dgst_pos3 = 3;
10307 break;
10308
10309 case 12300: hash_type = HASH_TYPE_ORACLET;
10310 salt_type = SALT_TYPE_EMBEDDED;
10311 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10312 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10313 kern_type = KERN_TYPE_ORACLET;
10314 dgst_size = DGST_SIZE_8_16;
10315 parse_func = oraclet_parse_hash;
10316 sort_by_digest = sort_by_digest_8_16;
10317 opti_type = OPTI_TYPE_ZERO_BYTE
10318 | OPTI_TYPE_USES_BITS_64;
10319 dgst_pos0 = 0;
10320 dgst_pos1 = 1;
10321 dgst_pos2 = 2;
10322 dgst_pos3 = 3;
10323 break;
10324
10325 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10326 salt_type = SALT_TYPE_EMBEDDED;
10327 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10328 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10329 kern_type = KERN_TYPE_BSDICRYPT;
10330 dgst_size = DGST_SIZE_4_4;
10331 parse_func = bsdicrypt_parse_hash;
10332 sort_by_digest = sort_by_digest_4_4;
10333 opti_type = OPTI_TYPE_ZERO_BYTE
10334 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10335 dgst_pos0 = 0;
10336 dgst_pos1 = 1;
10337 dgst_pos2 = 2;
10338 dgst_pos3 = 3;
10339 break;
10340
10341 case 12500: hash_type = HASH_TYPE_RAR3HP;
10342 salt_type = SALT_TYPE_EMBEDDED;
10343 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10344 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10345 kern_type = KERN_TYPE_RAR3;
10346 dgst_size = DGST_SIZE_4_4;
10347 parse_func = rar3hp_parse_hash;
10348 sort_by_digest = sort_by_digest_4_4;
10349 opti_type = OPTI_TYPE_ZERO_BYTE;
10350 dgst_pos0 = 0;
10351 dgst_pos1 = 1;
10352 dgst_pos2 = 2;
10353 dgst_pos3 = 3;
10354 break;
10355
10356 case 12600: hash_type = HASH_TYPE_SHA256;
10357 salt_type = SALT_TYPE_INTERN;
10358 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10359 opts_type = OPTS_TYPE_PT_GENERATE_BE
10360 | OPTS_TYPE_PT_ADD80;
10361 kern_type = KERN_TYPE_CF10;
10362 dgst_size = DGST_SIZE_4_8;
10363 parse_func = cf10_parse_hash;
10364 sort_by_digest = sort_by_digest_4_8;
10365 opti_type = OPTI_TYPE_ZERO_BYTE
10366 | OPTI_TYPE_PRECOMPUTE_INIT
10367 | OPTI_TYPE_EARLY_SKIP
10368 | OPTI_TYPE_NOT_ITERATED;
10369 dgst_pos0 = 3;
10370 dgst_pos1 = 7;
10371 dgst_pos2 = 2;
10372 dgst_pos3 = 6;
10373 break;
10374
10375 case 12700: hash_type = HASH_TYPE_AES;
10376 salt_type = SALT_TYPE_EMBEDDED;
10377 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10378 opts_type = OPTS_TYPE_PT_GENERATE_LE
10379 | OPTS_TYPE_HASH_COPY;
10380 kern_type = KERN_TYPE_MYWALLET;
10381 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10382 parse_func = mywallet_parse_hash;
10383 sort_by_digest = sort_by_digest_4_5;
10384 opti_type = OPTI_TYPE_ZERO_BYTE;
10385 dgst_pos0 = 0;
10386 dgst_pos1 = 1;
10387 dgst_pos2 = 2;
10388 dgst_pos3 = 3;
10389 break;
10390
10391 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10392 salt_type = SALT_TYPE_EMBEDDED;
10393 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10394 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10395 kern_type = KERN_TYPE_MS_DRSR;
10396 dgst_size = DGST_SIZE_4_8;
10397 parse_func = ms_drsr_parse_hash;
10398 sort_by_digest = sort_by_digest_4_8;
10399 opti_type = OPTI_TYPE_ZERO_BYTE;
10400 dgst_pos0 = 0;
10401 dgst_pos1 = 1;
10402 dgst_pos2 = 2;
10403 dgst_pos3 = 3;
10404 break;
10405
10406 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10407 salt_type = SALT_TYPE_EMBEDDED;
10408 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10409 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10410 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10411 dgst_size = DGST_SIZE_4_8;
10412 parse_func = androidfde_samsung_parse_hash;
10413 sort_by_digest = sort_by_digest_4_8;
10414 opti_type = OPTI_TYPE_ZERO_BYTE;
10415 dgst_pos0 = 0;
10416 dgst_pos1 = 1;
10417 dgst_pos2 = 2;
10418 dgst_pos3 = 3;
10419 break;
10420
10421 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10422 salt_type = SALT_TYPE_EMBEDDED;
10423 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10424 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10425 kern_type = KERN_TYPE_RAR5;
10426 dgst_size = DGST_SIZE_4_4;
10427 parse_func = rar5_parse_hash;
10428 sort_by_digest = sort_by_digest_4_4;
10429 opti_type = OPTI_TYPE_ZERO_BYTE;
10430 dgst_pos0 = 0;
10431 dgst_pos1 = 1;
10432 dgst_pos2 = 2;
10433 dgst_pos3 = 3;
10434 break;
10435
10436 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10437 salt_type = SALT_TYPE_EMBEDDED;
10438 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10439 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10440 kern_type = KERN_TYPE_KRB5TGS;
10441 dgst_size = DGST_SIZE_4_4;
10442 parse_func = krb5tgs_parse_hash;
10443 sort_by_digest = sort_by_digest_4_4;
10444 opti_type = OPTI_TYPE_ZERO_BYTE
10445 | OPTI_TYPE_NOT_ITERATED;
10446 dgst_pos0 = 0;
10447 dgst_pos1 = 1;
10448 dgst_pos2 = 2;
10449 dgst_pos3 = 3;
10450 break;
10451
10452 case 13200: hash_type = HASH_TYPE_AES;
10453 salt_type = SALT_TYPE_EMBEDDED;
10454 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10455 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10456 kern_type = KERN_TYPE_AXCRYPT;
10457 dgst_size = DGST_SIZE_4_4;
10458 parse_func = axcrypt_parse_hash;
10459 sort_by_digest = sort_by_digest_4_4;
10460 opti_type = OPTI_TYPE_ZERO_BYTE;
10461 dgst_pos0 = 0;
10462 dgst_pos1 = 1;
10463 dgst_pos2 = 2;
10464 dgst_pos3 = 3;
10465 break;
10466
10467 case 13300: hash_type = HASH_TYPE_SHA1;
10468 salt_type = SALT_TYPE_NONE;
10469 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10470 opts_type = OPTS_TYPE_PT_GENERATE_BE
10471 | OPTS_TYPE_PT_ADD80
10472 | OPTS_TYPE_PT_ADDBITS15;
10473 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10474 dgst_size = DGST_SIZE_4_5;
10475 parse_func = sha1axcrypt_parse_hash;
10476 sort_by_digest = sort_by_digest_4_5;
10477 opti_type = OPTI_TYPE_ZERO_BYTE
10478 | OPTI_TYPE_PRECOMPUTE_INIT
10479 | OPTI_TYPE_EARLY_SKIP
10480 | OPTI_TYPE_NOT_ITERATED
10481 | OPTI_TYPE_NOT_SALTED;
10482 dgst_pos0 = 0;
10483 dgst_pos1 = 4;
10484 dgst_pos2 = 3;
10485 dgst_pos3 = 2;
10486 break;
10487
10488 case 13400: hash_type = HASH_TYPE_AES;
10489 salt_type = SALT_TYPE_EMBEDDED;
10490 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10491 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10492 kern_type = KERN_TYPE_KEEPASS;
10493 dgst_size = DGST_SIZE_4_4;
10494 parse_func = keepass_parse_hash;
10495 sort_by_digest = sort_by_digest_4_4;
10496 opti_type = OPTI_TYPE_ZERO_BYTE;
10497 dgst_pos0 = 0;
10498 dgst_pos1 = 1;
10499 dgst_pos2 = 2;
10500 dgst_pos3 = 3;
10501 break;
10502
10503 case 13500: hash_type = HASH_TYPE_SHA1;
10504 salt_type = SALT_TYPE_EMBEDDED;
10505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10506 opts_type = OPTS_TYPE_PT_GENERATE_BE
10507 | OPTS_TYPE_PT_UNICODE
10508 | OPTS_TYPE_PT_ADD80;
10509 kern_type = KERN_TYPE_PSTOKEN;
10510 dgst_size = DGST_SIZE_4_5;
10511 parse_func = pstoken_parse_hash;
10512 sort_by_digest = sort_by_digest_4_5;
10513 opti_type = OPTI_TYPE_ZERO_BYTE
10514 | OPTI_TYPE_PRECOMPUTE_INIT
10515 | OPTI_TYPE_EARLY_SKIP
10516 | OPTI_TYPE_NOT_ITERATED
10517 | OPTI_TYPE_PREPENDED_SALT
10518 | OPTI_TYPE_RAW_HASH;
10519 dgst_pos0 = 3;
10520 dgst_pos1 = 4;
10521 dgst_pos2 = 2;
10522 dgst_pos3 = 1;
10523 break;
10524
10525 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10526 salt_type = SALT_TYPE_EMBEDDED;
10527 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10528 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10529 kern_type = KERN_TYPE_ZIP2;
10530 dgst_size = DGST_SIZE_4_4;
10531 parse_func = zip2_parse_hash;
10532 sort_by_digest = sort_by_digest_4_4;
10533 opti_type = OPTI_TYPE_ZERO_BYTE;
10534 dgst_pos0 = 0;
10535 dgst_pos1 = 1;
10536 dgst_pos2 = 2;
10537 dgst_pos3 = 3;
10538 break;
10539
10540 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10541 salt_type = SALT_TYPE_EMBEDDED;
10542 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10543 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10544 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10545 dgst_size = DGST_SIZE_4_5;
10546 parse_func = veracrypt_parse_hash_655331;
10547 sort_by_digest = sort_by_digest_4_5;
10548 opti_type = OPTI_TYPE_ZERO_BYTE;
10549 dgst_pos0 = 0;
10550 dgst_pos1 = 1;
10551 dgst_pos2 = 2;
10552 dgst_pos3 = 3;
10553 break;
10554
10555 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10556 salt_type = SALT_TYPE_EMBEDDED;
10557 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10558 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10559 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10560 dgst_size = DGST_SIZE_4_5;
10561 parse_func = veracrypt_parse_hash_655331;
10562 sort_by_digest = sort_by_digest_4_5;
10563 opti_type = OPTI_TYPE_ZERO_BYTE;
10564 dgst_pos0 = 0;
10565 dgst_pos1 = 1;
10566 dgst_pos2 = 2;
10567 dgst_pos3 = 3;
10568 break;
10569
10570 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10571 salt_type = SALT_TYPE_EMBEDDED;
10572 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10573 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10574 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10575 dgst_size = DGST_SIZE_4_5;
10576 parse_func = veracrypt_parse_hash_655331;
10577 sort_by_digest = sort_by_digest_4_5;
10578 opti_type = OPTI_TYPE_ZERO_BYTE;
10579 dgst_pos0 = 0;
10580 dgst_pos1 = 1;
10581 dgst_pos2 = 2;
10582 dgst_pos3 = 3;
10583 break;
10584
10585 case 13721: hash_type = HASH_TYPE_SHA512;
10586 salt_type = SALT_TYPE_EMBEDDED;
10587 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10588 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10589 kern_type = KERN_TYPE_TCSHA512_XTS512;
10590 dgst_size = DGST_SIZE_8_8;
10591 parse_func = veracrypt_parse_hash_500000;
10592 sort_by_digest = sort_by_digest_8_8;
10593 opti_type = OPTI_TYPE_ZERO_BYTE
10594 | OPTI_TYPE_USES_BITS_64;
10595 dgst_pos0 = 0;
10596 dgst_pos1 = 1;
10597 dgst_pos2 = 2;
10598 dgst_pos3 = 3;
10599 break;
10600
10601 case 13722: hash_type = HASH_TYPE_SHA512;
10602 salt_type = SALT_TYPE_EMBEDDED;
10603 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10604 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10605 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10606 dgst_size = DGST_SIZE_8_8;
10607 parse_func = veracrypt_parse_hash_500000;
10608 sort_by_digest = sort_by_digest_8_8;
10609 opti_type = OPTI_TYPE_ZERO_BYTE
10610 | OPTI_TYPE_USES_BITS_64;
10611 dgst_pos0 = 0;
10612 dgst_pos1 = 1;
10613 dgst_pos2 = 2;
10614 dgst_pos3 = 3;
10615 break;
10616
10617 case 13723: hash_type = HASH_TYPE_SHA512;
10618 salt_type = SALT_TYPE_EMBEDDED;
10619 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10620 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10621 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10622 dgst_size = DGST_SIZE_8_8;
10623 parse_func = veracrypt_parse_hash_500000;
10624 sort_by_digest = sort_by_digest_8_8;
10625 opti_type = OPTI_TYPE_ZERO_BYTE
10626 | OPTI_TYPE_USES_BITS_64;
10627 dgst_pos0 = 0;
10628 dgst_pos1 = 1;
10629 dgst_pos2 = 2;
10630 dgst_pos3 = 3;
10631 break;
10632
10633 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10634 salt_type = SALT_TYPE_EMBEDDED;
10635 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10636 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10637 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10638 dgst_size = DGST_SIZE_4_8;
10639 parse_func = veracrypt_parse_hash_500000;
10640 sort_by_digest = sort_by_digest_4_8;
10641 opti_type = OPTI_TYPE_ZERO_BYTE;
10642 dgst_pos0 = 0;
10643 dgst_pos1 = 1;
10644 dgst_pos2 = 2;
10645 dgst_pos3 = 3;
10646 break;
10647
10648 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10649 salt_type = SALT_TYPE_EMBEDDED;
10650 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10651 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10652 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10653 dgst_size = DGST_SIZE_4_8;
10654 parse_func = veracrypt_parse_hash_500000;
10655 sort_by_digest = sort_by_digest_4_8;
10656 opti_type = OPTI_TYPE_ZERO_BYTE;
10657 dgst_pos0 = 0;
10658 dgst_pos1 = 1;
10659 dgst_pos2 = 2;
10660 dgst_pos3 = 3;
10661 break;
10662
10663 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10664 salt_type = SALT_TYPE_EMBEDDED;
10665 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10666 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10667 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10668 dgst_size = DGST_SIZE_4_8;
10669 parse_func = veracrypt_parse_hash_500000;
10670 sort_by_digest = sort_by_digest_4_8;
10671 opti_type = OPTI_TYPE_ZERO_BYTE;
10672 dgst_pos0 = 0;
10673 dgst_pos1 = 1;
10674 dgst_pos2 = 2;
10675 dgst_pos3 = 3;
10676 break;
10677
10678 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10679 salt_type = SALT_TYPE_EMBEDDED;
10680 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10681 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10682 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10683 dgst_size = DGST_SIZE_4_5;
10684 parse_func = veracrypt_parse_hash_327661;
10685 sort_by_digest = sort_by_digest_4_5;
10686 opti_type = OPTI_TYPE_ZERO_BYTE;
10687 dgst_pos0 = 0;
10688 dgst_pos1 = 1;
10689 dgst_pos2 = 2;
10690 dgst_pos3 = 3;
10691 break;
10692
10693 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10694 salt_type = SALT_TYPE_EMBEDDED;
10695 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10696 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10697 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10698 dgst_size = DGST_SIZE_4_5;
10699 parse_func = veracrypt_parse_hash_327661;
10700 sort_by_digest = sort_by_digest_4_5;
10701 opti_type = OPTI_TYPE_ZERO_BYTE;
10702 dgst_pos0 = 0;
10703 dgst_pos1 = 1;
10704 dgst_pos2 = 2;
10705 dgst_pos3 = 3;
10706 break;
10707
10708 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10709 salt_type = SALT_TYPE_EMBEDDED;
10710 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10711 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10712 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10713 dgst_size = DGST_SIZE_4_5;
10714 parse_func = veracrypt_parse_hash_327661;
10715 sort_by_digest = sort_by_digest_4_5;
10716 opti_type = OPTI_TYPE_ZERO_BYTE;
10717 dgst_pos0 = 0;
10718 dgst_pos1 = 1;
10719 dgst_pos2 = 2;
10720 dgst_pos3 = 3;
10721 break;
10722
10723 case 13751: hash_type = HASH_TYPE_SHA256;
10724 salt_type = SALT_TYPE_EMBEDDED;
10725 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10726 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10727 kern_type = KERN_TYPE_VCSHA256_XTS512;
10728 dgst_size = DGST_SIZE_4_8;
10729 parse_func = veracrypt_parse_hash_500000;
10730 sort_by_digest = sort_by_digest_4_8;
10731 opti_type = OPTI_TYPE_ZERO_BYTE;
10732 dgst_pos0 = 0;
10733 dgst_pos1 = 1;
10734 dgst_pos2 = 2;
10735 dgst_pos3 = 3;
10736 break;
10737
10738 case 13752: hash_type = HASH_TYPE_SHA256;
10739 salt_type = SALT_TYPE_EMBEDDED;
10740 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10741 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10742 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10743 dgst_size = DGST_SIZE_4_8;
10744 parse_func = veracrypt_parse_hash_500000;
10745 sort_by_digest = sort_by_digest_4_8;
10746 opti_type = OPTI_TYPE_ZERO_BYTE;
10747 dgst_pos0 = 0;
10748 dgst_pos1 = 1;
10749 dgst_pos2 = 2;
10750 dgst_pos3 = 3;
10751 break;
10752
10753 case 13753: hash_type = HASH_TYPE_SHA256;
10754 salt_type = SALT_TYPE_EMBEDDED;
10755 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10756 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10757 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10758 dgst_size = DGST_SIZE_4_8;
10759 parse_func = veracrypt_parse_hash_500000;
10760 sort_by_digest = sort_by_digest_4_8;
10761 opti_type = OPTI_TYPE_ZERO_BYTE;
10762 dgst_pos0 = 0;
10763 dgst_pos1 = 1;
10764 dgst_pos2 = 2;
10765 dgst_pos3 = 3;
10766 break;
10767
10768 case 13761: hash_type = HASH_TYPE_SHA256;
10769 salt_type = SALT_TYPE_EMBEDDED;
10770 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10771 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10772 kern_type = KERN_TYPE_VCSHA256_XTS512;
10773 dgst_size = DGST_SIZE_4_8;
10774 parse_func = veracrypt_parse_hash_200000;
10775 sort_by_digest = sort_by_digest_4_8;
10776 opti_type = OPTI_TYPE_ZERO_BYTE;
10777 dgst_pos0 = 0;
10778 dgst_pos1 = 1;
10779 dgst_pos2 = 2;
10780 dgst_pos3 = 3;
10781 break;
10782
10783 case 13762: hash_type = HASH_TYPE_SHA256;
10784 salt_type = SALT_TYPE_EMBEDDED;
10785 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10786 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10787 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10788 dgst_size = DGST_SIZE_4_8;
10789 parse_func = veracrypt_parse_hash_200000;
10790 sort_by_digest = sort_by_digest_4_8;
10791 opti_type = OPTI_TYPE_ZERO_BYTE;
10792 dgst_pos0 = 0;
10793 dgst_pos1 = 1;
10794 dgst_pos2 = 2;
10795 dgst_pos3 = 3;
10796 break;
10797
10798 case 13763: hash_type = HASH_TYPE_SHA256;
10799 salt_type = SALT_TYPE_EMBEDDED;
10800 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10801 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10802 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10803 dgst_size = DGST_SIZE_4_8;
10804 parse_func = veracrypt_parse_hash_200000;
10805 sort_by_digest = sort_by_digest_4_8;
10806 opti_type = OPTI_TYPE_ZERO_BYTE;
10807 dgst_pos0 = 0;
10808 dgst_pos1 = 1;
10809 dgst_pos2 = 2;
10810 dgst_pos3 = 3;
10811 break;
10812
10813
10814 default: usage_mini_print (PROGNAME); return (-1);
10815 }
10816
10817 /**
10818 * parser
10819 */
10820
10821 data.parse_func = parse_func;
10822
10823 /**
10824 * misc stuff
10825 */
10826
10827 if (hex_salt)
10828 {
10829 if (salt_type == SALT_TYPE_INTERN)
10830 {
10831 opts_type |= OPTS_TYPE_ST_HEX;
10832 }
10833 else
10834 {
10835 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10836
10837 return (-1);
10838 }
10839 }
10840
10841 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10842 | (salt_type == SALT_TYPE_EXTERN)
10843 | (salt_type == SALT_TYPE_EMBEDDED)
10844 | (salt_type == SALT_TYPE_VIRTUAL));
10845
10846 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10847
10848 data.hash_type = hash_type;
10849 data.attack_mode = attack_mode;
10850 data.attack_kern = attack_kern;
10851 data.attack_exec = attack_exec;
10852 data.kern_type = kern_type;
10853 data.opts_type = opts_type;
10854 data.dgst_size = dgst_size;
10855 data.salt_type = salt_type;
10856 data.isSalted = isSalted;
10857 data.sort_by_digest = sort_by_digest;
10858 data.dgst_pos0 = dgst_pos0;
10859 data.dgst_pos1 = dgst_pos1;
10860 data.dgst_pos2 = dgst_pos2;
10861 data.dgst_pos3 = dgst_pos3;
10862
10863 esalt_size = 0;
10864
10865 switch (hash_mode)
10866 {
10867 case 2500: esalt_size = sizeof (wpa_t); break;
10868 case 5300: esalt_size = sizeof (ikepsk_t); break;
10869 case 5400: esalt_size = sizeof (ikepsk_t); break;
10870 case 5500: esalt_size = sizeof (netntlm_t); break;
10871 case 5600: esalt_size = sizeof (netntlm_t); break;
10872 case 6211: esalt_size = sizeof (tc_t); break;
10873 case 6212: esalt_size = sizeof (tc_t); break;
10874 case 6213: esalt_size = sizeof (tc_t); break;
10875 case 6221: esalt_size = sizeof (tc_t); break;
10876 case 6222: esalt_size = sizeof (tc_t); break;
10877 case 6223: esalt_size = sizeof (tc_t); break;
10878 case 6231: esalt_size = sizeof (tc_t); break;
10879 case 6232: esalt_size = sizeof (tc_t); break;
10880 case 6233: esalt_size = sizeof (tc_t); break;
10881 case 6241: esalt_size = sizeof (tc_t); break;
10882 case 6242: esalt_size = sizeof (tc_t); break;
10883 case 6243: esalt_size = sizeof (tc_t); break;
10884 case 6600: esalt_size = sizeof (agilekey_t); break;
10885 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10886 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10887 case 7300: esalt_size = sizeof (rakp_t); break;
10888 case 7500: esalt_size = sizeof (krb5pa_t); break;
10889 case 8200: esalt_size = sizeof (cloudkey_t); break;
10890 case 8800: esalt_size = sizeof (androidfde_t); break;
10891 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10892 case 9400: esalt_size = sizeof (office2007_t); break;
10893 case 9500: esalt_size = sizeof (office2010_t); break;
10894 case 9600: esalt_size = sizeof (office2013_t); break;
10895 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10896 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10897 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10898 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10899 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10900 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10901 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10902 case 10200: esalt_size = sizeof (cram_md5_t); break;
10903 case 10400: esalt_size = sizeof (pdf_t); break;
10904 case 10410: esalt_size = sizeof (pdf_t); break;
10905 case 10420: esalt_size = sizeof (pdf_t); break;
10906 case 10500: esalt_size = sizeof (pdf_t); break;
10907 case 10600: esalt_size = sizeof (pdf_t); break;
10908 case 10700: esalt_size = sizeof (pdf_t); break;
10909 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10910 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10911 case 11400: esalt_size = sizeof (sip_t); break;
10912 case 11600: esalt_size = sizeof (seven_zip_t); break;
10913 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10914 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10915 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10916 case 13000: esalt_size = sizeof (rar5_t); break;
10917 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10918 case 13400: esalt_size = sizeof (keepass_t); break;
10919 case 13500: esalt_size = sizeof (pstoken_t); break;
10920 case 13600: esalt_size = sizeof (zip2_t); break;
10921 case 13711: esalt_size = sizeof (tc_t); break;
10922 case 13712: esalt_size = sizeof (tc_t); break;
10923 case 13713: esalt_size = sizeof (tc_t); break;
10924 case 13721: esalt_size = sizeof (tc_t); break;
10925 case 13722: esalt_size = sizeof (tc_t); break;
10926 case 13723: esalt_size = sizeof (tc_t); break;
10927 case 13731: esalt_size = sizeof (tc_t); break;
10928 case 13732: esalt_size = sizeof (tc_t); break;
10929 case 13733: esalt_size = sizeof (tc_t); break;
10930 case 13741: esalt_size = sizeof (tc_t); break;
10931 case 13742: esalt_size = sizeof (tc_t); break;
10932 case 13743: esalt_size = sizeof (tc_t); break;
10933 case 13751: esalt_size = sizeof (tc_t); break;
10934 case 13752: esalt_size = sizeof (tc_t); break;
10935 case 13753: esalt_size = sizeof (tc_t); break;
10936 case 13761: esalt_size = sizeof (tc_t); break;
10937 case 13762: esalt_size = sizeof (tc_t); break;
10938 case 13763: esalt_size = sizeof (tc_t); break;
10939 }
10940
10941 data.esalt_size = esalt_size;
10942
10943 /**
10944 * choose dictionary parser
10945 */
10946
10947 if (hash_type == HASH_TYPE_LM)
10948 {
10949 get_next_word_func = get_next_word_lm;
10950 }
10951 else if (opts_type & OPTS_TYPE_PT_UPPER)
10952 {
10953 get_next_word_func = get_next_word_uc;
10954 }
10955 else
10956 {
10957 get_next_word_func = get_next_word_std;
10958 }
10959
10960 /**
10961 * dictstat
10962 */
10963
10964 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10965
10966 #ifdef _POSIX
10967 size_t dictstat_nmemb = 0;
10968 #endif
10969
10970 #ifdef _WIN
10971 uint dictstat_nmemb = 0;
10972 #endif
10973
10974 char dictstat[256] = { 0 };
10975
10976 FILE *dictstat_fp = NULL;
10977
10978 if (keyspace == 0)
10979 {
10980 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10981
10982 dictstat_fp = fopen (dictstat, "rb");
10983
10984 if (dictstat_fp)
10985 {
10986 #ifdef _POSIX
10987 struct stat tmpstat;
10988
10989 fstat (fileno (dictstat_fp), &tmpstat);
10990 #endif
10991
10992 #ifdef _WIN
10993 struct stat64 tmpstat;
10994
10995 _fstat64 (fileno (dictstat_fp), &tmpstat);
10996 #endif
10997
10998 if (tmpstat.st_mtime < COMPTIME)
10999 {
11000 /* with v0.15 the format changed so we have to ensure user is using a good version
11001 since there is no version-header in the dictstat file */
11002
11003 fclose (dictstat_fp);
11004
11005 unlink (dictstat);
11006 }
11007 else
11008 {
11009 while (!feof (dictstat_fp))
11010 {
11011 dictstat_t d;
11012
11013 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11014
11015 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11016
11017 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11018 {
11019 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11020
11021 return -1;
11022 }
11023 }
11024
11025 fclose (dictstat_fp);
11026 }
11027 }
11028 }
11029
11030 /**
11031 * potfile
11032 */
11033
11034 char potfile[256] = { 0 };
11035
11036 if (potfile_path == NULL)
11037 {
11038 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11039 }
11040 else
11041 {
11042 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11043 }
11044
11045 data.pot_fp = NULL;
11046
11047 FILE *out_fp = NULL;
11048 FILE *pot_fp = NULL;
11049
11050 if (show == 1 || left == 1)
11051 {
11052 pot_fp = fopen (potfile, "rb");
11053
11054 if (pot_fp == NULL)
11055 {
11056 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11057
11058 return (-1);
11059 }
11060
11061 if (outfile != NULL)
11062 {
11063 if ((out_fp = fopen (outfile, "ab")) == NULL)
11064 {
11065 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11066
11067 fclose (pot_fp);
11068
11069 return (-1);
11070 }
11071 }
11072 else
11073 {
11074 out_fp = stdout;
11075 }
11076 }
11077 else
11078 {
11079 if (potfile_disable == 0)
11080 {
11081 pot_fp = fopen (potfile, "ab");
11082
11083 if (pot_fp == NULL)
11084 {
11085 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11086
11087 return (-1);
11088 }
11089
11090 data.pot_fp = pot_fp;
11091 }
11092 }
11093
11094 pot_t *pot = NULL;
11095
11096 uint pot_cnt = 0;
11097 uint pot_avail = 0;
11098
11099 if (show == 1 || left == 1)
11100 {
11101 SUPPRESS_OUTPUT = 1;
11102
11103 pot_avail = count_lines (pot_fp);
11104
11105 rewind (pot_fp);
11106
11107 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11108
11109 uint pot_hashes_avail = 0;
11110
11111 uint line_num = 0;
11112
11113 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11114
11115 while (!feof (pot_fp))
11116 {
11117 line_num++;
11118
11119 int line_len = fgetl (pot_fp, line_buf);
11120
11121 if (line_len == 0) continue;
11122
11123 char *plain_buf = line_buf + line_len;
11124
11125 pot_t *pot_ptr = &pot[pot_cnt];
11126
11127 hash_t *hashes_buf = &pot_ptr->hash;
11128
11129 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11130 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11131
11132 if (pot_cnt == pot_hashes_avail)
11133 {
11134 uint pos = 0;
11135
11136 for (pos = 0; pos < INCR_POT; pos++)
11137 {
11138 if ((pot_cnt + pos) >= pot_avail) break;
11139
11140 pot_t *tmp_pot = &pot[pot_cnt + pos];
11141
11142 hash_t *tmp_hash = &tmp_pot->hash;
11143
11144 tmp_hash->digest = mymalloc (dgst_size);
11145
11146 if (isSalted)
11147 {
11148 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11149 }
11150
11151 if (esalt_size)
11152 {
11153 tmp_hash->esalt = mymalloc (esalt_size);
11154 }
11155
11156 pot_hashes_avail++;
11157 }
11158 }
11159
11160 int plain_len = 0;
11161
11162 int parser_status;
11163
11164 int iter = MAX_CUT_TRIES;
11165
11166 do
11167 {
11168 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11169 {
11170 if (line_buf[i] == ':')
11171 {
11172 line_len--;
11173
11174 break;
11175 }
11176 }
11177
11178 if (data.hash_mode != 2500)
11179 {
11180 parser_status = parse_func (line_buf, line_len, hashes_buf);
11181 }
11182 else
11183 {
11184 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11185
11186 if (line_len > max_salt_size)
11187 {
11188 parser_status = PARSER_GLOBAL_LENGTH;
11189 }
11190 else
11191 {
11192 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11193
11194 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11195
11196 hashes_buf->salt->salt_len = line_len;
11197
11198 parser_status = PARSER_OK;
11199 }
11200 }
11201
11202 // if NOT parsed without error, we add the ":" to the plain
11203
11204 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11205 {
11206 plain_len++;
11207 plain_buf--;
11208 }
11209
11210 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11211
11212 if (parser_status < PARSER_GLOBAL_ZERO)
11213 {
11214 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11215
11216 continue;
11217 }
11218
11219 if (plain_len >= 255) continue;
11220
11221 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11222
11223 pot_ptr->plain_len = plain_len;
11224
11225 pot_cnt++;
11226 }
11227
11228 myfree (line_buf);
11229
11230 fclose (pot_fp);
11231
11232 SUPPRESS_OUTPUT = 0;
11233
11234 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11235 }
11236
11237 /**
11238 * word len
11239 */
11240
11241 uint pw_min = PW_MIN;
11242 uint pw_max = PW_MAX;
11243
11244 switch (hash_mode)
11245 {
11246 case 125: if (pw_max > 32) pw_max = 32;
11247 break;
11248 case 400: if (pw_max > 40) pw_max = 40;
11249 break;
11250 case 500: if (pw_max > 16) pw_max = 16;
11251 break;
11252 case 1500: if (pw_max > 8) pw_max = 8;
11253 break;
11254 case 1600: if (pw_max > 16) pw_max = 16;
11255 break;
11256 case 1800: if (pw_max > 16) pw_max = 16;
11257 break;
11258 case 2100: if (pw_max > 16) pw_max = 16;
11259 break;
11260 case 2500: if (pw_min < 8) pw_min = 8;
11261 break;
11262 case 3000: if (pw_max > 7) pw_max = 7;
11263 break;
11264 case 5200: if (pw_max > 24) pw_max = 24;
11265 break;
11266 case 5800: if (pw_max > 16) pw_max = 16;
11267 break;
11268 case 6300: if (pw_max > 16) pw_max = 16;
11269 break;
11270 case 7400: if (pw_max > 16) pw_max = 16;
11271 break;
11272 case 7500: if (pw_max > 8) pw_max = 8;
11273 break;
11274 case 7900: if (pw_max > 48) pw_max = 48;
11275 break;
11276 case 8500: if (pw_max > 8) pw_max = 8;
11277 break;
11278 case 8600: if (pw_max > 16) pw_max = 16;
11279 break;
11280 case 9710: pw_min = 5;
11281 pw_max = 5;
11282 break;
11283 case 9810: pw_min = 5;
11284 pw_max = 5;
11285 break;
11286 case 10410: pw_min = 5;
11287 pw_max = 5;
11288 break;
11289 case 10300: if (pw_max < 3) pw_min = 3;
11290 if (pw_max > 40) pw_max = 40;
11291 break;
11292 case 10500: if (pw_max < 3) pw_min = 3;
11293 if (pw_max > 40) pw_max = 40;
11294 break;
11295 case 10700: if (pw_max > 16) pw_max = 16;
11296 break;
11297 case 11300: if (pw_max > 40) pw_max = 40;
11298 break;
11299 case 11600: if (pw_max > 32) pw_max = 32;
11300 break;
11301 case 12500: if (pw_max > 20) pw_max = 20;
11302 break;
11303 case 12800: if (pw_max > 24) pw_max = 24;
11304 break;
11305 }
11306
11307 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11308 {
11309 switch (attack_kern)
11310 {
11311 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11312 break;
11313 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11314 break;
11315 }
11316 }
11317
11318 /**
11319 * charsets : keep them together for more easy maintainnce
11320 */
11321
11322 cs_t mp_sys[6] = { { { 0 }, 0 } };
11323 cs_t mp_usr[4] = { { { 0 }, 0 } };
11324
11325 mp_setup_sys (mp_sys);
11326
11327 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11328 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11329 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11330 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11331
11332 /**
11333 * load hashes, part I: find input mode, count hashes
11334 */
11335
11336 uint hashlist_mode = 0;
11337 uint hashlist_format = HLFMT_HASHCAT;
11338
11339 uint hashes_avail = 0;
11340
11341 if (benchmark == 0)
11342 {
11343 struct stat f;
11344
11345 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11346
11347 if ((hash_mode == 2500) ||
11348 (hash_mode == 5200) ||
11349 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11350 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11351 (hash_mode == 9000))
11352 {
11353 hashlist_mode = HL_MODE_ARG;
11354
11355 char *hashfile = myargv[optind];
11356
11357 data.hashfile = hashfile;
11358
11359 logfile_top_var_string ("target", hashfile);
11360 }
11361
11362 if (hashlist_mode == HL_MODE_ARG)
11363 {
11364 if (hash_mode == 2500)
11365 {
11366 struct stat st;
11367
11368 if (stat (data.hashfile, &st) == -1)
11369 {
11370 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11371
11372 return (-1);
11373 }
11374
11375 hashes_avail = st.st_size / sizeof (hccap_t);
11376 }
11377 else
11378 {
11379 hashes_avail = 1;
11380 }
11381 }
11382 else if (hashlist_mode == HL_MODE_FILE)
11383 {
11384 char *hashfile = myargv[optind];
11385
11386 data.hashfile = hashfile;
11387
11388 logfile_top_var_string ("target", hashfile);
11389
11390 FILE *fp = NULL;
11391
11392 if ((fp = fopen (hashfile, "rb")) == NULL)
11393 {
11394 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11395
11396 return (-1);
11397 }
11398
11399 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11400
11401 hashes_avail = count_lines (fp);
11402
11403 rewind (fp);
11404
11405 if (hashes_avail == 0)
11406 {
11407 log_error ("ERROR: hashfile is empty or corrupt");
11408
11409 fclose (fp);
11410
11411 return (-1);
11412 }
11413
11414 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11415
11416 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11417 {
11418 log_error ("ERROR: remove not supported in native hashfile-format mode");
11419
11420 fclose (fp);
11421
11422 return (-1);
11423 }
11424
11425 fclose (fp);
11426 }
11427 }
11428 else
11429 {
11430 hashlist_mode = HL_MODE_ARG;
11431
11432 hashes_avail = 1;
11433 }
11434
11435 if (hash_mode == 3000) hashes_avail *= 2;
11436
11437 data.hashlist_mode = hashlist_mode;
11438 data.hashlist_format = hashlist_format;
11439
11440 logfile_top_uint (hashlist_mode);
11441 logfile_top_uint (hashlist_format);
11442
11443 /**
11444 * load hashes, part II: allocate required memory, set pointers
11445 */
11446
11447 hash_t *hashes_buf = NULL;
11448 void *digests_buf = NULL;
11449 salt_t *salts_buf = NULL;
11450 void *esalts_buf = NULL;
11451
11452 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11453
11454 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11455
11456 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11457 {
11458 u32 hash_pos;
11459
11460 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11461 {
11462 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11463
11464 hashes_buf[hash_pos].hash_info = hash_info;
11465
11466 if (username && (remove || show || left))
11467 {
11468 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11469 }
11470
11471 if (benchmark)
11472 {
11473 hash_info->orighash = (char *) mymalloc (256);
11474 }
11475 }
11476 }
11477
11478 if (isSalted)
11479 {
11480 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11481
11482 if (esalt_size)
11483 {
11484 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11485 }
11486 }
11487 else
11488 {
11489 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11490 }
11491
11492 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11493 {
11494 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11495
11496 if (isSalted)
11497 {
11498 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11499
11500 if (esalt_size)
11501 {
11502 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11503 }
11504 }
11505 else
11506 {
11507 hashes_buf[hash_pos].salt = &salts_buf[0];
11508 }
11509 }
11510
11511 /**
11512 * load hashes, part III: parse hashes or generate them if benchmark
11513 */
11514
11515 uint hashes_cnt = 0;
11516
11517 if (benchmark == 0)
11518 {
11519 if (keyspace == 1)
11520 {
11521 // useless to read hash file for keyspace, cheat a little bit w/ optind
11522 }
11523 else if (hashes_avail == 0)
11524 {
11525 }
11526 else if (hashlist_mode == HL_MODE_ARG)
11527 {
11528 char *input_buf = myargv[optind];
11529
11530 uint input_len = strlen (input_buf);
11531
11532 logfile_top_var_string ("target", input_buf);
11533
11534 char *hash_buf = NULL;
11535 int hash_len = 0;
11536
11537 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11538
11539 bool hash_fmt_error = 0;
11540
11541 if (hash_len < 1) hash_fmt_error = 1;
11542 if (hash_buf == NULL) hash_fmt_error = 1;
11543
11544 if (hash_fmt_error)
11545 {
11546 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11547 }
11548 else
11549 {
11550 if (opts_type & OPTS_TYPE_HASH_COPY)
11551 {
11552 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11553
11554 hash_info_tmp->orighash = mystrdup (hash_buf);
11555 }
11556
11557 if (isSalted)
11558 {
11559 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11560 }
11561
11562 int parser_status = PARSER_OK;
11563
11564 if (hash_mode == 2500)
11565 {
11566 if (hash_len == 0)
11567 {
11568 log_error ("ERROR: hccap file not specified");
11569
11570 return (-1);
11571 }
11572
11573 hashlist_mode = HL_MODE_FILE;
11574
11575 data.hashlist_mode = hashlist_mode;
11576
11577 FILE *fp = fopen (hash_buf, "rb");
11578
11579 if (fp == NULL)
11580 {
11581 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11582
11583 return (-1);
11584 }
11585
11586 if (hashes_avail < 1)
11587 {
11588 log_error ("ERROR: hccap file is empty or corrupt");
11589
11590 fclose (fp);
11591
11592 return (-1);
11593 }
11594
11595 uint hccap_size = sizeof (hccap_t);
11596
11597 char *in = (char *) mymalloc (hccap_size);
11598
11599 while (!feof (fp))
11600 {
11601 int n = fread (in, hccap_size, 1, fp);
11602
11603 if (n != 1)
11604 {
11605 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11606
11607 break;
11608 }
11609
11610 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11611
11612 if (parser_status != PARSER_OK)
11613 {
11614 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11615
11616 continue;
11617 }
11618
11619 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11620
11621 if ((show == 1) || (left == 1))
11622 {
11623 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11624
11625 char *salt_ptr = (char *) tmp_salt->salt_buf;
11626
11627 int cur_pos = tmp_salt->salt_len;
11628 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11629
11630 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11631
11632 // do the appending task
11633
11634 snprintf (salt_ptr + cur_pos,
11635 rem_len,
11636 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11637 wpa->orig_mac1[0],
11638 wpa->orig_mac1[1],
11639 wpa->orig_mac1[2],
11640 wpa->orig_mac1[3],
11641 wpa->orig_mac1[4],
11642 wpa->orig_mac1[5],
11643 wpa->orig_mac2[0],
11644 wpa->orig_mac2[1],
11645 wpa->orig_mac2[2],
11646 wpa->orig_mac2[3],
11647 wpa->orig_mac2[4],
11648 wpa->orig_mac2[5]);
11649
11650 // memset () the remaining part of the salt
11651
11652 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11653 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11654
11655 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11656
11657 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11658 }
11659
11660 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);
11661 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);
11662
11663 hashes_cnt++;
11664 }
11665
11666 fclose (fp);
11667
11668 myfree (in);
11669 }
11670 else if (hash_mode == 3000)
11671 {
11672 if (hash_len == 32)
11673 {
11674 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11675
11676 hash_t *lm_hash_left = NULL;
11677
11678 if (parser_status == PARSER_OK)
11679 {
11680 lm_hash_left = &hashes_buf[hashes_cnt];
11681
11682 hashes_cnt++;
11683 }
11684 else
11685 {
11686 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11687 }
11688
11689 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11690
11691 hash_t *lm_hash_right = NULL;
11692
11693 if (parser_status == PARSER_OK)
11694 {
11695 lm_hash_right = &hashes_buf[hashes_cnt];
11696
11697 hashes_cnt++;
11698 }
11699 else
11700 {
11701 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11702 }
11703
11704 // show / left
11705
11706 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11707 {
11708 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);
11709 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);
11710 }
11711 }
11712 else
11713 {
11714 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11715
11716 if (parser_status == PARSER_OK)
11717 {
11718 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11719 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11720 }
11721
11722 if (parser_status == PARSER_OK)
11723 {
11724 hashes_cnt++;
11725 }
11726 else
11727 {
11728 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11729 }
11730 }
11731 }
11732 else
11733 {
11734 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11735
11736 if (parser_status == PARSER_OK)
11737 {
11738 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11739 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11740 }
11741
11742 if (parser_status == PARSER_OK)
11743 {
11744 hashes_cnt++;
11745 }
11746 else
11747 {
11748 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11749 }
11750 }
11751 }
11752 }
11753 else if (hashlist_mode == HL_MODE_FILE)
11754 {
11755 char *hashfile = data.hashfile;
11756
11757 FILE *fp;
11758
11759 if ((fp = fopen (hashfile, "rb")) == NULL)
11760 {
11761 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11762
11763 return (-1);
11764 }
11765
11766 uint line_num = 0;
11767
11768 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11769
11770 while (!feof (fp))
11771 {
11772 line_num++;
11773
11774 int line_len = fgetl (fp, line_buf);
11775
11776 if (line_len == 0) continue;
11777
11778 char *hash_buf = NULL;
11779 int hash_len = 0;
11780
11781 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11782
11783 bool hash_fmt_error = 0;
11784
11785 if (hash_len < 1) hash_fmt_error = 1;
11786 if (hash_buf == NULL) hash_fmt_error = 1;
11787
11788 if (hash_fmt_error)
11789 {
11790 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11791
11792 continue;
11793 }
11794
11795 if (username)
11796 {
11797 char *user_buf = NULL;
11798 int user_len = 0;
11799
11800 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11801
11802 if (remove || show)
11803 {
11804 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11805
11806 *user = (user_t *) mymalloc (sizeof (user_t));
11807
11808 user_t *user_ptr = *user;
11809
11810 if (user_buf != NULL)
11811 {
11812 user_ptr->user_name = mystrdup (user_buf);
11813 }
11814 else
11815 {
11816 user_ptr->user_name = mystrdup ("");
11817 }
11818
11819 user_ptr->user_len = user_len;
11820 }
11821 }
11822
11823 if (opts_type & OPTS_TYPE_HASH_COPY)
11824 {
11825 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11826
11827 hash_info_tmp->orighash = mystrdup (hash_buf);
11828 }
11829
11830 if (isSalted)
11831 {
11832 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11833 }
11834
11835 if (hash_mode == 3000)
11836 {
11837 if (hash_len == 32)
11838 {
11839 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11840
11841 if (parser_status < PARSER_GLOBAL_ZERO)
11842 {
11843 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11844
11845 continue;
11846 }
11847
11848 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11849
11850 hashes_cnt++;
11851
11852 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11853
11854 if (parser_status < PARSER_GLOBAL_ZERO)
11855 {
11856 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11857
11858 continue;
11859 }
11860
11861 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11862
11863 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);
11864
11865 hashes_cnt++;
11866
11867 // show / left
11868
11869 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);
11870 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);
11871 }
11872 else
11873 {
11874 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11875
11876 if (parser_status < PARSER_GLOBAL_ZERO)
11877 {
11878 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11879
11880 continue;
11881 }
11882
11883 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);
11884
11885 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11886 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11887
11888 hashes_cnt++;
11889 }
11890 }
11891 else
11892 {
11893 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11894
11895 if (parser_status < PARSER_GLOBAL_ZERO)
11896 {
11897 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11898
11899 continue;
11900 }
11901
11902 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);
11903
11904 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11905 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11906
11907 hashes_cnt++;
11908 }
11909 }
11910
11911 myfree (line_buf);
11912
11913 fclose (fp);
11914
11915 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11916
11917 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11918 }
11919 }
11920 else
11921 {
11922 if (isSalted)
11923 {
11924 hashes_buf[0].salt->salt_len = 8;
11925
11926 // special salt handling
11927
11928 switch (hash_mode)
11929 {
11930 case 1500: hashes_buf[0].salt->salt_len = 2;
11931 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11932 break;
11933 case 1731: hashes_buf[0].salt->salt_len = 4;
11934 break;
11935 case 2410: hashes_buf[0].salt->salt_len = 4;
11936 break;
11937 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11938 break;
11939 case 3100: hashes_buf[0].salt->salt_len = 1;
11940 break;
11941 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11942 break;
11943 case 5800: hashes_buf[0].salt->salt_len = 16;
11944 break;
11945 case 6800: hashes_buf[0].salt->salt_len = 32;
11946 break;
11947 case 8400: hashes_buf[0].salt->salt_len = 40;
11948 break;
11949 case 8800: hashes_buf[0].salt->salt_len = 16;
11950 break;
11951 case 8900: hashes_buf[0].salt->salt_len = 16;
11952 hashes_buf[0].salt->scrypt_N = 1024;
11953 hashes_buf[0].salt->scrypt_r = 1;
11954 hashes_buf[0].salt->scrypt_p = 1;
11955 break;
11956 case 9100: hashes_buf[0].salt->salt_len = 16;
11957 break;
11958 case 9300: hashes_buf[0].salt->salt_len = 14;
11959 hashes_buf[0].salt->scrypt_N = 16384;
11960 hashes_buf[0].salt->scrypt_r = 1;
11961 hashes_buf[0].salt->scrypt_p = 1;
11962 break;
11963 case 9400: hashes_buf[0].salt->salt_len = 16;
11964 break;
11965 case 9500: hashes_buf[0].salt->salt_len = 16;
11966 break;
11967 case 9600: hashes_buf[0].salt->salt_len = 16;
11968 break;
11969 case 9700: hashes_buf[0].salt->salt_len = 16;
11970 break;
11971 case 9710: hashes_buf[0].salt->salt_len = 16;
11972 break;
11973 case 9720: hashes_buf[0].salt->salt_len = 16;
11974 break;
11975 case 9800: hashes_buf[0].salt->salt_len = 16;
11976 break;
11977 case 9810: hashes_buf[0].salt->salt_len = 16;
11978 break;
11979 case 9820: hashes_buf[0].salt->salt_len = 16;
11980 break;
11981 case 10300: hashes_buf[0].salt->salt_len = 12;
11982 break;
11983 case 11500: hashes_buf[0].salt->salt_len = 4;
11984 break;
11985 case 11600: hashes_buf[0].salt->salt_len = 4;
11986 break;
11987 case 12400: hashes_buf[0].salt->salt_len = 4;
11988 break;
11989 case 12500: hashes_buf[0].salt->salt_len = 8;
11990 break;
11991 case 12600: hashes_buf[0].salt->salt_len = 64;
11992 break;
11993 }
11994
11995 // special esalt handling
11996
11997 switch (hash_mode)
11998 {
11999 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12000 break;
12001 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12002 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12003 break;
12004 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12005 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12006 break;
12007 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12008 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12009 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12010 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12011 break;
12012 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12013 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12014 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12015 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12016 break;
12017 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12018 break;
12019 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12020 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12021 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12022 break;
12023 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12024 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12025 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12026 break;
12027 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12028 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12029 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12030 break;
12031 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12032 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12033 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12034 break;
12035 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12036 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12037 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12038 break;
12039 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12040 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12041 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12042 break;
12043 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12044 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12045 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12046 break;
12047 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12048 break;
12049 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12050 break;
12051 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12052 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12053 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12054 break;
12055 }
12056 }
12057
12058 // set hashfile
12059
12060 switch (hash_mode)
12061 {
12062 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12063 break;
12064 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12065 break;
12066 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12067 break;
12068 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12069 break;
12070 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12071 break;
12072 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12073 break;
12074 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12075 break;
12076 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12077 break;
12078 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12079 break;
12080 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12081 break;
12082 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12083 break;
12084 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12085 break;
12086 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12087 break;
12088 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12089 break;
12090 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12091 break;
12092 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12093 break;
12094 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12095 break;
12096 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12097 break;
12098 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12099 break;
12100 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12101 break;
12102 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12103 break;
12104 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12105 break;
12106 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12107 break;
12108 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12109 break;
12110 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12111 break;
12112 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12113 break;
12114 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12115 break;
12116 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12117 break;
12118 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12119 break;
12120 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12121 break;
12122 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12123 break;
12124 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12125 break;
12126 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12127 break;
12128 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12129 break;
12130 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12131 break;
12132 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12133 break;
12134 }
12135
12136 // set default iterations
12137
12138 switch (hash_mode)
12139 {
12140 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12141 break;
12142 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12143 break;
12144 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12145 break;
12146 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12147 break;
12148 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12149 break;
12150 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12151 break;
12152 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12153 break;
12154 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12155 break;
12156 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12157 break;
12158 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12159 break;
12160 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12161 break;
12162 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12163 break;
12164 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12165 break;
12166 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12167 break;
12168 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12169 break;
12170 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12171 break;
12172 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12173 break;
12174 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12175 break;
12176 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12177 break;
12178 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12179 break;
12180 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12181 break;
12182 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12183 break;
12184 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12185 break;
12186 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12187 break;
12188 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12189 break;
12190 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12191 break;
12192 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12193 break;
12194 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12195 break;
12196 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12197 break;
12198 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12199 break;
12200 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12201 break;
12202 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12203 break;
12204 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12205 break;
12206 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12207 break;
12208 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12209 break;
12210 case 8900: hashes_buf[0].salt->salt_iter = 1;
12211 break;
12212 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12213 break;
12214 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12215 break;
12216 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12217 break;
12218 case 9300: hashes_buf[0].salt->salt_iter = 1;
12219 break;
12220 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12221 break;
12222 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12223 break;
12224 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12225 break;
12226 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12227 break;
12228 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12229 break;
12230 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12231 break;
12232 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12233 break;
12234 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12235 break;
12236 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12237 break;
12238 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12239 break;
12240 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12241 break;
12242 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12243 break;
12244 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12245 break;
12246 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12247 break;
12248 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12249 break;
12250 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12251 break;
12252 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12253 break;
12254 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12255 break;
12256 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12257 break;
12258 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12259 break;
12260 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12261 break;
12262 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12263 break;
12264 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12265 break;
12266 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12267 break;
12268 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12269 break;
12270 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12271 break;
12272 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12273 break;
12274 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12275 break;
12276 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12277 break;
12278 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12279 break;
12280 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12281 break;
12282 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12283 break;
12284 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12285 break;
12286 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12287 break;
12288 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12289 break;
12290 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12291 break;
12292 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12293 break;
12294 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12295 break;
12296 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12297 break;
12298 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12299 break;
12300 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12301 break;
12302 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12303 break;
12304 }
12305
12306 hashes_cnt = 1;
12307 }
12308
12309 if (show == 1 || left == 1)
12310 {
12311 for (uint i = 0; i < pot_cnt; i++)
12312 {
12313 pot_t *pot_ptr = &pot[i];
12314
12315 hash_t *hashes_buf = &pot_ptr->hash;
12316
12317 local_free (hashes_buf->digest);
12318
12319 if (isSalted)
12320 {
12321 local_free (hashes_buf->salt);
12322 }
12323 }
12324
12325 local_free (pot);
12326
12327 if (data.quiet == 0) log_info_nn ("");
12328
12329 return (0);
12330 }
12331
12332 if (keyspace == 0)
12333 {
12334 if (hashes_cnt == 0)
12335 {
12336 log_error ("ERROR: No hashes loaded");
12337
12338 return (-1);
12339 }
12340 }
12341
12342 /**
12343 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12344 */
12345
12346 if (data.outfile != NULL)
12347 {
12348 if (data.hashfile != NULL)
12349 {
12350 #ifdef _POSIX
12351 struct stat tmpstat_outfile;
12352 struct stat tmpstat_hashfile;
12353 #endif
12354
12355 #ifdef _WIN
12356 struct stat64 tmpstat_outfile;
12357 struct stat64 tmpstat_hashfile;
12358 #endif
12359
12360 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12361
12362 if (tmp_outfile_fp)
12363 {
12364 #ifdef _POSIX
12365 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12366 #endif
12367
12368 #ifdef _WIN
12369 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12370 #endif
12371
12372 fclose (tmp_outfile_fp);
12373 }
12374
12375 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12376
12377 if (tmp_hashfile_fp)
12378 {
12379 #ifdef _POSIX
12380 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12381 #endif
12382
12383 #ifdef _WIN
12384 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12385 #endif
12386
12387 fclose (tmp_hashfile_fp);
12388 }
12389
12390 if (tmp_outfile_fp && tmp_outfile_fp)
12391 {
12392 tmpstat_outfile.st_mode = 0;
12393 tmpstat_outfile.st_nlink = 0;
12394 tmpstat_outfile.st_uid = 0;
12395 tmpstat_outfile.st_gid = 0;
12396 tmpstat_outfile.st_rdev = 0;
12397 tmpstat_outfile.st_atime = 0;
12398
12399 tmpstat_hashfile.st_mode = 0;
12400 tmpstat_hashfile.st_nlink = 0;
12401 tmpstat_hashfile.st_uid = 0;
12402 tmpstat_hashfile.st_gid = 0;
12403 tmpstat_hashfile.st_rdev = 0;
12404 tmpstat_hashfile.st_atime = 0;
12405
12406 #ifdef _POSIX
12407 tmpstat_outfile.st_blksize = 0;
12408 tmpstat_outfile.st_blocks = 0;
12409
12410 tmpstat_hashfile.st_blksize = 0;
12411 tmpstat_hashfile.st_blocks = 0;
12412 #endif
12413
12414 #ifdef _POSIX
12415 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 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 #ifdef _WIN
12424 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12425 {
12426 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12427
12428 return (-1);
12429 }
12430 #endif
12431 }
12432 }
12433 }
12434
12435 /**
12436 * Remove duplicates
12437 */
12438
12439 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12440
12441 if (isSalted)
12442 {
12443 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12444 }
12445 else
12446 {
12447 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12448 }
12449
12450 uint hashes_cnt_orig = hashes_cnt;
12451
12452 hashes_cnt = 1;
12453
12454 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12455 {
12456 if (isSalted)
12457 {
12458 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12459 {
12460 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12461 }
12462 }
12463 else
12464 {
12465 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12466 }
12467
12468 if (hashes_pos > hashes_cnt)
12469 {
12470 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12471 }
12472
12473 hashes_cnt++;
12474 }
12475
12476 /**
12477 * Potfile removes
12478 */
12479
12480 uint potfile_remove_cracks = 0;
12481
12482 if (potfile_disable == 0)
12483 {
12484 hash_t hash_buf;
12485
12486 hash_buf.digest = mymalloc (dgst_size);
12487 hash_buf.salt = NULL;
12488 hash_buf.esalt = NULL;
12489 hash_buf.hash_info = NULL;
12490 hash_buf.cracked = 0;
12491
12492 if (isSalted)
12493 {
12494 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12495 }
12496
12497 if (esalt_size)
12498 {
12499 hash_buf.esalt = mymalloc (esalt_size);
12500 }
12501
12502 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12503
12504 // no solution for these special hash types (for instane because they use hashfile in output etc)
12505 if ((hash_mode != 5200) &&
12506 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12507 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12508 (hash_mode != 9000))
12509 {
12510 FILE *fp = fopen (potfile, "rb");
12511
12512 if (fp != NULL)
12513 {
12514 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12515
12516 // to be safe work with a copy (because of line_len loop, i etc)
12517 // moved up here because it's easier to handle continue case
12518 // it's just 64kb
12519
12520 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12521
12522 while (!feof (fp))
12523 {
12524 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12525
12526 if (ptr == NULL) break;
12527
12528 int line_len = strlen (line_buf);
12529
12530 if (line_len == 0) continue;
12531
12532 int iter = MAX_CUT_TRIES;
12533
12534 for (int i = line_len - 1; i && iter; i--, line_len--)
12535 {
12536 if (line_buf[i] != ':') continue;
12537
12538 if (isSalted)
12539 {
12540 memset (hash_buf.salt, 0, sizeof (salt_t));
12541 }
12542
12543 hash_t *found = NULL;
12544
12545 if (hash_mode == 6800)
12546 {
12547 if (i < 64) // 64 = 16 * uint in salt_buf[]
12548 {
12549 // manipulate salt_buf
12550 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12551
12552 hash_buf.salt->salt_len = i;
12553
12554 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12555 }
12556 }
12557 else if (hash_mode == 2500)
12558 {
12559 if (i < 64) // 64 = 16 * uint in salt_buf[]
12560 {
12561 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12562 // manipulate salt_buf
12563
12564 memcpy (line_buf_cpy, line_buf, i);
12565
12566 char *mac2_pos = strrchr (line_buf_cpy, ':');
12567
12568 if (mac2_pos == NULL) continue;
12569
12570 mac2_pos[0] = 0;
12571 mac2_pos++;
12572
12573 if (strlen (mac2_pos) != 12) continue;
12574
12575 char *mac1_pos = strrchr (line_buf_cpy, ':');
12576
12577 if (mac1_pos == NULL) continue;
12578
12579 mac1_pos[0] = 0;
12580 mac1_pos++;
12581
12582 if (strlen (mac1_pos) != 12) continue;
12583
12584 uint essid_length = mac1_pos - line_buf_cpy - 1;
12585
12586 // here we need the ESSID
12587 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12588
12589 hash_buf.salt->salt_len = essid_length;
12590
12591 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12592
12593 if (found)
12594 {
12595 wpa_t *wpa = (wpa_t *) found->esalt;
12596
12597 // compare hex string(s) vs binary MAC address(es)
12598
12599 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12600 {
12601 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12602 {
12603 found = NULL;
12604
12605 break;
12606 }
12607 }
12608
12609 // early skip ;)
12610 if (!found) continue;
12611
12612 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12613 {
12614 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12615 {
12616 found = NULL;
12617
12618 break;
12619 }
12620 }
12621 }
12622 }
12623 }
12624 else
12625 {
12626 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12627
12628 if (parser_status == PARSER_OK)
12629 {
12630 if (isSalted)
12631 {
12632 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12633 }
12634 else
12635 {
12636 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12637 }
12638 }
12639 }
12640
12641 if (found == NULL) continue;
12642
12643 if (!found->cracked) potfile_remove_cracks++;
12644
12645 found->cracked = 1;
12646
12647 if (found) break;
12648
12649 iter--;
12650 }
12651 }
12652
12653 myfree (line_buf_cpy);
12654
12655 myfree (line_buf);
12656
12657 fclose (fp);
12658 }
12659 }
12660
12661 if (esalt_size)
12662 {
12663 local_free (hash_buf.esalt);
12664 }
12665
12666 if (isSalted)
12667 {
12668 local_free (hash_buf.salt);
12669 }
12670
12671 local_free (hash_buf.digest);
12672 }
12673
12674 /**
12675 * Now generate all the buffers required for later
12676 */
12677
12678 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12679
12680 salt_t *salts_buf_new = NULL;
12681 void *esalts_buf_new = NULL;
12682
12683 if (isSalted)
12684 {
12685 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12686
12687 if (esalt_size)
12688 {
12689 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12690 }
12691 }
12692 else
12693 {
12694 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12695 }
12696
12697 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12698
12699 uint digests_cnt = hashes_cnt;
12700 uint digests_done = 0;
12701
12702 size_t size_digests = digests_cnt * dgst_size;
12703 size_t size_shown = digests_cnt * sizeof (uint);
12704
12705 uint *digests_shown = (uint *) mymalloc (size_shown);
12706 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12707
12708 uint salts_cnt = 0;
12709 uint salts_done = 0;
12710
12711 hashinfo_t **hash_info = NULL;
12712
12713 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12714 {
12715 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12716
12717 if (username && (remove || show))
12718 {
12719 uint user_pos;
12720
12721 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12722 {
12723 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12724
12725 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12726 }
12727 }
12728 }
12729
12730 uint *salts_shown = (uint *) mymalloc (size_shown);
12731
12732 salt_t *salt_buf;
12733
12734 {
12735 // copied from inner loop
12736
12737 salt_buf = &salts_buf_new[salts_cnt];
12738
12739 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12740
12741 if (esalt_size)
12742 {
12743 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12744 }
12745
12746 salt_buf->digests_cnt = 0;
12747 salt_buf->digests_done = 0;
12748 salt_buf->digests_offset = 0;
12749
12750 salts_cnt++;
12751 }
12752
12753 if (hashes_buf[0].cracked == 1)
12754 {
12755 digests_shown[0] = 1;
12756
12757 digests_done++;
12758
12759 salt_buf->digests_done++;
12760 }
12761
12762 salt_buf->digests_cnt++;
12763
12764 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12765
12766 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12767 {
12768 hash_info[0] = hashes_buf[0].hash_info;
12769 }
12770
12771 // copy from inner loop
12772
12773 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12774 {
12775 if (isSalted)
12776 {
12777 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12778 {
12779 salt_buf = &salts_buf_new[salts_cnt];
12780
12781 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12782
12783 if (esalt_size)
12784 {
12785 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12786 }
12787
12788 salt_buf->digests_cnt = 0;
12789 salt_buf->digests_done = 0;
12790 salt_buf->digests_offset = hashes_pos;
12791
12792 salts_cnt++;
12793 }
12794 }
12795
12796 if (hashes_buf[hashes_pos].cracked == 1)
12797 {
12798 digests_shown[hashes_pos] = 1;
12799
12800 digests_done++;
12801
12802 salt_buf->digests_done++;
12803 }
12804
12805 salt_buf->digests_cnt++;
12806
12807 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12808
12809 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12810 {
12811 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12812 }
12813 }
12814
12815 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12816 {
12817 salt_t *salt_buf = &salts_buf_new[salt_pos];
12818
12819 if (salt_buf->digests_done == salt_buf->digests_cnt)
12820 {
12821 salts_shown[salt_pos] = 1;
12822
12823 salts_done++;
12824 }
12825
12826 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12827 }
12828
12829 local_free (digests_buf);
12830 local_free (salts_buf);
12831 local_free (esalts_buf);
12832
12833 digests_buf = digests_buf_new;
12834 salts_buf = salts_buf_new;
12835 esalts_buf = esalts_buf_new;
12836
12837 local_free (hashes_buf);
12838
12839 /**
12840 * special modification not set from parser
12841 */
12842
12843 switch (hash_mode)
12844 {
12845 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12846 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12847 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12848 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12849 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12850 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12851 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12852 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12853 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12854 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12855 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12856 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12857 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12858 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12859 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12860 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12861 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12862 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12863 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12864 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12865 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12866 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12867 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12868 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12869 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12870 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12871 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12872 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12873 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12874 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12875 }
12876
12877 if (truecrypt_keyfiles)
12878 {
12879 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12880
12881 char *keyfiles = strdup (truecrypt_keyfiles);
12882
12883 char *keyfile = strtok (keyfiles, ",");
12884
12885 do
12886 {
12887 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12888
12889 } while ((keyfile = strtok (NULL, ",")) != NULL);
12890
12891 free (keyfiles);
12892 }
12893
12894 if (veracrypt_keyfiles)
12895 {
12896 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12897
12898 char *keyfiles = strdup (veracrypt_keyfiles);
12899
12900 char *keyfile = strtok (keyfiles, ",");
12901
12902 do
12903 {
12904 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12905
12906 } while ((keyfile = strtok (NULL, ",")) != NULL);
12907
12908 free (keyfiles);
12909 }
12910
12911 data.digests_cnt = digests_cnt;
12912 data.digests_done = digests_done;
12913 data.digests_buf = digests_buf;
12914 data.digests_shown = digests_shown;
12915 data.digests_shown_tmp = digests_shown_tmp;
12916
12917 data.salts_cnt = salts_cnt;
12918 data.salts_done = salts_done;
12919 data.salts_buf = salts_buf;
12920 data.salts_shown = salts_shown;
12921
12922 data.esalts_buf = esalts_buf;
12923 data.hash_info = hash_info;
12924
12925 /**
12926 * Automatic Optimizers
12927 */
12928
12929 if (salts_cnt == 1)
12930 opti_type |= OPTI_TYPE_SINGLE_SALT;
12931
12932 if (digests_cnt == 1)
12933 opti_type |= OPTI_TYPE_SINGLE_HASH;
12934
12935 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12936 opti_type |= OPTI_TYPE_NOT_ITERATED;
12937
12938 if (attack_mode == ATTACK_MODE_BF)
12939 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12940
12941 data.opti_type = opti_type;
12942
12943 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12944 {
12945 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12946 {
12947 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12948 {
12949 if (opts_type & OPTS_TYPE_ST_ADD80)
12950 {
12951 opts_type &= ~OPTS_TYPE_ST_ADD80;
12952 opts_type |= OPTS_TYPE_PT_ADD80;
12953 }
12954
12955 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12956 {
12957 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12958 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12959 }
12960
12961 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12962 {
12963 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12964 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12965 }
12966 }
12967 }
12968 }
12969
12970 /**
12971 * Some algorithm, like descrypt, can benefit from JIT compilation
12972 */
12973
12974 int force_jit_compilation = -1;
12975
12976 if (hash_mode == 8900)
12977 {
12978 force_jit_compilation = 8900;
12979 }
12980 else if (hash_mode == 9300)
12981 {
12982 force_jit_compilation = 8900;
12983 }
12984 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12985 {
12986 force_jit_compilation = 1500;
12987 }
12988
12989 /**
12990 * generate bitmap tables
12991 */
12992
12993 const uint bitmap_shift1 = 5;
12994 const uint bitmap_shift2 = 13;
12995
12996 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12997
12998 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12999 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13000 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13001 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13002 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13003 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13004 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13005 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13006
13007 uint bitmap_bits;
13008 uint bitmap_nums;
13009 uint bitmap_mask;
13010 uint bitmap_size;
13011
13012 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13013 {
13014 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13015
13016 bitmap_nums = 1 << bitmap_bits;
13017
13018 bitmap_mask = bitmap_nums - 1;
13019
13020 bitmap_size = bitmap_nums * sizeof (uint);
13021
13022 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13023
13024 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;
13025 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;
13026
13027 break;
13028 }
13029
13030 bitmap_nums = 1 << bitmap_bits;
13031
13032 bitmap_mask = bitmap_nums - 1;
13033
13034 bitmap_size = bitmap_nums * sizeof (uint);
13035
13036 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);
13037 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);
13038
13039 /**
13040 * prepare quick rule
13041 */
13042
13043 data.rule_buf_l = rule_buf_l;
13044 data.rule_buf_r = rule_buf_r;
13045
13046 int rule_len_l = (int) strlen (rule_buf_l);
13047 int rule_len_r = (int) strlen (rule_buf_r);
13048
13049 data.rule_len_l = rule_len_l;
13050 data.rule_len_r = rule_len_r;
13051
13052 /**
13053 * load rules
13054 */
13055
13056 uint *all_kernel_rules_cnt = NULL;
13057
13058 kernel_rule_t **all_kernel_rules_buf = NULL;
13059
13060 if (rp_files_cnt)
13061 {
13062 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13063
13064 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13065 }
13066
13067 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13068
13069 int rule_len = 0;
13070
13071 for (uint i = 0; i < rp_files_cnt; i++)
13072 {
13073 uint kernel_rules_avail = 0;
13074
13075 uint kernel_rules_cnt = 0;
13076
13077 kernel_rule_t *kernel_rules_buf = NULL;
13078
13079 char *rp_file = rp_files[i];
13080
13081 char in[BLOCK_SIZE] = { 0 };
13082 char out[BLOCK_SIZE] = { 0 };
13083
13084 FILE *fp = NULL;
13085
13086 uint rule_line = 0;
13087
13088 if ((fp = fopen (rp_file, "rb")) == NULL)
13089 {
13090 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13091
13092 return (-1);
13093 }
13094
13095 while (!feof (fp))
13096 {
13097 memset (rule_buf, 0, HCBUFSIZ);
13098
13099 rule_len = fgetl (fp, rule_buf);
13100
13101 rule_line++;
13102
13103 if (rule_len == 0) continue;
13104
13105 if (rule_buf[0] == '#') continue;
13106
13107 if (kernel_rules_avail == kernel_rules_cnt)
13108 {
13109 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13110
13111 kernel_rules_avail += INCR_RULES;
13112 }
13113
13114 memset (in, 0, BLOCK_SIZE);
13115 memset (out, 0, BLOCK_SIZE);
13116
13117 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13118
13119 if (result == -1)
13120 {
13121 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13122
13123 continue;
13124 }
13125
13126 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13127 {
13128 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13129
13130 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13131
13132 continue;
13133 }
13134
13135 /* its so slow
13136 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13137 {
13138 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13139
13140 continue;
13141 }
13142 */
13143
13144 kernel_rules_cnt++;
13145 }
13146
13147 fclose (fp);
13148
13149 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13150
13151 all_kernel_rules_buf[i] = kernel_rules_buf;
13152 }
13153
13154 /**
13155 * merge rules or automatic rule generator
13156 */
13157
13158 uint kernel_rules_cnt = 0;
13159
13160 kernel_rule_t *kernel_rules_buf = NULL;
13161
13162 if (attack_mode == ATTACK_MODE_STRAIGHT)
13163 {
13164 if (rp_files_cnt)
13165 {
13166 kernel_rules_cnt = 1;
13167
13168 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13169
13170 repeats[0] = kernel_rules_cnt;
13171
13172 for (uint i = 0; i < rp_files_cnt; i++)
13173 {
13174 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13175
13176 repeats[i + 1] = kernel_rules_cnt;
13177 }
13178
13179 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13180
13181 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13182
13183 for (uint i = 0; i < kernel_rules_cnt; i++)
13184 {
13185 uint out_pos = 0;
13186
13187 kernel_rule_t *out = &kernel_rules_buf[i];
13188
13189 for (uint j = 0; j < rp_files_cnt; j++)
13190 {
13191 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13192 uint in_pos;
13193
13194 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13195
13196 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13197 {
13198 if (out_pos == RULES_MAX - 1)
13199 {
13200 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13201
13202 break;
13203 }
13204
13205 out->cmds[out_pos] = in->cmds[in_pos];
13206 }
13207 }
13208 }
13209
13210 local_free (repeats);
13211 }
13212 else if (rp_gen)
13213 {
13214 uint kernel_rules_avail = 0;
13215
13216 while (kernel_rules_cnt < rp_gen)
13217 {
13218 if (kernel_rules_avail == kernel_rules_cnt)
13219 {
13220 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13221
13222 kernel_rules_avail += INCR_RULES;
13223 }
13224
13225 memset (rule_buf, 0, HCBUFSIZ);
13226
13227 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13228
13229 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13230
13231 kernel_rules_cnt++;
13232 }
13233 }
13234 }
13235
13236 myfree (rule_buf);
13237
13238 /**
13239 * generate NOP rules
13240 */
13241
13242 if (kernel_rules_cnt == 0)
13243 {
13244 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13245
13246 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13247
13248 kernel_rules_cnt++;
13249 }
13250
13251 data.kernel_rules_cnt = kernel_rules_cnt;
13252 data.kernel_rules_buf = kernel_rules_buf;
13253
13254 /**
13255 * OpenCL platforms: detect
13256 */
13257
13258 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13259 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13260
13261 cl_uint platforms_cnt = 0;
13262 cl_uint platform_devices_cnt = 0;
13263
13264 if (keyspace == 0)
13265 {
13266 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13267
13268 if (platforms_cnt == 0)
13269 {
13270 log_info ("");
13271 log_info ("ATTENTION! No OpenCL compatible platform found");
13272 log_info ("");
13273 log_info ("You're probably missing the OpenCL runtime installation");
13274 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13275 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13276 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13277 log_info ("");
13278
13279 return (-1);
13280 }
13281
13282 if (opencl_platforms_filter != (uint) -1)
13283 {
13284 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13285
13286 if (opencl_platforms_filter > platform_cnt_mask)
13287 {
13288 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13289
13290 return (-1);
13291 }
13292 }
13293 }
13294
13295 /**
13296 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
13297 */
13298
13299 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13300 {
13301 cl_platform_id platform = platforms[platform_id];
13302
13303 char platform_vendor[INFOSZ] = { 0 };
13304
13305 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13306
13307 #ifdef HAVE_HWMON
13308 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13309 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13310 {
13311 // make sure that we do not directly control the fan for NVidia
13312
13313 gpu_temp_retain = 0;
13314
13315 data.gpu_temp_retain = gpu_temp_retain;
13316 }
13317 #endif // HAVE_NVML || HAVE_NVAPI
13318 #endif
13319 }
13320
13321 /**
13322 * OpenCL device types:
13323 * 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.
13324 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13325 */
13326
13327 if (opencl_device_types == NULL)
13328 {
13329 cl_device_type device_types_all = 0;
13330
13331 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13332 {
13333 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13334
13335 cl_platform_id platform = platforms[platform_id];
13336
13337 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13338
13339 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13340 {
13341 cl_device_id device = platform_devices[platform_devices_id];
13342
13343 cl_device_type device_type;
13344
13345 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13346
13347 device_types_all |= device_type;
13348 }
13349 }
13350
13351 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13352 {
13353 device_types_filter |= CL_DEVICE_TYPE_CPU;
13354 }
13355 }
13356
13357 /**
13358 * OpenCL devices: simply push all devices from all platforms into the same device array
13359 */
13360
13361 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13362
13363 data.devices_param = devices_param;
13364
13365 uint devices_cnt = 0;
13366
13367 uint devices_active = 0;
13368
13369 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13370 {
13371 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13372
13373 cl_platform_id platform = platforms[platform_id];
13374
13375 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13376
13377 char platform_vendor[INFOSZ] = { 0 };
13378
13379 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13380
13381 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13382 // this causes trouble with vendor id based macros
13383 // we'll assign generic to those without special optimization available
13384
13385 cl_uint platform_vendor_id = 0;
13386
13387 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13388 {
13389 platform_vendor_id = VENDOR_ID_AMD;
13390 }
13391 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13392 {
13393 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13394 }
13395 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13396 {
13397 platform_vendor_id = VENDOR_ID_APPLE;
13398 }
13399 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13400 {
13401 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13402 }
13403 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13404 {
13405 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13406 }
13407 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13408 {
13409 platform_vendor_id = VENDOR_ID_MESA;
13410 }
13411 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13412 {
13413 platform_vendor_id = VENDOR_ID_NV;
13414 }
13415 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13416 {
13417 platform_vendor_id = VENDOR_ID_POCL;
13418 }
13419 else
13420 {
13421 platform_vendor_id = VENDOR_ID_GENERIC;
13422 }
13423
13424 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13425 {
13426 size_t param_value_size = 0;
13427
13428 const uint device_id = devices_cnt;
13429
13430 hc_device_param_t *device_param = &data.devices_param[device_id];
13431
13432 device_param->platform_vendor_id = platform_vendor_id;
13433
13434 device_param->device = platform_devices[platform_devices_id];
13435
13436 device_param->device_id = device_id;
13437
13438 device_param->platform_devices_id = platform_devices_id;
13439
13440 // device_type
13441
13442 cl_device_type device_type;
13443
13444 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13445
13446 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13447
13448 device_param->device_type = device_type;
13449
13450 // device_name
13451
13452 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13453
13454 char *device_name = (char *) mymalloc (param_value_size);
13455
13456 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13457
13458 device_param->device_name = device_name;
13459
13460 // device_vendor
13461
13462 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13463
13464 char *device_vendor = (char *) mymalloc (param_value_size);
13465
13466 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13467
13468 device_param->device_vendor = device_vendor;
13469
13470 cl_uint device_vendor_id = 0;
13471
13472 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13473 {
13474 device_vendor_id = VENDOR_ID_AMD;
13475 }
13476 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13477 {
13478 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13479 }
13480 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13481 {
13482 device_vendor_id = VENDOR_ID_APPLE;
13483 }
13484 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13485 {
13486 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13487 }
13488 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13489 {
13490 device_vendor_id = VENDOR_ID_INTEL_SDK;
13491 }
13492 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13493 {
13494 device_vendor_id = VENDOR_ID_MESA;
13495 }
13496 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13497 {
13498 device_vendor_id = VENDOR_ID_NV;
13499 }
13500 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13501 {
13502 device_vendor_id = VENDOR_ID_POCL;
13503 }
13504 else
13505 {
13506 device_vendor_id = VENDOR_ID_GENERIC;
13507 }
13508
13509 device_param->device_vendor_id = device_vendor_id;
13510
13511 // tuning db
13512
13513 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13514
13515 // device_version
13516
13517 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13518
13519 char *device_version = (char *) mymalloc (param_value_size);
13520
13521 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13522
13523 device_param->device_version = device_version;
13524
13525 // device_opencl_version
13526
13527 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13528
13529 char *device_opencl_version = (char *) mymalloc (param_value_size);
13530
13531 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13532
13533 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13534
13535 myfree (device_opencl_version);
13536
13537 // vector_width
13538
13539 cl_uint vector_width;
13540
13541 if (opencl_vector_width_chgd == 0)
13542 {
13543 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13544 {
13545 if (opti_type & OPTI_TYPE_USES_BITS_64)
13546 {
13547 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13548 }
13549 else
13550 {
13551 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13552 }
13553 }
13554 else
13555 {
13556 vector_width = (cl_uint) tuningdb_entry->vector_width;
13557 }
13558 }
13559 else
13560 {
13561 vector_width = opencl_vector_width;
13562 }
13563
13564 if (vector_width > 16) vector_width = 16;
13565
13566 device_param->vector_width = vector_width;
13567
13568 // max_compute_units
13569
13570 cl_uint device_processors;
13571
13572 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13573
13574 device_param->device_processors = device_processors;
13575
13576 // device_maxmem_alloc
13577 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13578
13579 cl_ulong device_maxmem_alloc;
13580
13581 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13582
13583 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13584
13585 // device_global_mem
13586
13587 cl_ulong device_global_mem;
13588
13589 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13590
13591 device_param->device_global_mem = device_global_mem;
13592
13593 // max_work_group_size
13594
13595 size_t device_maxworkgroup_size;
13596
13597 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13598
13599 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13600
13601 // max_clock_frequency
13602
13603 cl_uint device_maxclock_frequency;
13604
13605 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13606
13607 device_param->device_maxclock_frequency = device_maxclock_frequency;
13608
13609 // device_endian_little
13610
13611 cl_bool device_endian_little;
13612
13613 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13614
13615 if (device_endian_little == CL_FALSE)
13616 {
13617 if (data.quiet == 0) log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13618
13619 device_param->skipped = 1;
13620 }
13621
13622 // device_available
13623
13624 cl_bool device_available;
13625
13626 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13627
13628 if (device_available == CL_FALSE)
13629 {
13630 if (data.quiet == 0) log_info ("Device #%u: WARNING: device not available", device_id + 1);
13631
13632 device_param->skipped = 1;
13633 }
13634
13635 // device_compiler_available
13636
13637 cl_bool device_compiler_available;
13638
13639 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13640
13641 if (device_compiler_available == CL_FALSE)
13642 {
13643 if (data.quiet == 0) log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13644
13645 device_param->skipped = 1;
13646 }
13647
13648 // device_execution_capabilities
13649
13650 cl_device_exec_capabilities device_execution_capabilities;
13651
13652 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13653
13654 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13655 {
13656 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13657
13658 device_param->skipped = 1;
13659 }
13660
13661 // device_extensions
13662
13663 size_t device_extensions_size;
13664
13665 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13666
13667 char *device_extensions = mymalloc (device_extensions_size + 1);
13668
13669 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13670
13671 if (strstr (device_extensions, "base_atomics") == 0)
13672 {
13673 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13674
13675 device_param->skipped = 1;
13676 }
13677
13678 if (strstr (device_extensions, "byte_addressable_store") == 0)
13679 {
13680 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13681
13682 device_param->skipped = 1;
13683 }
13684
13685 myfree (device_extensions);
13686
13687 // device_local_mem_size
13688
13689 cl_ulong device_local_mem_size;
13690
13691 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13692
13693 if (device_local_mem_size < 32768)
13694 {
13695 if (data.quiet == 0) log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13696
13697 device_param->skipped = 1;
13698 }
13699
13700 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13701 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13702 // This results in both utilizing it for 50%
13703 // However, Intel has much better SIMD control over their own hardware
13704 // It makes sense to give them full control over their own hardware
13705
13706 if (device_type & CL_DEVICE_TYPE_CPU)
13707 {
13708 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13709 {
13710 if (data.quiet == 0) log_info ("Device #%u: WARNING: not native intel opencl platform", device_id + 1);
13711
13712 device_param->skipped = 1;
13713 }
13714 }
13715
13716 // skipped
13717
13718 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13719 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13720
13721 // driver_version
13722
13723 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13724
13725 char *driver_version = (char *) mymalloc (param_value_size);
13726
13727 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13728
13729 device_param->driver_version = driver_version;
13730
13731 // device_name_chksum
13732
13733 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13734
13735 #if __x86_64__
13736 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);
13737 #else
13738 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);
13739 #endif
13740
13741 uint device_name_digest[4] = { 0 };
13742
13743 md5_64 ((uint *) device_name_chksum, device_name_digest);
13744
13745 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13746
13747 device_param->device_name_chksum = device_name_chksum;
13748
13749 // device_processor_cores
13750
13751 if (device_type & CL_DEVICE_TYPE_CPU)
13752 {
13753 cl_uint device_processor_cores = 1;
13754
13755 device_param->device_processor_cores = device_processor_cores;
13756 }
13757
13758 if (device_type & CL_DEVICE_TYPE_GPU)
13759 {
13760 if (device_vendor_id == VENDOR_ID_AMD)
13761 {
13762 cl_uint device_processor_cores = 0;
13763
13764 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13765
13766 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13767
13768 device_param->device_processor_cores = device_processor_cores;
13769 }
13770 else if (device_vendor_id == VENDOR_ID_NV)
13771 {
13772 cl_uint kernel_exec_timeout = 0;
13773
13774 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13775
13776 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13777
13778 device_param->kernel_exec_timeout = kernel_exec_timeout;
13779
13780 cl_uint device_processor_cores = 0;
13781
13782 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13783
13784 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13785
13786 device_param->device_processor_cores = device_processor_cores;
13787
13788 cl_uint sm_minor = 0;
13789 cl_uint sm_major = 0;
13790
13791 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13792 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13793
13794 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13795 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13796
13797 device_param->sm_minor = sm_minor;
13798 device_param->sm_major = sm_major;
13799 }
13800 else
13801 {
13802 cl_uint device_processor_cores = 1;
13803
13804 device_param->device_processor_cores = device_processor_cores;
13805 }
13806 }
13807
13808 // display results
13809
13810 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13811 {
13812 if (machine_readable == 0)
13813 {
13814 if (device_param->skipped == 0)
13815 {
13816 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13817 device_id + 1,
13818 device_name,
13819 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13820 (unsigned int) (device_global_mem / 1024 / 1024),
13821 (unsigned int) device_processors);
13822 }
13823 else
13824 {
13825 log_info ("Device #%u: %s, skipped",
13826 device_id + 1,
13827 device_name);
13828 }
13829 }
13830 }
13831
13832 // common driver check
13833
13834 if (device_param->skipped == 0)
13835 {
13836 if (device_type & CL_DEVICE_TYPE_GPU)
13837 {
13838 if (platform_vendor_id == VENDOR_ID_AMD)
13839 {
13840 int catalyst_check = (force == 1) ? 0 : 1;
13841
13842 int catalyst_warn = 0;
13843
13844 int catalyst_broken = 0;
13845
13846 if (catalyst_check == 1)
13847 {
13848 catalyst_warn = 1;
13849
13850 // v14.9 and higher
13851 if (atoi (device_param->driver_version) >= 1573)
13852 {
13853 catalyst_warn = 0;
13854 }
13855
13856 catalyst_check = 0;
13857 }
13858
13859 if (catalyst_broken == 1)
13860 {
13861 log_info ("");
13862 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13863 log_info ("It will pass over cracked hashes and does not report them as cracked");
13864 log_info ("You are STRONGLY encouraged not to use it");
13865 log_info ("You can use --force to override this but do not post error reports if you do so");
13866 log_info ("");
13867
13868 return (-1);
13869 }
13870
13871 if (catalyst_warn == 1)
13872 {
13873 log_info ("");
13874 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13875 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13876 log_info ("See hashcat's homepage for official supported catalyst drivers");
13877 #ifdef _WIN
13878 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13879 #endif
13880 log_info ("You can use --force to override this but do not post error reports if you do so");
13881 log_info ("");
13882
13883 return (-1);
13884 }
13885 }
13886 else if (platform_vendor_id == VENDOR_ID_NV)
13887 {
13888 if (device_param->kernel_exec_timeout != 0)
13889 {
13890 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);
13891 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13892 }
13893 }
13894 }
13895
13896 /* turns out pocl still creates segfaults (because of llvm)
13897 if (device_type & CL_DEVICE_TYPE_CPU)
13898 {
13899 if (platform_vendor_id == VENDOR_ID_AMD)
13900 {
13901 if (force == 0)
13902 {
13903 log_info ("");
13904 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13905 log_info ("You are STRONGLY encouraged not to use it");
13906 log_info ("You can use --force to override this but do not post error reports if you do so");
13907 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13908 log_info ("");
13909
13910 return (-1);
13911 }
13912 }
13913 }
13914 */
13915
13916 /**
13917 * kernel accel and loops tuning db adjustment
13918 */
13919
13920 device_param->kernel_accel_min = 1;
13921 device_param->kernel_accel_max = 1024;
13922
13923 device_param->kernel_loops_min = 1;
13924 device_param->kernel_loops_max = 1024;
13925
13926 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13927
13928 if (tuningdb_entry)
13929 {
13930 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13931 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13932
13933 if (_kernel_accel)
13934 {
13935 device_param->kernel_accel_min = _kernel_accel;
13936 device_param->kernel_accel_max = _kernel_accel;
13937 }
13938
13939 if (_kernel_loops)
13940 {
13941 if (workload_profile == 1)
13942 {
13943 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13944 }
13945 else if (workload_profile == 2)
13946 {
13947 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13948 }
13949
13950 device_param->kernel_loops_min = _kernel_loops;
13951 device_param->kernel_loops_max = _kernel_loops;
13952 }
13953 }
13954
13955 // commandline parameters overwrite tuningdb entries
13956
13957 if (kernel_accel)
13958 {
13959 device_param->kernel_accel_min = kernel_accel;
13960 device_param->kernel_accel_max = kernel_accel;
13961 }
13962
13963 if (kernel_loops)
13964 {
13965 device_param->kernel_loops_min = kernel_loops;
13966 device_param->kernel_loops_max = kernel_loops;
13967 }
13968
13969 /**
13970 * activate device
13971 */
13972
13973 devices_active++;
13974 }
13975
13976 // next please
13977
13978 devices_cnt++;
13979 }
13980 }
13981
13982 if (keyspace == 0 && devices_active == 0)
13983 {
13984 log_error ("ERROR: No devices found/left");
13985
13986 return (-1);
13987 }
13988
13989 // 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)
13990
13991 if (devices_filter != (uint) -1)
13992 {
13993 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13994
13995 if (devices_filter > devices_cnt_mask)
13996 {
13997 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13998
13999 return (-1);
14000 }
14001 }
14002
14003 data.devices_cnt = devices_cnt;
14004
14005 data.devices_active = devices_active;
14006
14007 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14008 {
14009 if (machine_readable == 0)
14010 {
14011 log_info ("");
14012 }
14013 }
14014
14015 /**
14016 * HM devices: init
14017 */
14018
14019 #ifdef HAVE_HWMON
14020 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
14021 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0 } };
14022 #endif
14023
14024 #ifdef HAVE_ADL
14025 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0 } };
14026 #endif
14027
14028 if (gpu_temp_disable == 0)
14029 {
14030 #if defined(WIN) && defined(HAVE_NVAPI)
14031 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14032
14033 if (nvapi_init (nvapi) == 0)
14034 data.hm_nv = nvapi;
14035
14036 if (data.hm_nv)
14037 {
14038 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
14039 {
14040 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
14041
14042 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
14043
14044 int tmp_out = 0;
14045
14046 for (int i = 0; i < tmp_in; i++)
14047 {
14048 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
14049 }
14050
14051 for (int i = 0; i < tmp_out; i++)
14052 {
14053 NV_GPU_COOLER_SETTINGS pCoolerSettings;
14054
14055 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
14056
14057 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_supported = 1;
14058 }
14059 }
14060 }
14061 #endif // WIN && HAVE_NVAPI
14062
14063 #if defined(LINUX) && defined(HAVE_NVML)
14064 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14065
14066 if (nvml_init (nvml) == 0)
14067 data.hm_nv = nvml;
14068
14069 if (data.hm_nv)
14070 {
14071 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
14072 {
14073 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
14074
14075 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
14076
14077 int tmp_out = 0;
14078
14079 for (int i = 0; i < tmp_in; i++)
14080 {
14081 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
14082 }
14083
14084 for (int i = 0; i < tmp_out; i++)
14085 {
14086 unsigned int speed;
14087
14088 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_supported = 1;
14089 }
14090 }
14091 }
14092 #endif // LINUX && HAVE_NVML
14093
14094 data.hm_amd = NULL;
14095
14096 #ifdef HAVE_ADL
14097 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14098
14099 if (adl_init (adl) == 0)
14100 data.hm_amd = adl;
14101
14102 if (data.hm_amd)
14103 {
14104 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14105 {
14106 // total number of adapters
14107
14108 int hm_adapters_num;
14109
14110 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
14111
14112 // adapter info
14113
14114 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
14115
14116 if (lpAdapterInfo == NULL) return (-1);
14117
14118 // get a list (of ids of) valid/usable adapters
14119
14120 int num_adl_adapters = 0;
14121
14122 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14123
14124 if (num_adl_adapters > 0)
14125 {
14126 hc_thread_mutex_lock (mux_adl);
14127
14128 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
14129
14130 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14131
14132 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14133 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14134
14135 hc_thread_mutex_unlock (mux_adl);
14136 }
14137
14138 myfree (valid_adl_device_list);
14139 myfree (lpAdapterInfo);
14140 }
14141 }
14142 #endif // HAVE_ADL
14143
14144 if (data.hm_amd == NULL && data.hm_nv == NULL)
14145 {
14146 gpu_temp_disable = 1;
14147 }
14148 }
14149
14150 /**
14151 * OpenCL devices: allocate buffer for device specific information
14152 */
14153
14154 #ifdef HAVE_HWMON
14155 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14156
14157 #ifdef HAVE_ADL
14158 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14159
14160 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14161 #endif // ADL
14162 #endif
14163
14164 /**
14165 * enable custom signal handler(s)
14166 */
14167
14168 if (benchmark == 0)
14169 {
14170 hc_signal (sigHandler_default);
14171 }
14172 else
14173 {
14174 hc_signal (sigHandler_benchmark);
14175 }
14176
14177 /**
14178 * User-defined GPU temp handling
14179 */
14180
14181 #ifdef HAVE_HWMON
14182 if (gpu_temp_disable == 1)
14183 {
14184 gpu_temp_abort = 0;
14185 gpu_temp_retain = 0;
14186 }
14187
14188 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14189 {
14190 if (gpu_temp_abort < gpu_temp_retain)
14191 {
14192 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14193
14194 return (-1);
14195 }
14196 }
14197
14198 data.gpu_temp_disable = gpu_temp_disable;
14199 data.gpu_temp_abort = gpu_temp_abort;
14200 data.gpu_temp_retain = gpu_temp_retain;
14201 #endif
14202
14203 /**
14204 * inform the user
14205 */
14206
14207 if (data.quiet == 0)
14208 {
14209 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14210
14211 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);
14212
14213 if (attack_mode == ATTACK_MODE_STRAIGHT)
14214 {
14215 log_info ("Rules: %u", kernel_rules_cnt);
14216 }
14217
14218 if (opti_type)
14219 {
14220 log_info ("Applicable Optimizers:");
14221
14222 for (uint i = 0; i < 32; i++)
14223 {
14224 const uint opti_bit = 1u << i;
14225
14226 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14227 }
14228 }
14229
14230 /**
14231 * Watchdog and Temperature balance
14232 */
14233
14234 #ifdef HAVE_HWMON
14235 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
14236 {
14237 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14238 }
14239
14240 if (gpu_temp_abort == 0)
14241 {
14242 log_info ("Watchdog: Temperature abort trigger disabled");
14243 }
14244 else
14245 {
14246 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14247 }
14248
14249 if (gpu_temp_retain == 0)
14250 {
14251 log_info ("Watchdog: Temperature retain trigger disabled");
14252 }
14253 else
14254 {
14255 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14256 }
14257
14258 if (data.quiet == 0) log_info ("");
14259 #endif
14260 }
14261
14262 /**
14263 * HM devices: copy
14264 */
14265
14266 if (gpu_temp_disable == 0)
14267 {
14268 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14269 {
14270 hc_device_param_t *device_param = &data.devices_param[device_id];
14271
14272 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14273
14274 if (device_param->skipped) continue;
14275
14276 const uint platform_devices_id = device_param->platform_devices_id;
14277
14278 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
14279 if (device_param->device_vendor_id == VENDOR_ID_NV)
14280 {
14281 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14282 }
14283 #endif
14284
14285 #ifdef HAVE_ADL
14286 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14287 {
14288 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14289 }
14290 #endif
14291 }
14292 }
14293
14294 /**
14295 * Temporary fix:
14296 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14297 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14298 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14299 * Driver / ADL bug?
14300 */
14301
14302 #ifdef HAVE_ADL
14303 if (powertune_enable == 1)
14304 {
14305 hc_thread_mutex_lock (mux_adl);
14306
14307 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14308 {
14309 hc_device_param_t *device_param = &data.devices_param[device_id];
14310
14311 if (device_param->skipped) continue;
14312
14313 if (data.hm_device[device_id].od_version == 6)
14314 {
14315 // set powertune value only
14316
14317 int powertune_supported = 0;
14318
14319 int ADL_rc = 0;
14320
14321 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14322 {
14323 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14324
14325 return (-1);
14326 }
14327
14328 if (powertune_supported != 0)
14329 {
14330 // powertune set
14331 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14332
14333 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14334 {
14335 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14336
14337 return (-1);
14338 }
14339
14340 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14341 {
14342 log_error ("ERROR: Failed to set new ADL PowerControl values");
14343
14344 return (-1);
14345 }
14346 }
14347 }
14348 }
14349
14350 hc_thread_mutex_unlock (mux_adl);
14351 }
14352 #endif // HAVE_ADK
14353 #endif // HAVE_HWMON
14354
14355 #ifdef DEBUG
14356 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14357 #endif
14358
14359 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14360
14361 uint kernel_power_all = 0;
14362
14363 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14364 {
14365 /**
14366 * host buffer
14367 */
14368
14369 hc_device_param_t *device_param = &data.devices_param[device_id];
14370
14371 if (device_param->skipped) continue;
14372
14373 /**
14374 * device properties
14375 */
14376
14377 const char *device_name_chksum = device_param->device_name_chksum;
14378 const u32 device_processors = device_param->device_processors;
14379 const u32 device_processor_cores = device_param->device_processor_cores;
14380
14381 /**
14382 * create context for each device
14383 */
14384
14385 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14386
14387 /**
14388 * create command-queue
14389 */
14390
14391 // not supported with NV
14392 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14393
14394 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14395
14396 /**
14397 * kernel threads: some algorithms need a fixed kernel-threads count
14398 * because of shared memory usage or bitslice
14399 * there needs to be some upper limit, otherwise there's too much overhead
14400 */
14401
14402 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14403
14404 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14405 {
14406 kernel_threads = KERNEL_THREADS_MAX_CPU;
14407 }
14408
14409 if (hash_mode == 1500) kernel_threads = 64; // DES
14410 if (hash_mode == 3000) kernel_threads = 64; // DES
14411 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14412 if (hash_mode == 7500) kernel_threads = 64; // RC4
14413 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14414 if (hash_mode == 9700) kernel_threads = 64; // RC4
14415 if (hash_mode == 9710) kernel_threads = 64; // RC4
14416 if (hash_mode == 9800) kernel_threads = 64; // RC4
14417 if (hash_mode == 9810) kernel_threads = 64; // RC4
14418 if (hash_mode == 10400) kernel_threads = 64; // RC4
14419 if (hash_mode == 10410) kernel_threads = 64; // RC4
14420 if (hash_mode == 10500) kernel_threads = 64; // RC4
14421 if (hash_mode == 13100) kernel_threads = 64; // RC4
14422
14423 /**
14424 * create input buffers on device : calculate size of fixed memory buffers
14425 */
14426
14427 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14428 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14429
14430 device_param->size_root_css = size_root_css;
14431 device_param->size_markov_css = size_markov_css;
14432
14433 size_t size_results = sizeof (uint);
14434
14435 device_param->size_results = size_results;
14436
14437 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14438 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14439
14440 size_t size_plains = digests_cnt * sizeof (plain_t);
14441 size_t size_salts = salts_cnt * sizeof (salt_t);
14442 size_t size_esalts = salts_cnt * esalt_size;
14443
14444 device_param->size_plains = size_plains;
14445 device_param->size_digests = size_digests;
14446 device_param->size_shown = size_shown;
14447 device_param->size_salts = size_salts;
14448
14449 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14450 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14451 size_t size_tm = 32 * sizeof (bs_word_t);
14452
14453 // scryptV stuff
14454
14455 size_t size_scryptV = 1;
14456
14457 if ((hash_mode == 8900) || (hash_mode == 9300))
14458 {
14459 uint tmto_start = 0;
14460 uint tmto_stop = 10;
14461
14462 if (scrypt_tmto)
14463 {
14464 tmto_start = scrypt_tmto;
14465 }
14466 else
14467 {
14468 // in case the user did not specify the tmto manually
14469 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14470 // but set the lower end only in case the user has a device with too less memory
14471
14472 if (hash_mode == 8900)
14473 {
14474 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14475 {
14476 tmto_start = 1;
14477 }
14478 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14479 {
14480 tmto_start = 2;
14481 }
14482 }
14483 else if (hash_mode == 9300)
14484 {
14485 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14486 {
14487 tmto_start = 2;
14488 }
14489 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14490 {
14491 tmto_start = 2;
14492 }
14493 }
14494 }
14495
14496 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14497 {
14498 // TODO: in theory the following calculation needs to be done per salt, not global
14499 // we assume all hashes have the same scrypt settings
14500
14501 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14502
14503 size_scryptV /= 1 << tmto;
14504
14505 size_scryptV *= device_processors * device_processor_cores;
14506
14507 if (size_scryptV > device_param->device_maxmem_alloc)
14508 {
14509 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14510
14511 continue;
14512 }
14513
14514 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14515 {
14516 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14517 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14518 }
14519
14520 break;
14521 }
14522
14523 if (data.salts_buf[0].scrypt_phy == 0)
14524 {
14525 log_error ("ERROR: can't allocate enough device memory");
14526
14527 return -1;
14528 }
14529
14530 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14531 }
14532
14533 /**
14534 * some algorithms need a fixed kernel-loops count
14535 */
14536
14537 if (hash_mode == 1500)
14538 {
14539 const u32 kernel_loops_fixed = 1024;
14540
14541 device_param->kernel_loops_min = kernel_loops_fixed;
14542 device_param->kernel_loops_max = kernel_loops_fixed;
14543 }
14544
14545 if (hash_mode == 3000)
14546 {
14547 const u32 kernel_loops_fixed = 1024;
14548
14549 device_param->kernel_loops_min = kernel_loops_fixed;
14550 device_param->kernel_loops_max = kernel_loops_fixed;
14551 }
14552
14553 if (hash_mode == 8900)
14554 {
14555 const u32 kernel_loops_fixed = 1;
14556
14557 device_param->kernel_loops_min = kernel_loops_fixed;
14558 device_param->kernel_loops_max = kernel_loops_fixed;
14559 }
14560
14561 if (hash_mode == 9300)
14562 {
14563 const u32 kernel_loops_fixed = 1;
14564
14565 device_param->kernel_loops_min = kernel_loops_fixed;
14566 device_param->kernel_loops_max = kernel_loops_fixed;
14567 }
14568
14569 if (hash_mode == 12500)
14570 {
14571 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14572
14573 device_param->kernel_loops_min = kernel_loops_fixed;
14574 device_param->kernel_loops_max = kernel_loops_fixed;
14575 }
14576
14577 /**
14578 * some algorithms have a maximum kernel-loops count
14579 */
14580
14581 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14582 {
14583 u32 innerloop_cnt = 0;
14584
14585 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14586 {
14587 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14588 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14589 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14590 }
14591 else
14592 {
14593 innerloop_cnt = data.salts_buf[0].salt_iter;
14594 }
14595
14596 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14597 (innerloop_cnt <= device_param->kernel_loops_max))
14598 {
14599 device_param->kernel_loops_max = innerloop_cnt;
14600 }
14601 }
14602
14603 u32 kernel_accel_min = device_param->kernel_accel_min;
14604 u32 kernel_accel_max = device_param->kernel_accel_max;
14605
14606 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14607
14608 size_t size_pws = 4;
14609 size_t size_tmps = 4;
14610 size_t size_hooks = 4;
14611
14612 while (kernel_accel_max >= kernel_accel_min)
14613 {
14614 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14615
14616 // size_pws
14617
14618 size_pws = kernel_power_max * sizeof (pw_t);
14619
14620 // size_tmps
14621
14622 switch (hash_mode)
14623 {
14624 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14625 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14626 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14627 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14628 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14629 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14630 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14631 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14632 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14633 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14634 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14635 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14636 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14637 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14638 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14639 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14640 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14641 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14642 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14643 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14644 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14645 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14646 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14647 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14648 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14649 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14650 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14651 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14652 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14653 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14654 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14655 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14656 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14657 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14658 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14659 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14660 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14661 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14662 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14663 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14664 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14665 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14666 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14667 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14668 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14669 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14670 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14671 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14672 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14673 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14674 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14675 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14676 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14677 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14678 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14679 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14680 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14681 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14682 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14683 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14684 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14685 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14686 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14687 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14688 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14689 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14690 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14691 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14692 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14693 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14694 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14695 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14696 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14697 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14698 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14699 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14700 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14701 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14702 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14703 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14704 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14705 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14706 };
14707
14708 // size_hooks
14709
14710 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14711 {
14712 // none yet
14713 }
14714
14715 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14716 // if not, decrease amplifier and try again
14717
14718 int skip = 0;
14719
14720 const u64 size_total
14721 = bitmap_size
14722 + bitmap_size
14723 + bitmap_size
14724 + bitmap_size
14725 + bitmap_size
14726 + bitmap_size
14727 + bitmap_size
14728 + bitmap_size
14729 + size_bfs
14730 + size_combs
14731 + size_digests
14732 + size_esalts
14733 + size_hooks
14734 + size_markov_css
14735 + size_plains
14736 + size_pws
14737 + size_pws // not a bug
14738 + size_results
14739 + size_root_css
14740 + size_rules
14741 + size_rules_c
14742 + size_salts
14743 + size_scryptV
14744 + size_shown
14745 + size_tm
14746 + size_tmps;
14747
14748 // Don't ask me, ask AMD!
14749
14750 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14751 if (size_total > device_param->device_global_mem) skip = 1;
14752
14753 if (skip == 1)
14754 {
14755 kernel_accel_max--;
14756
14757 continue;
14758 }
14759
14760 break;
14761 }
14762
14763 /*
14764 if (kernel_accel_max == 0)
14765 {
14766 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14767
14768 return -1;
14769 }
14770 */
14771
14772 device_param->kernel_accel_min = kernel_accel_min;
14773 device_param->kernel_accel_max = kernel_accel_max;
14774
14775 /*
14776 if (kernel_accel_max < kernel_accel)
14777 {
14778 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14779
14780 device_param->kernel_accel = kernel_accel_max;
14781 }
14782 */
14783
14784 device_param->size_bfs = size_bfs;
14785 device_param->size_combs = size_combs;
14786 device_param->size_rules = size_rules;
14787 device_param->size_rules_c = size_rules_c;
14788 device_param->size_pws = size_pws;
14789 device_param->size_tmps = size_tmps;
14790 device_param->size_hooks = size_hooks;
14791
14792 // do not confuse kernel_accel_max with kernel_accel here
14793
14794 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14795
14796 device_param->kernel_threads = kernel_threads;
14797 device_param->kernel_power_user = kernel_power;
14798
14799 kernel_power_all += kernel_power;
14800
14801 /**
14802 * default building options
14803 */
14804
14805 char build_opts[1024] = { 0 };
14806
14807 // we don't have sm_* on vendors not NV but it doesn't matter
14808
14809 #if _WIN
14810 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);
14811 #else
14812 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);
14813 #endif
14814
14815 char build_opts_new[1024] = { 0 };
14816
14817 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);
14818
14819 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14820
14821 /*
14822 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14823 {
14824 // we do vectorizing much better than the auto-vectorizer
14825
14826 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14827
14828 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14829 }
14830 */
14831
14832 #ifdef DEBUG
14833 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14834 #endif
14835
14836 /**
14837 * main kernel
14838 */
14839
14840 {
14841 /**
14842 * kernel source filename
14843 */
14844
14845 char source_file[256] = { 0 };
14846
14847 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14848
14849 struct stat sst;
14850
14851 if (stat (source_file, &sst) == -1)
14852 {
14853 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14854
14855 return -1;
14856 }
14857
14858 /**
14859 * kernel cached filename
14860 */
14861
14862 char cached_file[256] = { 0 };
14863
14864 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14865
14866 int cached = 1;
14867
14868 struct stat cst;
14869
14870 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14871 {
14872 cached = 0;
14873 }
14874
14875 /**
14876 * kernel compile or load
14877 */
14878
14879 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14880
14881 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14882
14883 if (force_jit_compilation == -1)
14884 {
14885 if (cached == 0)
14886 {
14887 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14888
14889 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14890
14891 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14892
14893 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14894
14895 #ifdef DEBUG
14896 size_t build_log_size = 0;
14897
14898 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14899
14900 if (build_log_size > 1)
14901 {
14902 char *build_log = (char *) malloc (build_log_size + 1);
14903
14904 memset (build_log, 0, build_log_size + 1);
14905
14906 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14907
14908 puts (build_log);
14909
14910 free (build_log);
14911 }
14912 #endif
14913
14914 if (rc != 0)
14915 {
14916 device_param->skipped = true;
14917
14918 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14919
14920 continue;
14921 }
14922
14923 size_t binary_size;
14924
14925 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14926
14927 u8 *binary = (u8 *) mymalloc (binary_size);
14928
14929 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14930
14931 writeProgramBin (cached_file, binary, binary_size);
14932
14933 local_free (binary);
14934 }
14935 else
14936 {
14937 #ifdef DEBUG
14938 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14939 #endif
14940
14941 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14942
14943 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14944
14945 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14946 }
14947 }
14948 else
14949 {
14950 #ifdef DEBUG
14951 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14952 #endif
14953
14954 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14955
14956 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14957
14958 char build_opts_update[1024] = { 0 };
14959
14960 if (force_jit_compilation == 1500)
14961 {
14962 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14963 }
14964 else if (force_jit_compilation == 8900)
14965 {
14966 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);
14967 }
14968 else
14969 {
14970 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14971 }
14972
14973 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14974
14975 #ifdef DEBUG
14976 size_t build_log_size = 0;
14977
14978 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14979
14980 if (build_log_size > 1)
14981 {
14982 char *build_log = (char *) malloc (build_log_size + 1);
14983
14984 memset (build_log, 0, build_log_size + 1);
14985
14986 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14987
14988 puts (build_log);
14989
14990 free (build_log);
14991 }
14992 #endif
14993
14994 if (rc != 0)
14995 {
14996 device_param->skipped = true;
14997
14998 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14999 }
15000 }
15001
15002 local_free (kernel_lengths);
15003 local_free (kernel_sources[0]);
15004 local_free (kernel_sources);
15005 }
15006
15007 /**
15008 * word generator kernel
15009 */
15010
15011 if (attack_mode != ATTACK_MODE_STRAIGHT)
15012 {
15013 /**
15014 * kernel mp source filename
15015 */
15016
15017 char source_file[256] = { 0 };
15018
15019 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15020
15021 struct stat sst;
15022
15023 if (stat (source_file, &sst) == -1)
15024 {
15025 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15026
15027 return -1;
15028 }
15029
15030 /**
15031 * kernel mp cached filename
15032 */
15033
15034 char cached_file[256] = { 0 };
15035
15036 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15037
15038 int cached = 1;
15039
15040 struct stat cst;
15041
15042 if (stat (cached_file, &cst) == -1)
15043 {
15044 cached = 0;
15045 }
15046
15047 /**
15048 * kernel compile or load
15049 */
15050
15051 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15052
15053 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15054
15055 if (cached == 0)
15056 {
15057 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15058 if (quiet == 0) log_info ("");
15059
15060 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15061
15062 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15063
15064 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15065
15066 if (rc != 0)
15067 {
15068 device_param->skipped = true;
15069
15070 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15071
15072 continue;
15073 }
15074
15075 size_t binary_size;
15076
15077 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15078
15079 u8 *binary = (u8 *) mymalloc (binary_size);
15080
15081 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15082
15083 writeProgramBin (cached_file, binary, binary_size);
15084
15085 local_free (binary);
15086 }
15087 else
15088 {
15089 #ifdef DEBUG
15090 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15091 #endif
15092
15093 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15094
15095 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15096
15097 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15098 }
15099
15100 local_free (kernel_lengths);
15101 local_free (kernel_sources[0]);
15102 local_free (kernel_sources);
15103 }
15104
15105 /**
15106 * amplifier kernel
15107 */
15108
15109 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15110 {
15111
15112 }
15113 else
15114 {
15115 /**
15116 * kernel amp source filename
15117 */
15118
15119 char source_file[256] = { 0 };
15120
15121 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15122
15123 struct stat sst;
15124
15125 if (stat (source_file, &sst) == -1)
15126 {
15127 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15128
15129 return -1;
15130 }
15131
15132 /**
15133 * kernel amp cached filename
15134 */
15135
15136 char cached_file[256] = { 0 };
15137
15138 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15139
15140 int cached = 1;
15141
15142 struct stat cst;
15143
15144 if (stat (cached_file, &cst) == -1)
15145 {
15146 cached = 0;
15147 }
15148
15149 /**
15150 * kernel compile or load
15151 */
15152
15153 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15154
15155 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15156
15157 if (cached == 0)
15158 {
15159 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15160 if (quiet == 0) log_info ("");
15161
15162 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15163
15164 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15165
15166 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15167
15168 if (rc != 0)
15169 {
15170 device_param->skipped = true;
15171
15172 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15173
15174 continue;
15175 }
15176
15177 size_t binary_size;
15178
15179 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15180
15181 u8 *binary = (u8 *) mymalloc (binary_size);
15182
15183 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15184
15185 writeProgramBin (cached_file, binary, binary_size);
15186
15187 local_free (binary);
15188 }
15189 else
15190 {
15191 #ifdef DEBUG
15192 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15193 #endif
15194
15195 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15196
15197 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15198
15199 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15200 }
15201
15202 local_free (kernel_lengths);
15203 local_free (kernel_sources[0]);
15204 local_free (kernel_sources);
15205 }
15206
15207 // some algorithm collide too fast, make that impossible
15208
15209 if (benchmark == 1)
15210 {
15211 ((uint *) digests_buf)[0] = -1;
15212 ((uint *) digests_buf)[1] = -1;
15213 ((uint *) digests_buf)[2] = -1;
15214 ((uint *) digests_buf)[3] = -1;
15215 }
15216
15217 /**
15218 * global buffers
15219 */
15220
15221 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15222 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15223 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15224 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15225 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15226 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15227 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15228 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15229 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15230 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15231 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15232 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15233 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15234 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15235 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15236 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15237 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15238 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15239
15240 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);
15241 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);
15242 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);
15243 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);
15244 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);
15245 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);
15246 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);
15247 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);
15248 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15249 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15250 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15251
15252 /**
15253 * special buffers
15254 */
15255
15256 if (attack_kern == ATTACK_KERN_STRAIGHT)
15257 {
15258 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15259 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15260
15261 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15262 }
15263 else if (attack_kern == ATTACK_KERN_COMBI)
15264 {
15265 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15266 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15267 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15268 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15269 }
15270 else if (attack_kern == ATTACK_KERN_BF)
15271 {
15272 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15273 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15274 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15275 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15276 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15277 }
15278
15279 if (size_esalts)
15280 {
15281 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15282
15283 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15284 }
15285
15286 /**
15287 * main host data
15288 */
15289
15290 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15291
15292 device_param->pws_buf = pws_buf;
15293
15294 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15295
15296 device_param->combs_buf = combs_buf;
15297
15298 void *hooks_buf = mymalloc (size_hooks);
15299
15300 device_param->hooks_buf = hooks_buf;
15301
15302 /**
15303 * kernel args
15304 */
15305
15306 device_param->kernel_params_buf32[21] = bitmap_mask;
15307 device_param->kernel_params_buf32[22] = bitmap_shift1;
15308 device_param->kernel_params_buf32[23] = bitmap_shift2;
15309 device_param->kernel_params_buf32[24] = 0; // salt_pos
15310 device_param->kernel_params_buf32[25] = 0; // loop_pos
15311 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15312 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15313 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15314 device_param->kernel_params_buf32[29] = 0; // digests_offset
15315 device_param->kernel_params_buf32[30] = 0; // combs_mode
15316 device_param->kernel_params_buf32[31] = 0; // gid_max
15317
15318 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15319 ? &device_param->d_pws_buf
15320 : &device_param->d_pws_amp_buf;
15321 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15322 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15323 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15324 device_param->kernel_params[ 4] = &device_param->d_tmps;
15325 device_param->kernel_params[ 5] = &device_param->d_hooks;
15326 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15327 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15328 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15329 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15330 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15331 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15332 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15333 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15334 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15335 device_param->kernel_params[15] = &device_param->d_digests_buf;
15336 device_param->kernel_params[16] = &device_param->d_digests_shown;
15337 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15338 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15339 device_param->kernel_params[19] = &device_param->d_result;
15340 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15341 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15342 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15343 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15344 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15345 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15346 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15347 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15348 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15349 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15350 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15351 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15352
15353 device_param->kernel_params_mp_buf64[3] = 0;
15354 device_param->kernel_params_mp_buf32[4] = 0;
15355 device_param->kernel_params_mp_buf32[5] = 0;
15356 device_param->kernel_params_mp_buf32[6] = 0;
15357 device_param->kernel_params_mp_buf32[7] = 0;
15358 device_param->kernel_params_mp_buf32[8] = 0;
15359
15360 device_param->kernel_params_mp[0] = NULL;
15361 device_param->kernel_params_mp[1] = NULL;
15362 device_param->kernel_params_mp[2] = NULL;
15363 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15364 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15365 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15366 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15367 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15368 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15369
15370 device_param->kernel_params_mp_l_buf64[3] = 0;
15371 device_param->kernel_params_mp_l_buf32[4] = 0;
15372 device_param->kernel_params_mp_l_buf32[5] = 0;
15373 device_param->kernel_params_mp_l_buf32[6] = 0;
15374 device_param->kernel_params_mp_l_buf32[7] = 0;
15375 device_param->kernel_params_mp_l_buf32[8] = 0;
15376 device_param->kernel_params_mp_l_buf32[9] = 0;
15377
15378 device_param->kernel_params_mp_l[0] = NULL;
15379 device_param->kernel_params_mp_l[1] = NULL;
15380 device_param->kernel_params_mp_l[2] = NULL;
15381 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15382 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15383 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15384 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15385 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15386 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15387 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15388
15389 device_param->kernel_params_mp_r_buf64[3] = 0;
15390 device_param->kernel_params_mp_r_buf32[4] = 0;
15391 device_param->kernel_params_mp_r_buf32[5] = 0;
15392 device_param->kernel_params_mp_r_buf32[6] = 0;
15393 device_param->kernel_params_mp_r_buf32[7] = 0;
15394 device_param->kernel_params_mp_r_buf32[8] = 0;
15395
15396 device_param->kernel_params_mp_r[0] = NULL;
15397 device_param->kernel_params_mp_r[1] = NULL;
15398 device_param->kernel_params_mp_r[2] = NULL;
15399 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15400 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15401 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15402 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15403 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15404 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15405
15406 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15407 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15408
15409 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15410 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15411 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15412 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15413 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15414 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15415 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15416
15417 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15418 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15419
15420 device_param->kernel_params_memset_buf32[1] = 0; // value
15421 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15422
15423 device_param->kernel_params_memset[0] = NULL;
15424 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15425 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15426
15427 /**
15428 * kernel name
15429 */
15430
15431 size_t kernel_wgs_tmp;
15432
15433 char kernel_name[64] = { 0 };
15434
15435 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15436 {
15437 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15438 {
15439 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15440
15441 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15442
15443 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15444
15445 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15446
15447 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15448
15449 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15450 }
15451 else
15452 {
15453 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15454
15455 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15456
15457 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15458
15459 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15460
15461 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15462
15463 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15464 }
15465
15466 if (data.attack_mode == ATTACK_MODE_BF)
15467 {
15468 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15469 {
15470 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15471
15472 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15473
15474 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);
15475 }
15476 }
15477 }
15478 else
15479 {
15480 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15481
15482 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15483
15484 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15485
15486 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15487
15488 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15489
15490 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15491
15492 if (opts_type & OPTS_TYPE_HOOK12)
15493 {
15494 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15495
15496 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15497
15498 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);
15499 }
15500
15501 if (opts_type & OPTS_TYPE_HOOK23)
15502 {
15503 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15504
15505 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15506
15507 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);
15508 }
15509 }
15510
15511 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);
15512 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);
15513 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);
15514
15515 for (uint i = 0; i <= 20; i++)
15516 {
15517 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15518 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15519 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15520
15521 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15522 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15523 }
15524
15525 for (uint i = 21; i <= 31; i++)
15526 {
15527 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15528 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15529 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15530
15531 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15532 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15533 }
15534
15535 // GPU memset
15536
15537 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15538
15539 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);
15540
15541 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15542 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15543 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15544
15545 // MP start
15546
15547 if (attack_mode == ATTACK_MODE_BF)
15548 {
15549 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15550 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15551
15552 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);
15553 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);
15554
15555 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15556 {
15557 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15558 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15559 }
15560 }
15561 else if (attack_mode == ATTACK_MODE_HYBRID1)
15562 {
15563 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15564
15565 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);
15566 }
15567 else if (attack_mode == ATTACK_MODE_HYBRID2)
15568 {
15569 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15570
15571 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);
15572 }
15573
15574 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15575 {
15576 // nothing to do
15577 }
15578 else
15579 {
15580 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15581
15582 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);
15583 }
15584
15585 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15586 {
15587 // nothing to do
15588 }
15589 else
15590 {
15591 for (uint i = 0; i < 5; i++)
15592 {
15593 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15594 }
15595
15596 for (uint i = 5; i < 7; i++)
15597 {
15598 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15599 }
15600 }
15601
15602 // maybe this has been updated by clGetKernelWorkGroupInfo()
15603 // value can only be decreased, so we don't need to reallocate buffers
15604
15605 device_param->kernel_threads = kernel_threads;
15606
15607 // zero some data buffers
15608
15609 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15610 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15611 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15612 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15613 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15614 run_kernel_bzero (device_param, device_param->d_result, size_results);
15615
15616 /**
15617 * special buffers
15618 */
15619
15620 if (attack_kern == ATTACK_KERN_STRAIGHT)
15621 {
15622 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15623 }
15624 else if (attack_kern == ATTACK_KERN_COMBI)
15625 {
15626 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15627 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15628 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15629 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15630 }
15631 else if (attack_kern == ATTACK_KERN_BF)
15632 {
15633 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15634 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15635 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15636 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15637 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15638 }
15639
15640 /**
15641 * Store thermal target temperature so we can send a notice to user
15642 */
15643
15644 #if defined(HAVE_HWMON)
15645 if (gpu_temp_disable == 0)
15646 {
15647 const int gpu_temp_threshold_slowdown = hm_get_threshold_slowdown_with_device_id (device_id);
15648
15649 data.hm_device[device_id].gpu_temp_threshold_slowdown = (gpu_temp_threshold_slowdown == -1) ? 100000 : gpu_temp_threshold_slowdown;
15650 }
15651 #endif
15652
15653 /**
15654 * Store initial fanspeed if gpu_temp_retain is enabled
15655 */
15656
15657 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15658 int gpu_temp_retain_set = 0;
15659
15660 if (gpu_temp_disable == 0)
15661 {
15662 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15663 {
15664 hc_thread_mutex_lock (mux_adl);
15665
15666 if (data.hm_device[device_id].fan_supported == 1)
15667 {
15668 if (gpu_temp_retain_chgd == 0)
15669 {
15670 uint cur_temp = 0;
15671 uint default_temp = 0;
15672
15673 int ADL_rc = hm_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
15674
15675 if (ADL_rc == ADL_OK)
15676 {
15677 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15678
15679 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15680
15681 // special case with multi gpu setups: always use minimum retain
15682
15683 if (gpu_temp_retain_set == 0)
15684 {
15685 gpu_temp_retain = gpu_temp_retain_target;
15686 gpu_temp_retain_set = 1;
15687 }
15688 else
15689 {
15690 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15691 }
15692
15693 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15694 }
15695 }
15696
15697 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15698
15699 temp_retain_fanspeed_value[device_id] = fan_speed;
15700
15701 if (fan_speed == -1)
15702 {
15703 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15704
15705 temp_retain_fanspeed_value[device_id] = 0;
15706 }
15707 }
15708
15709 hc_thread_mutex_unlock (mux_adl);
15710 }
15711 }
15712
15713 /**
15714 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15715 */
15716
15717 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15718 {
15719 hc_thread_mutex_lock (mux_adl);
15720
15721 if (data.hm_device[device_id].od_version == 6)
15722 {
15723 int ADL_rc;
15724
15725 // check powertune capabilities first, if not available then skip device
15726
15727 int powertune_supported = 0;
15728
15729 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15730 {
15731 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15732
15733 return (-1);
15734 }
15735
15736 if (powertune_supported != 0)
15737 {
15738 // powercontrol settings
15739
15740 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15741
15742 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15743 {
15744 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15745 }
15746
15747 if (ADL_rc != ADL_OK)
15748 {
15749 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15750
15751 return (-1);
15752 }
15753
15754 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15755 {
15756 log_error ("ERROR: Failed to set new ADL PowerControl values");
15757
15758 return (-1);
15759 }
15760
15761 // clocks
15762
15763 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15764
15765 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15766
15767 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)
15768 {
15769 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15770
15771 return (-1);
15772 }
15773
15774 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15775
15776 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15777
15778 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15779 {
15780 log_error ("ERROR: Failed to get ADL device capabilities");
15781
15782 return (-1);
15783 }
15784
15785 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15786 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15787
15788 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15789 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15790
15791 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15792 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15793
15794 // warning if profile has too low max values
15795
15796 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15797 {
15798 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15799 }
15800
15801 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15802 {
15803 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15804 }
15805
15806 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15807
15808 performance_state->iNumberOfPerformanceLevels = 2;
15809
15810 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15811 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15812 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15813 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15814
15815 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)
15816 {
15817 log_info ("ERROR: Failed to set ADL performance state");
15818
15819 return (-1);
15820 }
15821
15822 local_free (performance_state);
15823 }
15824 }
15825
15826 hc_thread_mutex_unlock (mux_adl);
15827 }
15828 #endif // HAVE_HWMON && HAVE_ADL
15829 }
15830
15831 data.kernel_power_all = kernel_power_all;
15832
15833 if (data.quiet == 0) log_info_nn ("");
15834
15835 /**
15836 * In benchmark-mode, inform user which algorithm is checked
15837 */
15838
15839 if (benchmark == 1)
15840 {
15841 if (machine_readable == 0)
15842 {
15843 quiet = 0;
15844
15845 data.quiet = quiet;
15846
15847 char *hash_type = strhashtype (data.hash_mode); // not a bug
15848
15849 log_info ("Hashtype: %s", hash_type);
15850 log_info ("");
15851 }
15852 }
15853
15854 /**
15855 * keep track of the progress
15856 */
15857
15858 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15859 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15860 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15861
15862 /**
15863 * open filehandles
15864 */
15865
15866 #if _WIN
15867 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15868 {
15869 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15870
15871 return (-1);
15872 }
15873
15874 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15875 {
15876 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15877
15878 return (-1);
15879 }
15880
15881 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15882 {
15883 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15884
15885 return (-1);
15886 }
15887 #endif
15888
15889 /**
15890 * dictionary pad
15891 */
15892
15893 segment_size *= (1024 * 1024);
15894
15895 data.segment_size = segment_size;
15896
15897 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15898
15899 wl_data->buf = (char *) mymalloc (segment_size);
15900 wl_data->avail = segment_size;
15901 wl_data->incr = segment_size;
15902 wl_data->cnt = 0;
15903 wl_data->pos = 0;
15904
15905 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15906
15907 data.wordlist_mode = wordlist_mode;
15908
15909 cs_t *css_buf = NULL;
15910 uint css_cnt = 0;
15911 uint dictcnt = 0;
15912 uint maskcnt = 1;
15913 char **masks = NULL;
15914 char **dictfiles = NULL;
15915
15916 uint mask_from_file = 0;
15917
15918 if (attack_mode == ATTACK_MODE_STRAIGHT)
15919 {
15920 if (wordlist_mode == WL_MODE_FILE)
15921 {
15922 int wls_left = myargc - (optind + 1);
15923
15924 for (int i = 0; i < wls_left; i++)
15925 {
15926 char *l0_filename = myargv[optind + 1 + i];
15927
15928 struct stat l0_stat;
15929
15930 if (stat (l0_filename, &l0_stat) == -1)
15931 {
15932 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15933
15934 return (-1);
15935 }
15936
15937 uint is_dir = S_ISDIR (l0_stat.st_mode);
15938
15939 if (is_dir == 0)
15940 {
15941 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15942
15943 dictcnt++;
15944
15945 dictfiles[dictcnt - 1] = l0_filename;
15946 }
15947 else
15948 {
15949 // do not allow --keyspace w/ a directory
15950
15951 if (keyspace == 1)
15952 {
15953 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15954
15955 return (-1);
15956 }
15957
15958 char **dictionary_files = NULL;
15959
15960 dictionary_files = scan_directory (l0_filename);
15961
15962 if (dictionary_files != NULL)
15963 {
15964 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15965
15966 for (int d = 0; dictionary_files[d] != NULL; d++)
15967 {
15968 char *l1_filename = dictionary_files[d];
15969
15970 struct stat l1_stat;
15971
15972 if (stat (l1_filename, &l1_stat) == -1)
15973 {
15974 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15975
15976 return (-1);
15977 }
15978
15979 if (S_ISREG (l1_stat.st_mode))
15980 {
15981 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15982
15983 dictcnt++;
15984
15985 dictfiles[dictcnt - 1] = strdup (l1_filename);
15986 }
15987 }
15988 }
15989
15990 local_free (dictionary_files);
15991 }
15992 }
15993
15994 if (dictcnt < 1)
15995 {
15996 log_error ("ERROR: No usable dictionary file found.");
15997
15998 return (-1);
15999 }
16000 }
16001 else if (wordlist_mode == WL_MODE_STDIN)
16002 {
16003 dictcnt = 1;
16004 }
16005 }
16006 else if (attack_mode == ATTACK_MODE_COMBI)
16007 {
16008 // display
16009
16010 char *dictfile1 = myargv[optind + 1 + 0];
16011 char *dictfile2 = myargv[optind + 1 + 1];
16012
16013 // find the bigger dictionary and use as base
16014
16015 FILE *fp1 = NULL;
16016 FILE *fp2 = NULL;
16017
16018 struct stat tmp_stat;
16019
16020 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16021 {
16022 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16023
16024 return (-1);
16025 }
16026
16027 if (stat (dictfile1, &tmp_stat) == -1)
16028 {
16029 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16030
16031 fclose (fp1);
16032
16033 return (-1);
16034 }
16035
16036 if (S_ISDIR (tmp_stat.st_mode))
16037 {
16038 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16039
16040 fclose (fp1);
16041
16042 return (-1);
16043 }
16044
16045 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16046 {
16047 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16048
16049 fclose (fp1);
16050
16051 return (-1);
16052 }
16053
16054 if (stat (dictfile2, &tmp_stat) == -1)
16055 {
16056 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16057
16058 fclose (fp1);
16059 fclose (fp2);
16060
16061 return (-1);
16062 }
16063
16064 if (S_ISDIR (tmp_stat.st_mode))
16065 {
16066 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16067
16068 fclose (fp1);
16069 fclose (fp2);
16070
16071 return (-1);
16072 }
16073
16074 data.combs_cnt = 1;
16075
16076 data.quiet = 1;
16077
16078 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16079
16080 data.quiet = quiet;
16081
16082 if (words1_cnt == 0)
16083 {
16084 log_error ("ERROR: %s: empty file", dictfile1);
16085
16086 fclose (fp1);
16087 fclose (fp2);
16088
16089 return (-1);
16090 }
16091
16092 data.combs_cnt = 1;
16093
16094 data.quiet = 1;
16095
16096 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16097
16098 data.quiet = quiet;
16099
16100 if (words2_cnt == 0)
16101 {
16102 log_error ("ERROR: %s: empty file", dictfile2);
16103
16104 fclose (fp1);
16105 fclose (fp2);
16106
16107 return (-1);
16108 }
16109
16110 fclose (fp1);
16111 fclose (fp2);
16112
16113 data.dictfile = dictfile1;
16114 data.dictfile2 = dictfile2;
16115
16116 if (words1_cnt >= words2_cnt)
16117 {
16118 data.combs_cnt = words2_cnt;
16119 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16120
16121 dictfiles = &data.dictfile;
16122
16123 dictcnt = 1;
16124 }
16125 else
16126 {
16127 data.combs_cnt = words1_cnt;
16128 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16129
16130 dictfiles = &data.dictfile2;
16131
16132 dictcnt = 1;
16133
16134 // we also have to switch wordlist related rules!
16135
16136 char *tmpc = data.rule_buf_l;
16137
16138 data.rule_buf_l = data.rule_buf_r;
16139 data.rule_buf_r = tmpc;
16140
16141 int tmpi = data.rule_len_l;
16142
16143 data.rule_len_l = data.rule_len_r;
16144 data.rule_len_r = tmpi;
16145 }
16146 }
16147 else if (attack_mode == ATTACK_MODE_BF)
16148 {
16149 char *mask = NULL;
16150
16151 maskcnt = 0;
16152
16153 if (benchmark == 0)
16154 {
16155 mask = myargv[optind + 1];
16156
16157 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16158
16159 if ((optind + 2) <= myargc)
16160 {
16161 struct stat file_stat;
16162
16163 if (stat (mask, &file_stat) == -1)
16164 {
16165 maskcnt = 1;
16166
16167 masks[maskcnt - 1] = mystrdup (mask);
16168 }
16169 else
16170 {
16171 int wls_left = myargc - (optind + 1);
16172
16173 uint masks_avail = INCR_MASKS;
16174
16175 for (int i = 0; i < wls_left; i++)
16176 {
16177 if (i != 0)
16178 {
16179 mask = myargv[optind + 1 + i];
16180
16181 if (stat (mask, &file_stat) == -1)
16182 {
16183 log_error ("ERROR: %s: %s", mask, strerror (errno));
16184
16185 return (-1);
16186 }
16187 }
16188
16189 uint is_file = S_ISREG (file_stat.st_mode);
16190
16191 if (is_file == 1)
16192 {
16193 FILE *mask_fp;
16194
16195 if ((mask_fp = fopen (mask, "r")) == NULL)
16196 {
16197 log_error ("ERROR: %s: %s", mask, strerror (errno));
16198
16199 return (-1);
16200 }
16201
16202 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16203
16204 while (!feof (mask_fp))
16205 {
16206 memset (line_buf, 0, HCBUFSIZ);
16207
16208 int line_len = fgetl (mask_fp, line_buf);
16209
16210 if (line_len == 0) continue;
16211
16212 if (line_buf[0] == '#') continue;
16213
16214 if (masks_avail == maskcnt)
16215 {
16216 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16217
16218 masks_avail += INCR_MASKS;
16219 }
16220
16221 masks[maskcnt] = mystrdup (line_buf);
16222
16223 maskcnt++;
16224 }
16225
16226 myfree (line_buf);
16227
16228 fclose (mask_fp);
16229 }
16230 else
16231 {
16232 log_error ("ERROR: %s: unsupported file-type", mask);
16233
16234 return (-1);
16235 }
16236 }
16237
16238 mask_from_file = 1;
16239 }
16240 }
16241 else
16242 {
16243 custom_charset_1 = (char *) "?l?d?u";
16244 custom_charset_2 = (char *) "?l?d";
16245 custom_charset_3 = (char *) "?l?d*!$@_";
16246
16247 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16248 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16249 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16250
16251 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16252
16253 wordlist_mode = WL_MODE_MASK;
16254
16255 data.wordlist_mode = wordlist_mode;
16256
16257 increment = 1;
16258
16259 maskcnt = 1;
16260 }
16261 }
16262 else
16263 {
16264 /**
16265 * generate full masks and charsets
16266 */
16267
16268 masks = (char **) mymalloc (sizeof (char *));
16269
16270 switch (hash_mode)
16271 {
16272 case 1731: pw_min = 5;
16273 pw_max = 5;
16274 mask = mystrdup ("?b?b?b?b?b");
16275 break;
16276 case 12500: pw_min = 5;
16277 pw_max = 5;
16278 mask = mystrdup ("?b?b?b?b?b");
16279 break;
16280 default: pw_min = 7;
16281 pw_max = 7;
16282 mask = mystrdup ("?b?b?b?b?b?b?b");
16283 break;
16284 }
16285
16286 maskcnt = 1;
16287
16288 masks[maskcnt - 1] = mystrdup (mask);
16289
16290 wordlist_mode = WL_MODE_MASK;
16291
16292 data.wordlist_mode = wordlist_mode;
16293
16294 increment = 1;
16295 }
16296
16297 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16298
16299 if (increment)
16300 {
16301 if (increment_min > pw_min) pw_min = increment_min;
16302
16303 if (increment_max < pw_max) pw_max = increment_max;
16304 }
16305 }
16306 else if (attack_mode == ATTACK_MODE_HYBRID1)
16307 {
16308 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16309
16310 // display
16311
16312 char *mask = myargv[myargc - 1];
16313
16314 maskcnt = 0;
16315
16316 masks = (char **) mymalloc (1 * sizeof (char *));
16317
16318 // mod
16319
16320 struct stat file_stat;
16321
16322 if (stat (mask, &file_stat) == -1)
16323 {
16324 maskcnt = 1;
16325
16326 masks[maskcnt - 1] = mystrdup (mask);
16327 }
16328 else
16329 {
16330 uint is_file = S_ISREG (file_stat.st_mode);
16331
16332 if (is_file == 1)
16333 {
16334 FILE *mask_fp;
16335
16336 if ((mask_fp = fopen (mask, "r")) == NULL)
16337 {
16338 log_error ("ERROR: %s: %s", mask, strerror (errno));
16339
16340 return (-1);
16341 }
16342
16343 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16344
16345 uint masks_avail = 1;
16346
16347 while (!feof (mask_fp))
16348 {
16349 memset (line_buf, 0, HCBUFSIZ);
16350
16351 int line_len = fgetl (mask_fp, line_buf);
16352
16353 if (line_len == 0) continue;
16354
16355 if (line_buf[0] == '#') continue;
16356
16357 if (masks_avail == maskcnt)
16358 {
16359 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16360
16361 masks_avail += INCR_MASKS;
16362 }
16363
16364 masks[maskcnt] = mystrdup (line_buf);
16365
16366 maskcnt++;
16367 }
16368
16369 myfree (line_buf);
16370
16371 fclose (mask_fp);
16372
16373 mask_from_file = 1;
16374 }
16375 else
16376 {
16377 maskcnt = 1;
16378
16379 masks[maskcnt - 1] = mystrdup (mask);
16380 }
16381 }
16382
16383 // base
16384
16385 int wls_left = myargc - (optind + 2);
16386
16387 for (int i = 0; i < wls_left; i++)
16388 {
16389 char *filename = myargv[optind + 1 + i];
16390
16391 struct stat file_stat;
16392
16393 if (stat (filename, &file_stat) == -1)
16394 {
16395 log_error ("ERROR: %s: %s", filename, strerror (errno));
16396
16397 return (-1);
16398 }
16399
16400 uint is_dir = S_ISDIR (file_stat.st_mode);
16401
16402 if (is_dir == 0)
16403 {
16404 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16405
16406 dictcnt++;
16407
16408 dictfiles[dictcnt - 1] = filename;
16409 }
16410 else
16411 {
16412 // do not allow --keyspace w/ a directory
16413
16414 if (keyspace == 1)
16415 {
16416 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16417
16418 return (-1);
16419 }
16420
16421 char **dictionary_files = NULL;
16422
16423 dictionary_files = scan_directory (filename);
16424
16425 if (dictionary_files != NULL)
16426 {
16427 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16428
16429 for (int d = 0; dictionary_files[d] != NULL; d++)
16430 {
16431 char *l1_filename = dictionary_files[d];
16432
16433 struct stat l1_stat;
16434
16435 if (stat (l1_filename, &l1_stat) == -1)
16436 {
16437 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16438
16439 return (-1);
16440 }
16441
16442 if (S_ISREG (l1_stat.st_mode))
16443 {
16444 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16445
16446 dictcnt++;
16447
16448 dictfiles[dictcnt - 1] = strdup (l1_filename);
16449 }
16450 }
16451 }
16452
16453 local_free (dictionary_files);
16454 }
16455 }
16456
16457 if (dictcnt < 1)
16458 {
16459 log_error ("ERROR: No usable dictionary file found.");
16460
16461 return (-1);
16462 }
16463
16464 if (increment)
16465 {
16466 maskcnt = 0;
16467
16468 uint mask_min = increment_min; // we can't reject smaller masks here
16469 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16470
16471 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16472 {
16473 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16474
16475 if (cur_mask == NULL) break;
16476
16477 masks[maskcnt] = cur_mask;
16478
16479 maskcnt++;
16480
16481 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16482 }
16483 }
16484 }
16485 else if (attack_mode == ATTACK_MODE_HYBRID2)
16486 {
16487 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16488
16489 // display
16490
16491 char *mask = myargv[optind + 1 + 0];
16492
16493 maskcnt = 0;
16494
16495 masks = (char **) mymalloc (1 * sizeof (char *));
16496
16497 // mod
16498
16499 struct stat file_stat;
16500
16501 if (stat (mask, &file_stat) == -1)
16502 {
16503 maskcnt = 1;
16504
16505 masks[maskcnt - 1] = mystrdup (mask);
16506 }
16507 else
16508 {
16509 uint is_file = S_ISREG (file_stat.st_mode);
16510
16511 if (is_file == 1)
16512 {
16513 FILE *mask_fp;
16514
16515 if ((mask_fp = fopen (mask, "r")) == NULL)
16516 {
16517 log_error ("ERROR: %s: %s", mask, strerror (errno));
16518
16519 return (-1);
16520 }
16521
16522 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16523
16524 uint masks_avail = 1;
16525
16526 while (!feof (mask_fp))
16527 {
16528 memset (line_buf, 0, HCBUFSIZ);
16529
16530 int line_len = fgetl (mask_fp, line_buf);
16531
16532 if (line_len == 0) continue;
16533
16534 if (line_buf[0] == '#') continue;
16535
16536 if (masks_avail == maskcnt)
16537 {
16538 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16539
16540 masks_avail += INCR_MASKS;
16541 }
16542
16543 masks[maskcnt] = mystrdup (line_buf);
16544
16545 maskcnt++;
16546 }
16547
16548 myfree (line_buf);
16549
16550 fclose (mask_fp);
16551
16552 mask_from_file = 1;
16553 }
16554 else
16555 {
16556 maskcnt = 1;
16557
16558 masks[maskcnt - 1] = mystrdup (mask);
16559 }
16560 }
16561
16562 // base
16563
16564 int wls_left = myargc - (optind + 2);
16565
16566 for (int i = 0; i < wls_left; i++)
16567 {
16568 char *filename = myargv[optind + 2 + i];
16569
16570 struct stat file_stat;
16571
16572 if (stat (filename, &file_stat) == -1)
16573 {
16574 log_error ("ERROR: %s: %s", filename, strerror (errno));
16575
16576 return (-1);
16577 }
16578
16579 uint is_dir = S_ISDIR (file_stat.st_mode);
16580
16581 if (is_dir == 0)
16582 {
16583 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16584
16585 dictcnt++;
16586
16587 dictfiles[dictcnt - 1] = filename;
16588 }
16589 else
16590 {
16591 // do not allow --keyspace w/ a directory
16592
16593 if (keyspace == 1)
16594 {
16595 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16596
16597 return (-1);
16598 }
16599
16600 char **dictionary_files = NULL;
16601
16602 dictionary_files = scan_directory (filename);
16603
16604 if (dictionary_files != NULL)
16605 {
16606 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16607
16608 for (int d = 0; dictionary_files[d] != NULL; d++)
16609 {
16610 char *l1_filename = dictionary_files[d];
16611
16612 struct stat l1_stat;
16613
16614 if (stat (l1_filename, &l1_stat) == -1)
16615 {
16616 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16617
16618 return (-1);
16619 }
16620
16621 if (S_ISREG (l1_stat.st_mode))
16622 {
16623 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16624
16625 dictcnt++;
16626
16627 dictfiles[dictcnt - 1] = strdup (l1_filename);
16628 }
16629 }
16630 }
16631
16632 local_free (dictionary_files);
16633 }
16634 }
16635
16636 if (dictcnt < 1)
16637 {
16638 log_error ("ERROR: No usable dictionary file found.");
16639
16640 return (-1);
16641 }
16642
16643 if (increment)
16644 {
16645 maskcnt = 0;
16646
16647 uint mask_min = increment_min; // we can't reject smaller masks here
16648 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16649
16650 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16651 {
16652 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16653
16654 if (cur_mask == NULL) break;
16655
16656 masks[maskcnt] = cur_mask;
16657
16658 maskcnt++;
16659
16660 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16661 }
16662 }
16663 }
16664
16665 data.pw_min = pw_min;
16666 data.pw_max = pw_max;
16667
16668 /**
16669 * weak hash check
16670 */
16671
16672 if (weak_hash_threshold >= salts_cnt)
16673 {
16674 hc_device_param_t *device_param = NULL;
16675
16676 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16677 {
16678 device_param = &data.devices_param[device_id];
16679
16680 if (device_param->skipped) continue;
16681
16682 break;
16683 }
16684
16685 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16686
16687 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16688 {
16689 weak_hash_check (device_param, salt_pos);
16690 }
16691
16692 // Display hack, guarantee that there is at least one \r before real start
16693
16694 //if (data.quiet == 0) log_info ("");
16695 }
16696
16697 /**
16698 * status and monitor threads
16699 */
16700
16701 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16702
16703 hc_thread_t i_thread = 0;
16704
16705 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16706 {
16707 hc_thread_create (i_thread, thread_keypress, &benchmark);
16708 }
16709
16710 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16711
16712 uint ni_threads_cnt = 0;
16713
16714 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16715
16716 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16717
16718 ni_threads_cnt++;
16719
16720 /**
16721 * Outfile remove
16722 */
16723
16724 if (keyspace == 0)
16725 {
16726 if (outfile_check_timer != 0)
16727 {
16728 if (data.outfile_check_directory != NULL)
16729 {
16730 if ((hash_mode != 5200) &&
16731 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16732 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16733 (hash_mode != 9000))
16734 {
16735 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16736
16737 ni_threads_cnt++;
16738 }
16739 else
16740 {
16741 outfile_check_timer = 0;
16742 }
16743 }
16744 else
16745 {
16746 outfile_check_timer = 0;
16747 }
16748 }
16749 }
16750
16751 /**
16752 * Inform the user if we got some hashes remove because of the pot file remove feature
16753 */
16754
16755 if (data.quiet == 0)
16756 {
16757 if (potfile_remove_cracks > 0)
16758 {
16759 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16760 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16761 }
16762 }
16763
16764 data.outfile_check_timer = outfile_check_timer;
16765
16766 /**
16767 * main loop
16768 */
16769
16770 char **induction_dictionaries = NULL;
16771
16772 int induction_dictionaries_cnt = 0;
16773
16774 hcstat_table_t *root_table_buf = NULL;
16775 hcstat_table_t *markov_table_buf = NULL;
16776
16777 uint initial_restore_done = 0;
16778
16779 data.maskcnt = maskcnt;
16780
16781 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16782 {
16783 if (data.devices_status == STATUS_CRACKED) break;
16784
16785 data.devices_status = STATUS_INIT;
16786
16787 if (maskpos > rd->maskpos)
16788 {
16789 rd->dictpos = 0;
16790 }
16791
16792 rd->maskpos = maskpos;
16793 data.maskpos = maskpos;
16794
16795 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16796 {
16797 char *mask = masks[maskpos];
16798
16799 if (mask_from_file == 1)
16800 {
16801 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16802
16803 char *str_ptr;
16804 uint str_pos;
16805
16806 uint mask_offset = 0;
16807
16808 uint separator_cnt;
16809
16810 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16811 {
16812 str_ptr = strstr (mask + mask_offset, ",");
16813
16814 if (str_ptr == NULL) break;
16815
16816 str_pos = str_ptr - mask;
16817
16818 // escaped separator, i.e. "\,"
16819
16820 if (str_pos > 0)
16821 {
16822 if (mask[str_pos - 1] == '\\')
16823 {
16824 separator_cnt --;
16825
16826 mask_offset = str_pos + 1;
16827
16828 continue;
16829 }
16830 }
16831
16832 // reset the offset
16833
16834 mask_offset = 0;
16835
16836 mask[str_pos] = '\0';
16837
16838 switch (separator_cnt)
16839 {
16840 case 0:
16841 mp_reset_usr (mp_usr, 0);
16842
16843 custom_charset_1 = mask;
16844 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16845 break;
16846
16847 case 1:
16848 mp_reset_usr (mp_usr, 1);
16849
16850 custom_charset_2 = mask;
16851 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16852 break;
16853
16854 case 2:
16855 mp_reset_usr (mp_usr, 2);
16856
16857 custom_charset_3 = mask;
16858 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16859 break;
16860
16861 case 3:
16862 mp_reset_usr (mp_usr, 3);
16863
16864 custom_charset_4 = mask;
16865 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16866 break;
16867 }
16868
16869 mask = mask + str_pos + 1;
16870 }
16871 }
16872
16873 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16874 {
16875 if (maskpos > 0)
16876 {
16877 local_free (css_buf);
16878 local_free (data.root_css_buf);
16879 local_free (data.markov_css_buf);
16880
16881 local_free (masks[maskpos - 1]);
16882 }
16883
16884 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16885
16886 data.mask = mask;
16887 data.css_cnt = css_cnt;
16888 data.css_buf = css_buf;
16889
16890 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16891
16892 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16893
16894 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16895 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16896
16897 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16898
16899 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16900
16901 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16902 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16903
16904 data.root_css_buf = root_css_buf;
16905 data.markov_css_buf = markov_css_buf;
16906
16907 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16908
16909 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16910
16911 local_free (root_table_buf);
16912 local_free (markov_table_buf);
16913
16914 // args
16915
16916 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16917 {
16918 hc_device_param_t *device_param = &data.devices_param[device_id];
16919
16920 if (device_param->skipped) continue;
16921
16922 device_param->kernel_params_mp[0] = &device_param->d_combs;
16923 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16924 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16925
16926 device_param->kernel_params_mp_buf64[3] = 0;
16927 device_param->kernel_params_mp_buf32[4] = css_cnt;
16928 device_param->kernel_params_mp_buf32[5] = 0;
16929 device_param->kernel_params_mp_buf32[6] = 0;
16930 device_param->kernel_params_mp_buf32[7] = 0;
16931
16932 if (attack_mode == ATTACK_MODE_HYBRID1)
16933 {
16934 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16935 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16936 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16937 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16938 }
16939 else if (attack_mode == ATTACK_MODE_HYBRID2)
16940 {
16941 device_param->kernel_params_mp_buf32[5] = 0;
16942 device_param->kernel_params_mp_buf32[6] = 0;
16943 device_param->kernel_params_mp_buf32[7] = 0;
16944 }
16945
16946 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]);
16947 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]);
16948 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]);
16949
16950 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);
16951 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);
16952 }
16953 }
16954 else if (attack_mode == ATTACK_MODE_BF)
16955 {
16956 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16957
16958 if (increment)
16959 {
16960 for (uint i = 0; i < dictcnt; i++)
16961 {
16962 local_free (dictfiles[i]);
16963 }
16964
16965 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16966 {
16967 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16968
16969 if (l1_filename == NULL) break;
16970
16971 dictcnt++;
16972
16973 dictfiles[dictcnt - 1] = l1_filename;
16974 }
16975 }
16976 else
16977 {
16978 dictcnt++;
16979
16980 dictfiles[dictcnt - 1] = mask;
16981 }
16982
16983 if (dictcnt == 0)
16984 {
16985 log_error ("ERROR: Mask is too small");
16986
16987 return (-1);
16988 }
16989 }
16990 }
16991
16992 free (induction_dictionaries);
16993
16994 // induction_dictionaries_cnt = 0; // implied
16995
16996 if (attack_mode != ATTACK_MODE_BF)
16997 {
16998 if (keyspace == 0)
16999 {
17000 induction_dictionaries = scan_directory (induction_directory);
17001
17002 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17003 }
17004 }
17005
17006 if (induction_dictionaries_cnt)
17007 {
17008 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17009 }
17010
17011 /**
17012 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17013 */
17014 if (keyspace == 1)
17015 {
17016 if ((maskcnt > 1) || (dictcnt > 1))
17017 {
17018 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17019
17020 return (-1);
17021 }
17022 }
17023
17024 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17025 {
17026 char *subid = logfile_generate_subid ();
17027
17028 data.subid = subid;
17029
17030 logfile_sub_msg ("START");
17031
17032 data.devices_status = STATUS_INIT;
17033
17034 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17035 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17036 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17037
17038 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17039
17040 data.cpt_pos = 0;
17041
17042 data.cpt_start = time (NULL);
17043
17044 data.cpt_total = 0;
17045
17046 if (data.restore == 0)
17047 {
17048 rd->words_cur = skip;
17049
17050 skip = 0;
17051
17052 data.skip = 0;
17053 }
17054
17055 data.ms_paused = 0;
17056
17057 data.words_cur = rd->words_cur;
17058
17059 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17060 {
17061 hc_device_param_t *device_param = &data.devices_param[device_id];
17062
17063 if (device_param->skipped) continue;
17064
17065 device_param->speed_pos = 0;
17066
17067 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17068 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17069
17070 device_param->exec_pos = 0;
17071
17072 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17073
17074 device_param->kernel_power = device_param->kernel_power_user;
17075
17076 device_param->outerloop_pos = 0;
17077 device_param->outerloop_left = 0;
17078 device_param->innerloop_pos = 0;
17079 device_param->innerloop_left = 0;
17080
17081 // some more resets:
17082
17083 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17084
17085 device_param->pws_cnt = 0;
17086
17087 device_param->words_off = 0;
17088 device_param->words_done = 0;
17089 }
17090
17091 data.kernel_power_div = 0;
17092
17093 // figure out some workload
17094
17095 if (attack_mode == ATTACK_MODE_STRAIGHT)
17096 {
17097 if (data.wordlist_mode == WL_MODE_FILE)
17098 {
17099 char *dictfile = NULL;
17100
17101 if (induction_dictionaries_cnt)
17102 {
17103 dictfile = induction_dictionaries[0];
17104 }
17105 else
17106 {
17107 dictfile = dictfiles[dictpos];
17108 }
17109
17110 data.dictfile = dictfile;
17111
17112 logfile_sub_string (dictfile);
17113
17114 for (uint i = 0; i < rp_files_cnt; i++)
17115 {
17116 logfile_sub_var_string ("rulefile", rp_files[i]);
17117 }
17118
17119 FILE *fd2 = fopen (dictfile, "rb");
17120
17121 if (fd2 == NULL)
17122 {
17123 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17124
17125 return (-1);
17126 }
17127
17128 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17129
17130 fclose (fd2);
17131
17132 if (data.words_cnt == 0)
17133 {
17134 if (data.devices_status == STATUS_CRACKED) break;
17135 if (data.devices_status == STATUS_ABORTED) break;
17136
17137 dictpos++;
17138
17139 continue;
17140 }
17141 }
17142 }
17143 else if (attack_mode == ATTACK_MODE_COMBI)
17144 {
17145 char *dictfile = data.dictfile;
17146 char *dictfile2 = data.dictfile2;
17147
17148 logfile_sub_string (dictfile);
17149 logfile_sub_string (dictfile2);
17150
17151 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17152 {
17153 FILE *fd2 = fopen (dictfile, "rb");
17154
17155 if (fd2 == NULL)
17156 {
17157 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17158
17159 return (-1);
17160 }
17161
17162 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17163
17164 fclose (fd2);
17165 }
17166 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17167 {
17168 FILE *fd2 = fopen (dictfile2, "rb");
17169
17170 if (fd2 == NULL)
17171 {
17172 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17173
17174 return (-1);
17175 }
17176
17177 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17178
17179 fclose (fd2);
17180 }
17181
17182 if (data.words_cnt == 0)
17183 {
17184 if (data.devices_status == STATUS_CRACKED) break;
17185 if (data.devices_status == STATUS_ABORTED) break;
17186
17187 dictpos++;
17188
17189 continue;
17190 }
17191 }
17192 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17193 {
17194 char *dictfile = NULL;
17195
17196 if (induction_dictionaries_cnt)
17197 {
17198 dictfile = induction_dictionaries[0];
17199 }
17200 else
17201 {
17202 dictfile = dictfiles[dictpos];
17203 }
17204
17205 data.dictfile = dictfile;
17206
17207 char *mask = data.mask;
17208
17209 logfile_sub_string (dictfile);
17210 logfile_sub_string (mask);
17211
17212 FILE *fd2 = fopen (dictfile, "rb");
17213
17214 if (fd2 == NULL)
17215 {
17216 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17217
17218 return (-1);
17219 }
17220
17221 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17222
17223 fclose (fd2);
17224
17225 if (data.words_cnt == 0)
17226 {
17227 if (data.devices_status == STATUS_CRACKED) break;
17228 if (data.devices_status == STATUS_ABORTED) break;
17229
17230 dictpos++;
17231
17232 continue;
17233 }
17234 }
17235 else if (attack_mode == ATTACK_MODE_BF)
17236 {
17237 local_free (css_buf);
17238 local_free (data.root_css_buf);
17239 local_free (data.markov_css_buf);
17240
17241 char *mask = dictfiles[dictpos];
17242
17243 logfile_sub_string (mask);
17244
17245 // base
17246
17247 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17248
17249 if (opts_type & OPTS_TYPE_PT_UNICODE)
17250 {
17251 uint css_cnt_unicode = css_cnt * 2;
17252
17253 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17254
17255 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17256 {
17257 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17258
17259 css_buf_unicode[j + 1].cs_buf[0] = 0;
17260 css_buf_unicode[j + 1].cs_len = 1;
17261 }
17262
17263 free (css_buf);
17264
17265 css_buf = css_buf_unicode;
17266 css_cnt = css_cnt_unicode;
17267 }
17268
17269 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17270
17271 uint mask_min = pw_min;
17272 uint mask_max = pw_max;
17273
17274 if (opts_type & OPTS_TYPE_PT_UNICODE)
17275 {
17276 mask_min *= 2;
17277 mask_max *= 2;
17278 }
17279
17280 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17281 {
17282 if (css_cnt < mask_min)
17283 {
17284 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17285 }
17286
17287 if (css_cnt > mask_max)
17288 {
17289 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17290 }
17291
17292 // skip to next mask
17293
17294 dictpos++;
17295
17296 rd->dictpos = dictpos;
17297
17298 logfile_sub_msg ("STOP");
17299
17300 continue;
17301 }
17302
17303 uint save_css_cnt = css_cnt;
17304
17305 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17306 {
17307 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17308 {
17309 uint salt_len = (uint) data.salts_buf[0].salt_len;
17310 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17311
17312 uint css_cnt_salt = css_cnt + salt_len;
17313
17314 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17315
17316 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17317
17318 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17319 {
17320 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17321 css_buf_salt[j].cs_len = 1;
17322 }
17323
17324 free (css_buf);
17325
17326 css_buf = css_buf_salt;
17327 css_cnt = css_cnt_salt;
17328 }
17329 }
17330
17331 data.mask = mask;
17332 data.css_cnt = css_cnt;
17333 data.css_buf = css_buf;
17334
17335 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17336
17337 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17338
17339 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17340
17341 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17342 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17343
17344 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17345
17346 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17347
17348 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17349 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17350
17351 data.root_css_buf = root_css_buf;
17352 data.markov_css_buf = markov_css_buf;
17353
17354 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17355
17356 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17357
17358 local_free (root_table_buf);
17359 local_free (markov_table_buf);
17360
17361 // copy + args
17362
17363 uint css_cnt_l = css_cnt;
17364 uint css_cnt_r;
17365
17366 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17367 {
17368 if (save_css_cnt < 6)
17369 {
17370 css_cnt_r = 1;
17371 }
17372 else if (save_css_cnt == 6)
17373 {
17374 css_cnt_r = 2;
17375 }
17376 else
17377 {
17378 if (opts_type & OPTS_TYPE_PT_UNICODE)
17379 {
17380 if (save_css_cnt == 8 || save_css_cnt == 10)
17381 {
17382 css_cnt_r = 2;
17383 }
17384 else
17385 {
17386 css_cnt_r = 4;
17387 }
17388 }
17389 else
17390 {
17391 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17392 {
17393 css_cnt_r = 3;
17394 }
17395 else
17396 {
17397 css_cnt_r = 4;
17398 }
17399 }
17400 }
17401 }
17402 else
17403 {
17404 css_cnt_r = 1;
17405
17406 /* unfinished code?
17407 int sum = css_buf[css_cnt_r - 1].cs_len;
17408
17409 for (uint i = 1; i < 4 && i < css_cnt; i++)
17410 {
17411 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17412
17413 css_cnt_r++;
17414
17415 sum *= css_buf[css_cnt_r - 1].cs_len;
17416 }
17417 */
17418 }
17419
17420 css_cnt_l -= css_cnt_r;
17421
17422 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17423
17424 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17425 {
17426 hc_device_param_t *device_param = &data.devices_param[device_id];
17427
17428 if (device_param->skipped) continue;
17429
17430 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17431 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17432 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17433
17434 device_param->kernel_params_mp_l_buf64[3] = 0;
17435 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17436 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17437 device_param->kernel_params_mp_l_buf32[6] = 0;
17438 device_param->kernel_params_mp_l_buf32[7] = 0;
17439 device_param->kernel_params_mp_l_buf32[8] = 0;
17440
17441 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17442 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17443 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17444 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17445
17446 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17447 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17448 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17449
17450 device_param->kernel_params_mp_r_buf64[3] = 0;
17451 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17452 device_param->kernel_params_mp_r_buf32[5] = 0;
17453 device_param->kernel_params_mp_r_buf32[6] = 0;
17454 device_param->kernel_params_mp_r_buf32[7] = 0;
17455
17456 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]);
17457 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]);
17458 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]);
17459
17460 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]);
17461 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]);
17462 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]);
17463
17464 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);
17465 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);
17466 }
17467 }
17468
17469 u64 words_base = data.words_cnt;
17470
17471 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17472 {
17473 if (data.kernel_rules_cnt)
17474 {
17475 words_base /= data.kernel_rules_cnt;
17476 }
17477 }
17478 else if (data.attack_kern == ATTACK_KERN_COMBI)
17479 {
17480 if (data.combs_cnt)
17481 {
17482 words_base /= data.combs_cnt;
17483 }
17484 }
17485 else if (data.attack_kern == ATTACK_KERN_BF)
17486 {
17487 if (data.bfs_cnt)
17488 {
17489 words_base /= data.bfs_cnt;
17490 }
17491 }
17492
17493 data.words_base = words_base;
17494
17495 if (keyspace == 1)
17496 {
17497 log_info ("%llu", (unsigned long long int) words_base);
17498
17499 return (0);
17500 }
17501
17502 if (data.words_cur > data.words_base)
17503 {
17504 log_error ("ERROR: restore value greater keyspace");
17505
17506 return (-1);
17507 }
17508
17509 if (data.words_cur)
17510 {
17511 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17512 {
17513 for (uint i = 0; i < data.salts_cnt; i++)
17514 {
17515 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17516 }
17517 }
17518 else if (data.attack_kern == ATTACK_KERN_COMBI)
17519 {
17520 for (uint i = 0; i < data.salts_cnt; i++)
17521 {
17522 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17523 }
17524 }
17525 else if (data.attack_kern == ATTACK_KERN_BF)
17526 {
17527 for (uint i = 0; i < data.salts_cnt; i++)
17528 {
17529 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17530 }
17531 }
17532 }
17533
17534 /*
17535 * Inform user about possible slow speeds
17536 */
17537
17538 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17539 {
17540 if (data.words_base < kernel_power_all)
17541 {
17542 if (quiet == 0)
17543 {
17544 log_info ("ATTENTION!");
17545 log_info (" The wordlist or mask you are using is too small.");
17546 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17547 log_info (" The cracking speed will drop.");
17548 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17549 log_info ("");
17550 }
17551 }
17552 }
17553
17554 /*
17555 * Update loopback file
17556 */
17557
17558 if (loopback == 1)
17559 {
17560 time_t now;
17561
17562 time (&now);
17563
17564 uint random_num = get_random_num (0, 9999);
17565
17566 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17567
17568 data.loopback_file = loopback_file;
17569 }
17570
17571 /*
17572 * Update dictionary statistic
17573 */
17574
17575 if (keyspace == 0)
17576 {
17577 dictstat_fp = fopen (dictstat, "wb");
17578
17579 if (dictstat_fp)
17580 {
17581 lock_file (dictstat_fp);
17582
17583 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17584
17585 fclose (dictstat_fp);
17586 }
17587 }
17588
17589 data.devices_status = STATUS_RUNNING;
17590
17591 if (initial_restore_done == 0)
17592 {
17593 if (data.restore_disable == 0) cycle_restore ();
17594
17595 initial_restore_done = 1;
17596 }
17597
17598 hc_timer_set (&data.timer_running);
17599
17600 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17601 {
17602 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17603 {
17604 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17605 if (quiet == 0) fflush (stdout);
17606 }
17607 }
17608 else if (wordlist_mode == WL_MODE_STDIN)
17609 {
17610 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17611 if (data.quiet == 0) log_info ("");
17612 }
17613
17614 time_t runtime_start;
17615
17616 time (&runtime_start);
17617
17618 data.runtime_start = runtime_start;
17619
17620 /**
17621 * create cracker threads
17622 */
17623
17624 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17625
17626 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17627 {
17628 hc_device_param_t *device_param = &devices_param[device_id];
17629
17630 if (wordlist_mode == WL_MODE_STDIN)
17631 {
17632 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17633 }
17634 else
17635 {
17636 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17637 }
17638 }
17639
17640 // wait for crack threads to exit
17641
17642 hc_thread_wait (data.devices_cnt, c_threads);
17643
17644 local_free (c_threads);
17645
17646 data.restore = 0;
17647
17648 // finalize task
17649
17650 logfile_sub_var_uint ("status-after-work", data.devices_status);
17651
17652 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17653
17654 if (data.devices_status == STATUS_CRACKED) break;
17655 if (data.devices_status == STATUS_ABORTED) break;
17656
17657 if (data.devices_status == STATUS_BYPASS)
17658 {
17659 data.devices_status = STATUS_RUNNING;
17660 }
17661
17662 if (induction_dictionaries_cnt)
17663 {
17664 unlink (induction_dictionaries[0]);
17665 }
17666
17667 free (induction_dictionaries);
17668
17669 if (attack_mode != ATTACK_MODE_BF)
17670 {
17671 induction_dictionaries = scan_directory (induction_directory);
17672
17673 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17674 }
17675
17676 if (benchmark == 0)
17677 {
17678 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17679 {
17680 if (quiet == 0) clear_prompt ();
17681
17682 if (quiet == 0) log_info ("");
17683
17684 if (status == 1)
17685 {
17686 status_display ();
17687 }
17688 else
17689 {
17690 if (quiet == 0) status_display ();
17691 }
17692
17693 if (quiet == 0) log_info ("");
17694 }
17695 }
17696
17697 if (attack_mode == ATTACK_MODE_BF)
17698 {
17699 dictpos++;
17700
17701 rd->dictpos = dictpos;
17702 }
17703 else
17704 {
17705 if (induction_dictionaries_cnt)
17706 {
17707 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17708 }
17709 else
17710 {
17711 dictpos++;
17712
17713 rd->dictpos = dictpos;
17714 }
17715 }
17716
17717 time_t runtime_stop;
17718
17719 time (&runtime_stop);
17720
17721 data.runtime_stop = runtime_stop;
17722
17723 logfile_sub_uint (runtime_start);
17724 logfile_sub_uint (runtime_stop);
17725
17726 logfile_sub_msg ("STOP");
17727
17728 global_free (subid);
17729 }
17730
17731 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17732
17733 if (data.devices_status == STATUS_CRACKED) break;
17734 if (data.devices_status == STATUS_ABORTED) break;
17735 if (data.devices_status == STATUS_QUIT) break;
17736
17737 if (data.devices_status == STATUS_BYPASS)
17738 {
17739 data.devices_status = STATUS_RUNNING;
17740 }
17741 }
17742
17743 // 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
17744
17745 if (attack_mode == ATTACK_MODE_STRAIGHT)
17746 {
17747 if (data.wordlist_mode == WL_MODE_FILE)
17748 {
17749 if (data.dictfile == NULL)
17750 {
17751 if (dictfiles != NULL)
17752 {
17753 data.dictfile = dictfiles[0];
17754
17755 hc_timer_set (&data.timer_running);
17756 }
17757 }
17758 }
17759 }
17760 // NOTE: combi is okay because it is already set beforehand
17761 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17762 {
17763 if (data.dictfile == NULL)
17764 {
17765 if (dictfiles != NULL)
17766 {
17767 hc_timer_set (&data.timer_running);
17768
17769 data.dictfile = dictfiles[0];
17770 }
17771 }
17772 }
17773 else if (attack_mode == ATTACK_MODE_BF)
17774 {
17775 if (data.mask == NULL)
17776 {
17777 hc_timer_set (&data.timer_running);
17778
17779 data.mask = masks[0];
17780 }
17781 }
17782
17783 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17784 {
17785 data.devices_status = STATUS_EXHAUSTED;
17786 }
17787
17788 // if cracked / aborted remove last induction dictionary
17789
17790 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17791 {
17792 struct stat induct_stat;
17793
17794 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17795 {
17796 unlink (induction_dictionaries[file_pos]);
17797 }
17798 }
17799
17800 // wait for non-interactive threads
17801
17802 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17803 {
17804 hc_thread_wait (1, &ni_threads[thread_idx]);
17805 }
17806
17807 local_free (ni_threads);
17808
17809 // wait for interactive threads
17810
17811 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17812 {
17813 hc_thread_wait (1, &i_thread);
17814 }
17815
17816 // we dont need restore file anymore
17817 if (data.restore_disable == 0)
17818 {
17819 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17820 {
17821 unlink (eff_restore_file);
17822 unlink (new_restore_file);
17823 }
17824 else
17825 {
17826 cycle_restore ();
17827 }
17828 }
17829
17830 // finally save left hashes
17831
17832 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17833 {
17834 save_hash ();
17835 }
17836
17837 /**
17838 * Clean up
17839 */
17840
17841 if (benchmark == 1)
17842 {
17843 status_benchmark ();
17844
17845 if (machine_readable == 0)
17846 {
17847 log_info ("");
17848 }
17849 }
17850 else
17851 {
17852 if (quiet == 0) clear_prompt ();
17853
17854 if (quiet == 0) log_info ("");
17855
17856 if (status == 1)
17857 {
17858 status_display ();
17859 }
17860 else
17861 {
17862 if (quiet == 0) status_display ();
17863 }
17864
17865 if (quiet == 0) log_info ("");
17866 }
17867
17868 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17869 {
17870 hc_device_param_t *device_param = &data.devices_param[device_id];
17871
17872 if (device_param->skipped) continue;
17873
17874 local_free (device_param->combs_buf);
17875
17876 local_free (device_param->hooks_buf);
17877
17878 local_free (device_param->device_name);
17879
17880 local_free (device_param->device_name_chksum);
17881
17882 local_free (device_param->device_version);
17883
17884 local_free (device_param->driver_version);
17885
17886 if (device_param->pws_buf) myfree (device_param->pws_buf);
17887 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17888 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17889 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17890 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17891 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17892 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17893 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17894 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17895 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17896 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17897 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17898 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17899 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17900 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17901 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17902 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17903 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17904 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17905 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17906 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17907 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17908 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17909 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17910 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17911 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17912 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17913 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17914 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17915
17916 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17917 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17918 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17919 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17920 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17921 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17922 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17923 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17924 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17925 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17926 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17927
17928 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17929 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17930 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17931
17932 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17933 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17934 }
17935
17936 // reset default fan speed
17937
17938 #ifdef HAVE_HWMON
17939 if (gpu_temp_disable == 0)
17940 {
17941 #ifdef HAVE_ADL
17942 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17943 {
17944 hc_thread_mutex_lock (mux_adl);
17945
17946 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17947 {
17948 hc_device_param_t *device_param = &data.devices_param[device_id];
17949
17950 if (device_param->skipped) continue;
17951
17952 if (data.hm_device[device_id].fan_supported == 1)
17953 {
17954 int fanspeed = temp_retain_fanspeed_value[device_id];
17955
17956 if (fanspeed == -1) continue;
17957
17958 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17959
17960 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17961 }
17962 }
17963
17964 hc_thread_mutex_unlock (mux_adl);
17965 }
17966 #endif // HAVE_ADL
17967 }
17968
17969 #ifdef HAVE_ADL
17970 // reset power tuning
17971
17972 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17973 {
17974 hc_thread_mutex_lock (mux_adl);
17975
17976 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17977 {
17978 hc_device_param_t *device_param = &data.devices_param[device_id];
17979
17980 if (device_param->skipped) continue;
17981
17982 if (data.hm_device[device_id].od_version == 6)
17983 {
17984 // check powertune capabilities first, if not available then skip device
17985
17986 int powertune_supported = 0;
17987
17988 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17989 {
17990 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17991
17992 return (-1);
17993 }
17994
17995 if (powertune_supported != 0)
17996 {
17997 // powercontrol settings
17998
17999 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)
18000 {
18001 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18002
18003 return (-1);
18004 }
18005
18006 // clocks
18007
18008 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18009
18010 performance_state->iNumberOfPerformanceLevels = 2;
18011
18012 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18013 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18014 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18015 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18016
18017 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)
18018 {
18019 log_info ("ERROR: Failed to restore ADL performance state");
18020
18021 return (-1);
18022 }
18023
18024 local_free (performance_state);
18025 }
18026 }
18027 }
18028
18029 hc_thread_mutex_unlock (mux_adl);
18030 }
18031 #endif // HAVE_ADL
18032
18033 if (gpu_temp_disable == 0)
18034 {
18035 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
18036 if (data.hm_nv)
18037 {
18038 #if defined(LINUX) && defined(HAVE_NVML)
18039
18040 hm_NVML_nvmlShutdown (data.hm_nv);
18041
18042 nvml_close (data.hm_nv);
18043
18044 #elif defined(WIN) && (HAVE_NVAPI)
18045
18046 hm_NvAPI_Unload (data.hm_nv);
18047
18048 nvapi_close (data.hm_nv);
18049
18050 #endif
18051
18052 data.hm_nv = NULL;
18053 }
18054 #endif
18055
18056 #ifdef HAVE_ADL
18057 if (data.hm_amd)
18058 {
18059 hm_ADL_Main_Control_Destroy (data.hm_amd);
18060
18061 adl_close (data.hm_amd);
18062 data.hm_amd = NULL;
18063 }
18064 #endif
18065 }
18066 #endif // HAVE_HWMON
18067
18068 // free memory
18069
18070 local_free (masks);
18071
18072 local_free (dictstat_base);
18073
18074 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18075 {
18076 pot_t *pot_ptr = &pot[pot_pos];
18077
18078 hash_t *hash = &pot_ptr->hash;
18079
18080 local_free (hash->digest);
18081
18082 if (isSalted)
18083 {
18084 local_free (hash->salt);
18085 }
18086 }
18087
18088 local_free (pot);
18089
18090 local_free (all_kernel_rules_cnt);
18091 local_free (all_kernel_rules_buf);
18092
18093 local_free (wl_data->buf);
18094 local_free (wl_data);
18095
18096 local_free (bitmap_s1_a);
18097 local_free (bitmap_s1_b);
18098 local_free (bitmap_s1_c);
18099 local_free (bitmap_s1_d);
18100 local_free (bitmap_s2_a);
18101 local_free (bitmap_s2_b);
18102 local_free (bitmap_s2_c);
18103 local_free (bitmap_s2_d);
18104
18105 #ifdef HAVE_HWMON
18106 local_free (temp_retain_fanspeed_value);
18107 #ifdef HAVE_ADL
18108 local_free (od_clock_mem_status);
18109 local_free (od_power_control_status);
18110 #endif // ADL
18111 #endif
18112
18113 global_free (devices_param);
18114
18115 global_free (kernel_rules_buf);
18116
18117 global_free (root_css_buf);
18118 global_free (markov_css_buf);
18119
18120 global_free (digests_buf);
18121 global_free (digests_shown);
18122 global_free (digests_shown_tmp);
18123
18124 global_free (salts_buf);
18125 global_free (salts_shown);
18126
18127 global_free (esalts_buf);
18128
18129 global_free (words_progress_done);
18130 global_free (words_progress_rejected);
18131 global_free (words_progress_restored);
18132
18133 if (pot_fp) fclose (pot_fp);
18134
18135 if (data.devices_status == STATUS_QUIT) break;
18136 }
18137
18138 // destroy others mutex
18139
18140 hc_thread_mutex_delete (mux_dispatcher);
18141 hc_thread_mutex_delete (mux_counter);
18142 hc_thread_mutex_delete (mux_display);
18143 hc_thread_mutex_delete (mux_adl);
18144
18145 // free memory
18146
18147 local_free (eff_restore_file);
18148 local_free (new_restore_file);
18149
18150 local_free (rd);
18151
18152 // tuning db
18153
18154 tuning_db_destroy (tuning_db);
18155
18156 // loopback
18157
18158 local_free (loopback_file);
18159
18160 if (loopback == 1) unlink (loopback_file);
18161
18162 // induction directory
18163
18164 if (induction_dir == NULL)
18165 {
18166 if (attack_mode != ATTACK_MODE_BF)
18167 {
18168 if (rmdir (induction_directory) == -1)
18169 {
18170 if (errno == ENOENT)
18171 {
18172 // good, we can ignore
18173 }
18174 else if (errno == ENOTEMPTY)
18175 {
18176 // good, we can ignore
18177 }
18178 else
18179 {
18180 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18181
18182 return (-1);
18183 }
18184 }
18185
18186 local_free (induction_directory);
18187 }
18188 }
18189
18190 // outfile-check directory
18191
18192 if (outfile_check_dir == NULL)
18193 {
18194 if (rmdir (outfile_check_directory) == -1)
18195 {
18196 if (errno == ENOENT)
18197 {
18198 // good, we can ignore
18199 }
18200 else if (errno == ENOTEMPTY)
18201 {
18202 // good, we can ignore
18203 }
18204 else
18205 {
18206 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18207
18208 return (-1);
18209 }
18210 }
18211
18212 local_free (outfile_check_directory);
18213 }
18214
18215 time_t proc_stop;
18216
18217 time (&proc_stop);
18218
18219 logfile_top_uint (proc_start);
18220 logfile_top_uint (proc_stop);
18221
18222 logfile_top_msg ("STOP");
18223
18224 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18225 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18226
18227 if (data.ocl) ocl_close (data.ocl);
18228
18229 if (data.devices_status == STATUS_ABORTED) return 2;
18230 if (data.devices_status == STATUS_QUIT) return 2;
18231 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18232 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18233 if (data.devices_status == STATUS_CRACKED) return 0;
18234
18235 return -1;
18236 }
Hashcat additions to support pwdhash