projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
enable path resolution on FreeBSD
[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 #if defined(DARWIN) || defined(__FreeBSD__)
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 STDOUT_FLAG 0
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define MACHINE_READABLE 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define NVIDIA_SPIN_DAMP 100
79 #define GPU_TEMP_DISABLE 0
80 #define GPU_TEMP_ABORT 90
81 #define GPU_TEMP_RETAIN 75
82 #define WORKLOAD_PROFILE 2
83 #define KERNEL_ACCEL 0
84 #define KERNEL_LOOPS 0
85 #define KERNEL_RULES 1024
86 #define KERNEL_COMBS 1024
87 #define KERNEL_BFS 1024
88 #define KERNEL_THREADS_MAX 256
89 #define KERNEL_THREADS_MAX_CPU 1
90 #define POWERTUNE_ENABLE 0
91 #define LOGFILE_DISABLE 0
92 #define SCRYPT_TMTO 0
93 #define OPENCL_VECTOR_WIDTH 0
94
95 #define WL_MODE_STDIN 1
96 #define WL_MODE_FILE 2
97 #define WL_MODE_MASK 3
98
99 #define HL_MODE_FILE 4
100 #define HL_MODE_ARG 5
101
102 #define HLFMTS_CNT 11
103 #define HLFMT_HASHCAT 0
104 #define HLFMT_PWDUMP 1
105 #define HLFMT_PASSWD 2
106 #define HLFMT_SHADOW 3
107 #define HLFMT_DCC 4
108 #define HLFMT_DCC2 5
109 #define HLFMT_NETNTLM1 7
110 #define HLFMT_NETNTLM2 8
111 #define HLFMT_NSLDAP 9
112 #define HLFMT_NSLDAPS 10
113
114 #define HLFMT_TEXT_HASHCAT "native hashcat"
115 #define HLFMT_TEXT_PWDUMP "pwdump"
116 #define HLFMT_TEXT_PASSWD "passwd"
117 #define HLFMT_TEXT_SHADOW "shadow"
118 #define HLFMT_TEXT_DCC "DCC"
119 #define HLFMT_TEXT_DCC2 "DCC 2"
120 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
121 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
122 #define HLFMT_TEXT_NSLDAP "nsldap"
123 #define HLFMT_TEXT_NSLDAPS "nsldaps"
124
125 #define ATTACK_MODE_STRAIGHT 0
126 #define ATTACK_MODE_COMBI 1
127 #define ATTACK_MODE_TOGGLE 2
128 #define ATTACK_MODE_BF 3
129 #define ATTACK_MODE_PERM 4
130 #define ATTACK_MODE_TABLE 5
131 #define ATTACK_MODE_HYBRID1 6
132 #define ATTACK_MODE_HYBRID2 7
133 #define ATTACK_MODE_NONE 100
134
135 #define ATTACK_KERN_STRAIGHT 0
136 #define ATTACK_KERN_COMBI 1
137 #define ATTACK_KERN_BF 3
138 #define ATTACK_KERN_NONE 100
139
140 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
141 #define ATTACK_EXEC_INSIDE_KERNEL 11
142
143 #define COMBINATOR_MODE_BASE_LEFT 10001
144 #define COMBINATOR_MODE_BASE_RIGHT 10002
145
146 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
147 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
148
149 #define MAX_CUT_TRIES 4
150
151 #define MAX_DICTSTAT 10000
152
153 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
154
155 #define NVIDIA_100PERCENTCPU_WORKAROUND 100
156
157 #define global_free(attr) \
158 { \
159 myfree ((void *) data.attr); \
160 \
161 data.attr = NULL; \
162 }
163
164 #define local_free(attr) \
165 { \
166 myfree ((void *) attr); \
167 \
168 attr = NULL; \
169 }
170
171 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
172 #define HC_API_CALL __stdcall
173 #else
174 #define HC_API_CALL
175 #endif
176
177 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
178 {
179 900,
180 0,
181 5100,
182 100,
183 1400,
184 10800,
185 1700,
186 5000,
187 10100,
188 6000,
189 6100,
190 6900,
191 11700,
192 11800,
193 400,
194 8900,
195 11900,
196 12000,
197 10900,
198 12100,
199 23,
200 2500,
201 5300,
202 5400,
203 5500,
204 5600,
205 7300,
206 7500,
207 13100,
208 8300,
209 11100,
210 11200,
211 11400,
212 121,
213 2611,
214 2711,
215 2811,
216 8400,
217 11,
218 2612,
219 7900,
220 21,
221 11000,
222 124,
223 10000,
224 3711,
225 7600,
226 12,
227 131,
228 132,
229 1731,
230 200,
231 300,
232 3100,
233 112,
234 12300,
235 8000,
236 141,
237 1441,
238 1600,
239 12600,
240 1421,
241 101,
242 111,
243 1711,
244 3000,
245 1000,
246 1100,
247 2100,
248 12800,
249 1500,
250 12400,
251 500,
252 3200,
253 7400,
254 1800,
255 122,
256 1722,
257 7100,
258 6300,
259 6700,
260 6400,
261 6500,
262 2400,
263 2410,
264 5700,
265 9200,
266 9300,
267 22,
268 501,
269 5800,
270 8100,
271 8500,
272 7200,
273 9900,
274 7700,
275 7800,
276 10300,
277 8600,
278 8700,
279 9100,
280 133,
281 13500,
282 11600,
283 13600,
284 12500,
285 13000,
286 13200,
287 13300,
288 6211,
289 6221,
290 6231,
291 6241,
292 13711,
293 13721,
294 13731,
295 13741,
296 13751,
297 13761,
298 8800,
299 12900,
300 12200,
301 9700,
302 9710,
303 9800,
304 9810,
305 9400,
306 9500,
307 9600,
308 10400,
309 10410,
310 10500,
311 10600,
312 10700,
313 9000,
314 5200,
315 6800,
316 6600,
317 8200,
318 11300,
319 12700,
320 13400,
321 125
322 };
323
324 /**
325 * types
326 */
327
328 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
329
330 /**
331 * globals
332 */
333
334 static unsigned int full01 = 0x01010101;
335 static unsigned int full80 = 0x80808080;
336
337 int SUPPRESS_OUTPUT = 0;
338
339 hc_thread_mutex_t mux_adl;
340 hc_thread_mutex_t mux_counter;
341 hc_thread_mutex_t mux_dispatcher;
342 hc_thread_mutex_t mux_display;
343
344 hc_global_data_t data;
345
346 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
347
348 const char *USAGE_MINI[] =
349 {
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "Try --help for more help.",
353 NULL
354 };
355
356 const char *USAGE_BIG[] =
357 {
358 "%s, advanced password recovery",
359 "",
360 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
361 "",
362 "- [ Options ] -",
363 "",
364 " Options Short / Long | Type | Description | Example",
365 "===============================+======+======================================================+=======================",
366 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
367 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
368 " -V, --version | | Print version |",
369 " -h, --help | | Print help |",
370 " --quiet | | Suppress output |",
371 " --hex-charset | | Assume charset is given in hex |",
372 " --hex-salt | | Assume salt is given in hex |",
373 " --hex-wordlist | | Assume words in wordlist is given in hex |",
374 " --force | | Ignore warnings |",
375 " --status | | Enable automatic update of the status-screen |",
376 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
377 " --machine-readable | | Display the status view in a machine readable format |",
378 " --loopback | | Add new plains to induct directory |",
379 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
380 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
381 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
382 " --markov-classic | | Enables classic markov-chains, no per-position |",
383 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
384 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
385 " --session | Str | Define specific session name | --session=mysession",
386 " --restore | | Restore session from --session |",
387 " --restore-disable | | Do not write restore file |",
388 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
389 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
390 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
391 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
392 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
393 " --stdout | | Do not crack a hash, instead print candidates only |",
394 " --show | | Compare hashlist with potfile; Show cracked hashes |",
395 " --left | | Compare hashlist with potfile; Show uncracked hashes |",
396 " --username | | Enable ignoring of usernames in hashfile |",
397 " --remove | | Enable remove of hash once it is cracked |",
398 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
399 " --potfile-disable | | Do not write potfile |",
400 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
401 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
402 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
403 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
404 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
405 " --logfile-disable | | Disable the logfile |",
406 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
407 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
408 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
409 " -b, --benchmark | | Run benchmark |",
410 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
411 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
412 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
413 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
414 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
415 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
416 " -D, --opencl-device-types | Str | OpenCL device-types to use, separate with comma | -D 1",
417 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
418 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
419 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
420 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
421 " --nvidia-spin-damp | Num | Workaround NVidias CPU burning loop bug, in percent | --nvidia-spin-damp=50",
422 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
423 #ifdef HAVE_HWMON
424 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
425 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
426 " --powertune-enable | | Enable power tuning, restores settings when finished |",
427 #endif
428 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
429 " -s, --skip | Num | Skip X words from the start | -s 1000000",
430 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
431 " --keyspace | | Show keyspace base:mod values and quit |",
432 " -j, --rule-left | Rule | Single rule applied to each word from left wordlist | -j 'c'",
433 " -k, --rule-right | Rule | Single rule applied to each word from right wordlist | -k '^-'",
434 " -r, --rules-file | File | Multiple rules applied to each word from wordlists | -r rules/best64.rule",
435 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
436 " --generate-rules-func-min | Num | Force min X funcs per rule |",
437 " --generate-rules-func-max | Num | Force max X funcs per rule |",
438 " --generate-rules-seed | Num | Force RNG seed set to X |",
439 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
440 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
441 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
442 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
443 " -i, --increment | | Enable mask increment mode |",
444 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
445 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
446 "",
447 "- [ Hash modes ] -",
448 "",
449 " # | Name | Category",
450 " ======+==================================================+======================================",
451 " 900 | MD4 | Raw Hash",
452 " 0 | MD5 | Raw Hash",
453 " 5100 | Half MD5 | Raw Hash",
454 " 100 | SHA1 | Raw Hash",
455 " 10800 | SHA-384 | Raw Hash",
456 " 1400 | SHA-256 | Raw Hash",
457 " 1700 | SHA-512 | Raw Hash",
458 " 5000 | SHA-3(Keccak) | Raw Hash",
459 " 10100 | SipHash | Raw Hash",
460 " 6000 | RipeMD160 | Raw Hash",
461 " 6100 | Whirlpool | Raw Hash",
462 " 6900 | GOST R 34.11-94 | Raw Hash",
463 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
464 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
465 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
466 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
467 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
468 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
469 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
470 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
471 " 2600 | md5(md5($pass)) | Raw Hash, Salted and / or Iterated",
472 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
473 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
474 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
475 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
476 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
477 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
478 " 4500 | sha1(sha1($pass)) | Raw Hash, Salted and / or Iterated",
479 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
480 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
481 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
482 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
483 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
484 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
485 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
486 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
487 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
488 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
489 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
490 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
491 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
492 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
493 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
494 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
495 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
496 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
497 " 400 | phpass | Generic KDF",
498 " 8900 | scrypt | Generic KDF",
499 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
500 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
501 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
502 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
503 " 23 | Skype | Network protocols",
504 " 2500 | WPA/WPA2 | Network protocols",
505 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
506 " 5300 | IKE-PSK MD5 | Network protocols",
507 " 5400 | IKE-PSK SHA1 | Network protocols",
508 " 5500 | NetNTLMv1 | Network protocols",
509 " 5500 | NetNTLMv1 + ESS | Network protocols",
510 " 5600 | NetNTLMv2 | Network protocols",
511 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
512 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
513 " 8300 | DNSSEC (NSEC3) | Network protocols",
514 " 10200 | Cram MD5 | Network protocols",
515 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
516 " 11200 | MySQL CRAM (SHA1) | Network protocols",
517 " 11400 | SIP digest authentication (MD5) | Network protocols",
518 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
519 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
520 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
521 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
522 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
523 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
524 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
525 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
526 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
527 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
528 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
529 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
530 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
531 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
532 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
533 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
534 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
535 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
536 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
537 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
538 " 12 | PostgreSQL | Database Server",
539 " 131 | MSSQL(2000) | Database Server",
540 " 132 | MSSQL(2005) | Database Server",
541 " 1731 | MSSQL(2012) | Database Server",
542 " 1731 | MSSQL(2014) | Database Server",
543 " 200 | MySQL323 | Database Server",
544 " 300 | MySQL4.1/MySQL5 | Database Server",
545 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
546 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
547 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
548 " 8000 | Sybase ASE | Database Server",
549 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
550 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
551 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
552 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
553 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
554 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
555 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
556 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
557 " 11500 | CRC32 | Checksums",
558 " 3000 | LM | Operating-Systems",
559 " 1000 | NTLM | Operating-Systems",
560 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
561 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
562 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
563 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
564 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
565 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
566 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
567 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
568 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
569 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
570 " 1722 | OSX v10.7 | Operating-Systems",
571 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
572 " 6300 | AIX {smd5} | Operating-Systems",
573 " 6700 | AIX {ssha1} | Operating-Systems",
574 " 6400 | AIX {ssha256} | Operating-Systems",
575 " 6500 | AIX {ssha512} | Operating-Systems",
576 " 2400 | Cisco-PIX | Operating-Systems",
577 " 2410 | Cisco-ASA | Operating-Systems",
578 " 500 | Cisco-IOS $1$ | Operating-Systems",
579 " 5700 | Cisco-IOS $4$ | Operating-Systems",
580 " 9200 | Cisco-IOS $8$ | Operating-Systems",
581 " 9300 | Cisco-IOS $9$ | Operating-Systems",
582 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
583 " 501 | Juniper IVE | Operating-Systems",
584 " 5800 | Android PIN | Operating-Systems",
585 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
586 " 8100 | Citrix Netscaler | Operating-Systems",
587 " 8500 | RACF | Operating-Systems",
588 " 7200 | GRUB 2 | Operating-Systems",
589 " 9900 | Radmin2 | Operating-Systems",
590 " 125 | ArubaOS | Operating-Systems",
591 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
592 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
593 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
594 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
595 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
596 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
597 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
598 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
599 " 11600 | 7-Zip | Archives",
600 " 12500 | RAR3-hp | Archives",
601 " 13000 | RAR5 | Archives",
602 " 13200 | AxCrypt | Archives",
603 " 13300 | AxCrypt in memory SHA1 | Archives",
604 " 13600 | WinZip | Archives",
605 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
606 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
607 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
608 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
609 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
610 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
611 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
612 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
613 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
614 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
615 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
616 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
617 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
618 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
619 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
620 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
621 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
622 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
623 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
624 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
625 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
626 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
627 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
628 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
629 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
630 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
631 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
632 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
633 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
634 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
635 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
636 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
637 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
638 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
639 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
640 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
641 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
642 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
643 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
644 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
645 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
646 " 9400 | MS Office 2007 | Documents",
647 " 9500 | MS Office 2010 | Documents",
648 " 9600 | MS Office 2013 | Documents",
649 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
650 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
651 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
652 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
653 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
654 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
655 " 9000 | Password Safe v2 | Password Managers",
656 " 5200 | Password Safe v3 | Password Managers",
657 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
658 " 6600 | 1Password, agilekeychain | Password Managers",
659 " 8200 | 1Password, cloudkeychain | Password Managers",
660 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
661 " 12700 | Blockchain, My Wallet | Password Managers",
662 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
663 "",
664 "- [ Outfile Formats ] -",
665 "",
666 " # | Format",
667 " ===+========",
668 " 1 | hash[:salt]",
669 " 2 | plain",
670 " 3 | hash[:salt]:plain",
671 " 4 | hex_plain",
672 " 5 | hash[:salt]:hex_plain",
673 " 6 | plain:hex_plain",
674 " 7 | hash[:salt]:plain:hex_plain",
675 " 8 | crackpos",
676 " 9 | hash[:salt]:crack_pos",
677 " 10 | plain:crack_pos",
678 " 11 | hash[:salt]:plain:crack_pos",
679 " 12 | hex_plain:crack_pos",
680 " 13 | hash[:salt]:hex_plain:crack_pos",
681 " 14 | plain:hex_plain:crack_pos",
682 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
683 "",
684 "- [ Rule Debugging Modes ] -",
685 "",
686 " # | Format",
687 " ===+========",
688 " 1 | Finding-Rule",
689 " 2 | Original-Word",
690 " 3 | Original-Word:Finding-Rule",
691 " 4 | Original-Word:Finding-Rule:Processed-Word",
692 "",
693 "- [ Attack Modes ] -",
694 "",
695 " # | Mode",
696 " ===+======",
697 " 0 | Straight",
698 " 1 | Combination",
699 " 3 | Brute-force",
700 " 6 | Hybrid Wordlist + Mask",
701 " 7 | Hybrid Mask + Wordlist",
702 "",
703 "- [ Built-in Charsets ] -",
704 "",
705 " ? | Charset",
706 " ===+=========",
707 " l | abcdefghijklmnopqrstuvwxyz",
708 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
709 " d | 0123456789",
710 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
711 " a | ?l?u?d?s",
712 " b | 0x00 - 0xff",
713 "",
714 "- [ OpenCL Device Types ] -",
715 "",
716 " # | Device Type",
717 " ===+=============",
718 " 1 | CPU",
719 " 2 | GPU",
720 " 3 | FPGA, DSP, Co-Processor",
721 "",
722 "- [ Workload Profiles ] -",
723 "",
724 " # | Performance | Runtime | Power Consumption | Desktop Impact",
725 " ===+=============+=========+===================+=================",
726 " 1 | Low | 2 ms | Low | Minimal",
727 " 2 | Default | 12 ms | Economic | Noticeable",
728 " 3 | High | 96 ms | High | Unresponsive",
729 " 4 | Nightmare | 480 ms | Insane | Headless",
730 "",
731 "- [ Basic Examples ] -",
732 "",
733 " Attack- | Hash- |",
734 " Mode | Type | Example command",
735 " ==================+=======+==================================================================",
736 " Wordlist | $P$ | %s -a 0 -m 400 example400.hash example.dict",
737 " Wordlist + Rules | MD5 | %s -a 0 -m 0 example0.hash example.dict -r rules/best64.rule",
738 " Brute-Force | MD5 | %s -a 3 -m 0 example0.hash ?a?a?a?a?a?a",
739 " Combinator | MD5 | %s -a 1 -m 0 example0.hash example.dict example.dict",
740 "",
741 "If you still have no idea what just happened try following pages:",
742 "",
743 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
744 "* https://hashcat.net/wiki/#frequently_asked_questions",
745 NULL
746 };
747
748 /**
749 * hashcat specific functions
750 */
751
752 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
753 {
754 int exec_pos = (int) device_param->exec_pos - last_num_entries;
755
756 if (exec_pos < 0) exec_pos += EXEC_CACHE;
757
758 double exec_ms_sum = 0;
759
760 int exec_ms_cnt = 0;
761
762 for (int i = 0; i < last_num_entries; i++)
763 {
764 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
765
766 if (exec_ms)
767 {
768 exec_ms_sum += exec_ms;
769
770 exec_ms_cnt++;
771 }
772 }
773
774 if (exec_ms_cnt == 0) return 0;
775
776 return exec_ms_sum / exec_ms_cnt;
777 }
778
779 void status_display_machine_readable ()
780 {
781 FILE *out = stdout;
782
783 fprintf (out, "STATUS\t%u\t", data.devices_status);
784
785 /**
786 * speed new
787 */
788
789 fprintf (out, "SPEED\t");
790
791 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
792 {
793 hc_device_param_t *device_param = &data.devices_param[device_id];
794
795 if (device_param->skipped) continue;
796
797 u64 speed_cnt = 0;
798 double speed_ms = 0;
799
800 for (int i = 0; i < SPEED_CACHE; i++)
801 {
802 speed_cnt += device_param->speed_cnt[i];
803 speed_ms += device_param->speed_ms[i];
804 }
805
806 speed_cnt /= SPEED_CACHE;
807 speed_ms /= SPEED_CACHE;
808
809 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
810 }
811
812 /**
813 * exec time
814 */
815
816 fprintf (out, "EXEC_RUNTIME\t");
817
818 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
819 {
820 hc_device_param_t *device_param = &data.devices_param[device_id];
821
822 if (device_param->skipped) continue;
823
824 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
825
826 fprintf (out, "%f\t", exec_ms_avg);
827 }
828
829 /**
830 * words_cur
831 */
832
833 u64 words_cur = get_lowest_words_done ();
834
835 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
836
837 /**
838 * counter
839 */
840
841 u64 progress_total = data.words_cnt * data.salts_cnt;
842
843 u64 all_done = 0;
844 u64 all_rejected = 0;
845 u64 all_restored = 0;
846
847 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
848 {
849 all_done += data.words_progress_done[salt_pos];
850 all_rejected += data.words_progress_rejected[salt_pos];
851 all_restored += data.words_progress_restored[salt_pos];
852 }
853
854 u64 progress_cur = all_restored + all_done + all_rejected;
855 u64 progress_end = progress_total;
856
857 u64 progress_skip = 0;
858
859 if (data.skip)
860 {
861 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
862
863 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
864 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
865 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
866 }
867
868 if (data.limit)
869 {
870 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
871
872 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
873 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
874 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
875 }
876
877 u64 progress_cur_relative_skip = progress_cur - progress_skip;
878 u64 progress_end_relative_skip = progress_end - progress_skip;
879
880 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
881
882 /**
883 * cracks
884 */
885
886 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
887 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
888
889 /**
890 * temperature
891 */
892
893 #ifdef HAVE_HWMON
894 if (data.gpu_temp_disable == 0)
895 {
896 fprintf (out, "TEMP\t");
897
898 hc_thread_mutex_lock (mux_adl);
899
900 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
901 {
902 hc_device_param_t *device_param = &data.devices_param[device_id];
903
904 if (device_param->skipped) continue;
905
906 int temp = hm_get_temperature_with_device_id (device_id);
907
908 fprintf (out, "%d\t", temp);
909 }
910
911 hc_thread_mutex_unlock (mux_adl);
912 }
913 #endif // HAVE_HWMON
914
915 /**
916 * flush
917 */
918
919 fputs (EOL, out);
920 fflush (out);
921 }
922
923 void status_display ()
924 {
925 if (data.devices_status == STATUS_INIT) return;
926 if (data.devices_status == STATUS_STARTING) return;
927
928 // in this case some required buffers are free'd, ascii_digest() would run into segfault
929 if (data.shutdown_inner == 1) return;
930
931 if (data.machine_readable == 1)
932 {
933 status_display_machine_readable ();
934
935 return;
936 }
937
938 char tmp_buf[1000] = { 0 };
939
940 uint tmp_len = 0;
941
942 log_info ("Session.Name...: %s", data.session);
943
944 char *status_type = strstatus (data.devices_status);
945
946 uint hash_mode = data.hash_mode;
947
948 char *hash_type = strhashtype (hash_mode); // not a bug
949
950 log_info ("Status.........: %s", status_type);
951
952 /**
953 * show rules
954 */
955
956 if (data.rp_files_cnt)
957 {
958 uint i;
959
960 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
961 {
962 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
963 }
964
965 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
966
967 log_info ("Rules.Type.....: %s", tmp_buf);
968
969 tmp_len = 0;
970 }
971
972 if (data.rp_gen)
973 {
974 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
975
976 if (data.rp_gen_seed)
977 {
978 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
979 }
980 }
981
982 /**
983 * show input
984 */
985
986 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
987 {
988 if (data.wordlist_mode == WL_MODE_FILE)
989 {
990 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
991 }
992 else if (data.wordlist_mode == WL_MODE_STDIN)
993 {
994 log_info ("Input.Mode.....: Pipe");
995 }
996 }
997 else if (data.attack_mode == ATTACK_MODE_COMBI)
998 {
999 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1000 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1001 }
1002 else if (data.attack_mode == ATTACK_MODE_BF)
1003 {
1004 char *mask = data.mask;
1005
1006 if (mask != NULL)
1007 {
1008 uint mask_len = data.css_cnt;
1009
1010 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1011
1012 if (mask_len > 0)
1013 {
1014 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1015 {
1016 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1017 {
1018 mask_len -= data.salts_buf[0].salt_len;
1019 }
1020 }
1021
1022 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1023
1024 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1025 }
1026
1027 if (data.maskcnt > 1)
1028 {
1029 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1030
1031 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1032 }
1033
1034 log_info ("Input.Mode.....: %s", tmp_buf);
1035 }
1036
1037 tmp_len = 0;
1038 }
1039 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1040 {
1041 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1042 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1043 }
1044 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1045 {
1046 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1047 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1048 }
1049
1050 if (data.digests_cnt == 1)
1051 {
1052 if (data.hash_mode == 2500)
1053 {
1054 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1055
1056 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1057 (char *) data.salts_buf[0].salt_buf,
1058 wpa->orig_mac1[0],
1059 wpa->orig_mac1[1],
1060 wpa->orig_mac1[2],
1061 wpa->orig_mac1[3],
1062 wpa->orig_mac1[4],
1063 wpa->orig_mac1[5],
1064 wpa->orig_mac2[0],
1065 wpa->orig_mac2[1],
1066 wpa->orig_mac2[2],
1067 wpa->orig_mac2[3],
1068 wpa->orig_mac2[4],
1069 wpa->orig_mac2[5]);
1070 }
1071 else if (data.hash_mode == 5200)
1072 {
1073 log_info ("Hash.Target....: File (%s)", data.hashfile);
1074 }
1075 else if (data.hash_mode == 9000)
1076 {
1077 log_info ("Hash.Target....: File (%s)", data.hashfile);
1078 }
1079 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1080 {
1081 log_info ("Hash.Target....: File (%s)", data.hashfile);
1082 }
1083 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1084 {
1085 log_info ("Hash.Target....: File (%s)", data.hashfile);
1086 }
1087 else
1088 {
1089 char out_buf[HCBUFSIZ] = { 0 };
1090
1091 ascii_digest (out_buf, 0, 0);
1092
1093 // limit length
1094 if (strlen (out_buf) > 40)
1095 {
1096 out_buf[41] = '.';
1097 out_buf[42] = '.';
1098 out_buf[43] = '.';
1099 out_buf[44] = 0;
1100 }
1101
1102 log_info ("Hash.Target....: %s", out_buf);
1103 }
1104 }
1105 else
1106 {
1107 if (data.hash_mode == 3000)
1108 {
1109 char out_buf1[32] = { 0 };
1110 char out_buf2[32] = { 0 };
1111
1112 ascii_digest (out_buf1, 0, 0);
1113 ascii_digest (out_buf2, 0, 1);
1114
1115 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1116 }
1117 else
1118 {
1119 log_info ("Hash.Target....: File (%s)", data.hashfile);
1120 }
1121 }
1122
1123 log_info ("Hash.Type......: %s", hash_type);
1124
1125 /**
1126 * speed new
1127 */
1128
1129 u64 speed_cnt[DEVICES_MAX] = { 0 };
1130 double speed_ms[DEVICES_MAX] = { 0 };
1131
1132 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1133 {
1134 hc_device_param_t *device_param = &data.devices_param[device_id];
1135
1136 if (device_param->skipped) continue;
1137
1138 speed_cnt[device_id] = 0;
1139 speed_ms[device_id] = 0;
1140
1141 for (int i = 0; i < SPEED_CACHE; i++)
1142 {
1143 speed_cnt[device_id] += device_param->speed_cnt[i];
1144 speed_ms[device_id] += device_param->speed_ms[i];
1145 }
1146
1147 speed_cnt[device_id] /= SPEED_CACHE;
1148 speed_ms[device_id] /= SPEED_CACHE;
1149 }
1150
1151 double hashes_all_ms = 0;
1152
1153 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1154
1155 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1156 {
1157 hc_device_param_t *device_param = &data.devices_param[device_id];
1158
1159 if (device_param->skipped) continue;
1160
1161 hashes_dev_ms[device_id] = 0;
1162
1163 if (speed_ms[device_id])
1164 {
1165 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1166
1167 hashes_all_ms += hashes_dev_ms[device_id];
1168 }
1169 }
1170
1171 /**
1172 * exec time
1173 */
1174
1175 double exec_all_ms[DEVICES_MAX] = { 0 };
1176
1177 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1178 {
1179 hc_device_param_t *device_param = &data.devices_param[device_id];
1180
1181 if (device_param->skipped) continue;
1182
1183 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1184
1185 exec_all_ms[device_id] = exec_ms_avg;
1186 }
1187
1188 /**
1189 * timers
1190 */
1191
1192 double ms_running = 0;
1193
1194 hc_timer_get (data.timer_running, ms_running);
1195
1196 double ms_paused = data.ms_paused;
1197
1198 if (data.devices_status == STATUS_PAUSED)
1199 {
1200 double ms_paused_tmp = 0;
1201
1202 hc_timer_get (data.timer_paused, ms_paused_tmp);
1203
1204 ms_paused += ms_paused_tmp;
1205 }
1206
1207 #ifdef WIN
1208
1209 __time64_t sec_run = ms_running / 1000;
1210
1211 #else
1212
1213 time_t sec_run = ms_running / 1000;
1214
1215 #endif
1216
1217 if (sec_run)
1218 {
1219 char display_run[32] = { 0 };
1220
1221 struct tm tm_run;
1222
1223 struct tm *tmp = NULL;
1224
1225 #ifdef WIN
1226
1227 tmp = _gmtime64 (&sec_run);
1228
1229 #else
1230
1231 tmp = gmtime (&sec_run);
1232
1233 #endif
1234
1235 if (tmp != NULL)
1236 {
1237 memset (&tm_run, 0, sizeof (tm_run));
1238
1239 memcpy (&tm_run, tmp, sizeof (tm_run));
1240
1241 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1242
1243 char *start = ctime (&data.proc_start);
1244
1245 size_t start_len = strlen (start);
1246
1247 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1248 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1249
1250 log_info ("Time.Started...: %s (%s)", start, display_run);
1251 }
1252 }
1253 else
1254 {
1255 log_info ("Time.Started...: 0 secs");
1256 }
1257
1258 /**
1259 * counters
1260 */
1261
1262 u64 progress_total = data.words_cnt * data.salts_cnt;
1263
1264 u64 all_done = 0;
1265 u64 all_rejected = 0;
1266 u64 all_restored = 0;
1267
1268 u64 progress_noneed = 0;
1269
1270 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1271 {
1272 all_done += data.words_progress_done[salt_pos];
1273 all_rejected += data.words_progress_rejected[salt_pos];
1274 all_restored += data.words_progress_restored[salt_pos];
1275
1276 // Important for ETA only
1277
1278 if (data.salts_shown[salt_pos] == 1)
1279 {
1280 const u64 all = data.words_progress_done[salt_pos]
1281 + data.words_progress_rejected[salt_pos]
1282 + data.words_progress_restored[salt_pos];
1283
1284 const u64 left = data.words_cnt - all;
1285
1286 progress_noneed += left;
1287 }
1288 }
1289
1290 u64 progress_cur = all_restored + all_done + all_rejected;
1291 u64 progress_end = progress_total;
1292
1293 u64 progress_skip = 0;
1294
1295 if (data.skip)
1296 {
1297 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1298
1299 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1300 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1301 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1302 }
1303
1304 if (data.limit)
1305 {
1306 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1307
1308 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1309 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1310 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1311 }
1312
1313 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1314 u64 progress_end_relative_skip = progress_end - progress_skip;
1315
1316 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1317 {
1318 if (data.devices_status != STATUS_CRACKED)
1319 {
1320 #ifdef WIN
1321 __time64_t sec_etc = 0;
1322 #else
1323 time_t sec_etc = 0;
1324 #endif
1325
1326 if (hashes_all_ms)
1327 {
1328 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1329
1330 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1331
1332 sec_etc = ms_left / 1000;
1333 }
1334
1335 if (sec_etc == 0)
1336 {
1337 //log_info ("Time.Estimated.: 0 secs");
1338 }
1339 else if ((u64) sec_etc > ETC_MAX)
1340 {
1341 log_info ("Time.Estimated.: > 10 Years");
1342 }
1343 else
1344 {
1345 char display_etc[32] = { 0 };
1346 char display_runtime[32] = { 0 };
1347
1348 struct tm tm_etc;
1349 struct tm tm_runtime;
1350
1351 struct tm *tmp = NULL;
1352
1353 #ifdef WIN
1354 tmp = _gmtime64 (&sec_etc);
1355 #else
1356 tmp = gmtime (&sec_etc);
1357 #endif
1358
1359 if (tmp != NULL)
1360 {
1361 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1362
1363 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1364
1365 time_t now;
1366
1367 time (&now);
1368
1369 now += sec_etc;
1370
1371 char *etc = ctime (&now);
1372
1373 size_t etc_len = strlen (etc);
1374
1375 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1376 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1377
1378 if (data.runtime)
1379 {
1380 time_t runtime_cur;
1381
1382 time (&runtime_cur);
1383
1384 #ifdef WIN
1385
1386 __time64_t runtime_left = data.proc_start + data.runtime - runtime_cur;
1387
1388 tmp = _gmtime64 (&runtime_left);
1389
1390 #else
1391
1392 time_t runtime_left = data.proc_start + data.runtime - runtime_cur;
1393
1394 tmp = gmtime (&runtime_left);
1395
1396 #endif
1397
1398 if ((tmp != NULL) && (runtime_left > 0) && (runtime_left < sec_etc))
1399 {
1400 memcpy (&tm_runtime, tmp, sizeof (tm_runtime));
1401
1402 format_timer_display (&tm_runtime, display_runtime, sizeof (display_runtime));
1403
1404 log_info ("Time.Estimated.: %s (%s), but limited (%s)", etc, display_etc, display_runtime);
1405 }
1406 else
1407 {
1408 log_info ("Time.Estimated.: %s (%s), but limit exceeded", etc, display_etc);
1409 }
1410 }
1411 else
1412 {
1413 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1414 }
1415 }
1416 }
1417 }
1418 }
1419
1420 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1421 {
1422 hc_device_param_t *device_param = &data.devices_param[device_id];
1423
1424 if (device_param->skipped) continue;
1425
1426 char display_dev_cur[16] = { 0 };
1427
1428 strncpy (display_dev_cur, "0.00", 4);
1429
1430 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1431
1432 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1433 }
1434
1435 char display_all_cur[16] = { 0 };
1436
1437 strncpy (display_all_cur, "0.00", 4);
1438
1439 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1440
1441 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1442
1443 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1444 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1445
1446 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);
1447
1448 // crack-per-time
1449
1450 if (data.digests_cnt > 100)
1451 {
1452 time_t now = time (NULL);
1453
1454 int cpt_cur_min = 0;
1455 int cpt_cur_hour = 0;
1456 int cpt_cur_day = 0;
1457
1458 for (int i = 0; i < CPT_BUF; i++)
1459 {
1460 const uint cracked = data.cpt_buf[i].cracked;
1461 const time_t timestamp = data.cpt_buf[i].timestamp;
1462
1463 if ((timestamp + 60) > now)
1464 {
1465 cpt_cur_min += cracked;
1466 }
1467
1468 if ((timestamp + 3600) > now)
1469 {
1470 cpt_cur_hour += cracked;
1471 }
1472
1473 if ((timestamp + 86400) > now)
1474 {
1475 cpt_cur_day += cracked;
1476 }
1477 }
1478
1479 double ms_real = ms_running - ms_paused;
1480
1481 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1482 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1483 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1484
1485 if ((data.cpt_start + 86400) < now)
1486 {
1487 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1488 cpt_cur_min,
1489 cpt_cur_hour,
1490 cpt_cur_day,
1491 cpt_avg_min,
1492 cpt_avg_hour,
1493 cpt_avg_day);
1494 }
1495 else if ((data.cpt_start + 3600) < now)
1496 {
1497 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1498 cpt_cur_min,
1499 cpt_cur_hour,
1500 cpt_avg_min,
1501 cpt_avg_hour,
1502 cpt_avg_day);
1503 }
1504 else if ((data.cpt_start + 60) < now)
1505 {
1506 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1507 cpt_cur_min,
1508 cpt_avg_min,
1509 cpt_avg_hour,
1510 cpt_avg_day);
1511 }
1512 else
1513 {
1514 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1515 cpt_avg_min,
1516 cpt_avg_hour,
1517 cpt_avg_day);
1518 }
1519 }
1520
1521 // Restore point
1522
1523 u64 restore_point = get_lowest_words_done ();
1524
1525 u64 restore_total = data.words_base;
1526
1527 float percent_restore = 0;
1528
1529 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1530
1531 if (progress_end_relative_skip)
1532 {
1533 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1534 {
1535 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1536 float percent_rejected = 0.0;
1537
1538 if (progress_cur)
1539 {
1540 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1541 }
1542
1543 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);
1544 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1545
1546 if (data.restore_disable == 0)
1547 {
1548 if (percent_finished != 1)
1549 {
1550 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1551 }
1552 }
1553 }
1554 }
1555 else
1556 {
1557 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1558 {
1559 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1560 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1561
1562 if (data.restore_disable == 0)
1563 {
1564 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1565 }
1566 }
1567 else
1568 {
1569 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1570 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1571
1572 // --restore not allowed if stdin is used -- really? why?
1573
1574 //if (data.restore_disable == 0)
1575 //{
1576 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1577 //}
1578 }
1579 }
1580
1581 #ifdef HAVE_HWMON
1582
1583 if (data.devices_status == STATUS_EXHAUSTED) return;
1584 if (data.devices_status == STATUS_CRACKED) return;
1585 if (data.devices_status == STATUS_ABORTED) return;
1586 if (data.devices_status == STATUS_QUIT) return;
1587
1588 if (data.gpu_temp_disable == 0)
1589 {
1590 hc_thread_mutex_lock (mux_adl);
1591
1592 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1593 {
1594 hc_device_param_t *device_param = &data.devices_param[device_id];
1595
1596 if (device_param->skipped) continue;
1597
1598 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1599 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1600 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1601 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1602 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1603 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1604 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1605
1606 char output_buf[256] = { 0 };
1607
1608 int output_len = 0;
1609
1610 if (num_temperature >= 0)
1611 {
1612 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1613
1614 output_len = strlen (output_buf);
1615 }
1616
1617 if (num_fanspeed >= 0)
1618 {
1619 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1620
1621 output_len = strlen (output_buf);
1622 }
1623
1624 if (num_utilization >= 0)
1625 {
1626 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1627
1628 output_len = strlen (output_buf);
1629 }
1630
1631 if (num_corespeed >= 0)
1632 {
1633 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1634
1635 output_len = strlen (output_buf);
1636 }
1637
1638 if (num_memoryspeed >= 0)
1639 {
1640 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1641
1642 output_len = strlen (output_buf);
1643 }
1644
1645 if (num_buslanes >= 0)
1646 {
1647 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1648
1649 output_len = strlen (output_buf);
1650 }
1651
1652 if (num_throttle == 1)
1653 {
1654 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1655
1656 output_len = strlen (output_buf);
1657 }
1658
1659 if (output_len == 0)
1660 {
1661 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1662
1663 output_len = strlen (output_buf);
1664 }
1665
1666 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1667 }
1668
1669 hc_thread_mutex_unlock (mux_adl);
1670 }
1671
1672 #endif // HAVE_HWMON
1673 }
1674
1675 static void status_benchmark_automate ()
1676 {
1677 u64 speed_cnt[DEVICES_MAX] = { 0 };
1678 double speed_ms[DEVICES_MAX] = { 0 };
1679
1680 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1681 {
1682 hc_device_param_t *device_param = &data.devices_param[device_id];
1683
1684 if (device_param->skipped) continue;
1685
1686 speed_cnt[device_id] = device_param->speed_cnt[0];
1687 speed_ms[device_id] = device_param->speed_ms[0];
1688 }
1689
1690 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1691
1692 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1693 {
1694 hc_device_param_t *device_param = &data.devices_param[device_id];
1695
1696 if (device_param->skipped) continue;
1697
1698 hashes_dev_ms[device_id] = 0;
1699
1700 if (speed_ms[device_id])
1701 {
1702 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1703 }
1704 }
1705
1706 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1707 {
1708 hc_device_param_t *device_param = &data.devices_param[device_id];
1709
1710 if (device_param->skipped) continue;
1711
1712 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1713 }
1714 }
1715
1716 static void status_benchmark ()
1717 {
1718 if (data.devices_status == STATUS_INIT) return;
1719 if (data.devices_status == STATUS_STARTING) return;
1720
1721 if (data.shutdown_inner == 1) return;
1722
1723 if (data.machine_readable == 1)
1724 {
1725 status_benchmark_automate ();
1726
1727 return;
1728 }
1729
1730 u64 speed_cnt[DEVICES_MAX] = { 0 };
1731 double speed_ms[DEVICES_MAX] = { 0 };
1732
1733 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1734 {
1735 hc_device_param_t *device_param = &data.devices_param[device_id];
1736
1737 if (device_param->skipped) continue;
1738
1739 speed_cnt[device_id] = device_param->speed_cnt[0];
1740 speed_ms[device_id] = device_param->speed_ms[0];
1741 }
1742
1743 double hashes_all_ms = 0;
1744
1745 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1746
1747 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1748 {
1749 hc_device_param_t *device_param = &data.devices_param[device_id];
1750
1751 if (device_param->skipped) continue;
1752
1753 hashes_dev_ms[device_id] = 0;
1754
1755 if (speed_ms[device_id])
1756 {
1757 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1758
1759 hashes_all_ms += hashes_dev_ms[device_id];
1760 }
1761 }
1762
1763 /**
1764 * exec time
1765 */
1766
1767 double exec_all_ms[DEVICES_MAX] = { 0 };
1768
1769 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1770 {
1771 hc_device_param_t *device_param = &data.devices_param[device_id];
1772
1773 if (device_param->skipped) continue;
1774
1775 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1776
1777 exec_all_ms[device_id] = exec_ms_avg;
1778 }
1779
1780 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1781 {
1782 hc_device_param_t *device_param = &data.devices_param[device_id];
1783
1784 if (device_param->skipped) continue;
1785
1786 char display_dev_cur[16] = { 0 };
1787
1788 strncpy (display_dev_cur, "0.00", 4);
1789
1790 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1791
1792 if (data.devices_active >= 10)
1793 {
1794 log_info ("Speed.Dev.#%d: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1795 }
1796 else
1797 {
1798 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1799 }
1800 }
1801
1802 char display_all_cur[16] = { 0 };
1803
1804 strncpy (display_all_cur, "0.00", 4);
1805
1806 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1807
1808 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1809 }
1810
1811 /**
1812 * hashcat -only- functions
1813 */
1814
1815 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1816 {
1817 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1818 {
1819 if (attack_kern == ATTACK_KERN_STRAIGHT)
1820 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1821 else if (attack_kern == ATTACK_KERN_COMBI)
1822 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1823 else if (attack_kern == ATTACK_KERN_BF)
1824 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1825 }
1826 else
1827 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1828 }
1829
1830 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)
1831 {
1832 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1833 {
1834 if (attack_kern == ATTACK_KERN_STRAIGHT)
1835 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1836 else if (attack_kern == ATTACK_KERN_COMBI)
1837 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1838 else if (attack_kern == ATTACK_KERN_BF)
1839 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1840 }
1841 else
1842 {
1843 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1844 }
1845 }
1846
1847 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1848 {
1849 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1850 {
1851 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1852 }
1853 else
1854 {
1855 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1856 }
1857 }
1858
1859 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)
1860 {
1861 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1862 {
1863 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1864 }
1865 else
1866 {
1867 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1868 }
1869 }
1870
1871 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1872 {
1873 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1874 }
1875
1876 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1877 {
1878 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1879 }
1880
1881 static char *filename_from_filepath (char *filepath)
1882 {
1883 char *ptr = NULL;
1884
1885 if ((ptr = strrchr (filepath, '/')) != NULL)
1886 {
1887 ptr++;
1888 }
1889 else if ((ptr = strrchr (filepath, '\\')) != NULL)
1890 {
1891 ptr++;
1892 }
1893 else
1894 {
1895 ptr = filepath;
1896 }
1897
1898 return ptr;
1899 }
1900
1901 static uint convert_from_hex (char *line_buf, const uint line_len)
1902 {
1903 if (line_len & 1) return (line_len); // not in hex
1904
1905 if (data.hex_wordlist == 1)
1906 {
1907 uint i;
1908 uint j;
1909
1910 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1911 {
1912 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1913 }
1914
1915 memset (line_buf + i, 0, line_len - i);
1916
1917 return (i);
1918 }
1919 else if (line_len >= 6) // $HEX[] = 6
1920 {
1921 if (line_buf[0] != '$') return (line_len);
1922 if (line_buf[1] != 'H') return (line_len);
1923 if (line_buf[2] != 'E') return (line_len);
1924 if (line_buf[3] != 'X') return (line_len);
1925 if (line_buf[4] != '[') return (line_len);
1926 if (line_buf[line_len - 1] != ']') return (line_len);
1927
1928 uint i;
1929 uint j;
1930
1931 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1932 {
1933 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1934 }
1935
1936 memset (line_buf + i, 0, line_len - i);
1937
1938 return (i);
1939 }
1940
1941 return (line_len);
1942 }
1943
1944 static void clear_prompt ()
1945 {
1946 fputc ('\r', stdout);
1947
1948 for (size_t i = 0; i < strlen (PROMPT); i++)
1949 {
1950 fputc (' ', stdout);
1951 }
1952
1953 fputc ('\r', stdout);
1954
1955 fflush (stdout);
1956 }
1957
1958 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1959 {
1960 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);
1961 }
1962
1963 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1964 {
1965 char *outfile = data.outfile;
1966 uint quiet = data.quiet;
1967 FILE *pot_fp = data.pot_fp;
1968 uint loopback = data.loopback;
1969 uint debug_mode = data.debug_mode;
1970 char *debug_file = data.debug_file;
1971
1972 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1973 int debug_rule_len = 0; // -1 error
1974 uint debug_plain_len = 0;
1975
1976 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1977
1978 // hash
1979
1980 char out_buf[HCBUFSIZ] = { 0 };
1981
1982 const u32 salt_pos = plain->salt_pos;
1983 const u32 digest_pos = plain->digest_pos; // relative
1984 const u32 gidvid = plain->gidvid;
1985 const u32 il_pos = plain->il_pos;
1986
1987 ascii_digest (out_buf, salt_pos, digest_pos);
1988
1989 // plain
1990
1991 u64 crackpos = device_param->words_off;
1992
1993 uint plain_buf[16] = { 0 };
1994
1995 u8 *plain_ptr = (u8 *) plain_buf;
1996
1997 unsigned int plain_len = 0;
1998
1999 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2000 {
2001 pw_t pw;
2002
2003 gidd_to_pw_t (device_param, gidvid, &pw);
2004
2005 for (int i = 0; i < 16; i++)
2006 {
2007 plain_buf[i] = pw.i[i];
2008 }
2009
2010 plain_len = pw.pw_len;
2011
2012 const uint off = device_param->innerloop_pos + il_pos;
2013
2014 if (debug_mode > 0)
2015 {
2016 debug_rule_len = 0;
2017
2018 // save rule
2019 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
2020 {
2021 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
2022
2023 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
2024 }
2025
2026 // save plain
2027 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
2028 {
2029 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
2030
2031 memcpy (debug_plain_ptr, plain_ptr, plain_len);
2032
2033 debug_plain_len = plain_len;
2034 }
2035 }
2036
2037 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2038
2039 crackpos += gidvid;
2040 crackpos *= data.kernel_rules_cnt;
2041 crackpos += device_param->innerloop_pos + il_pos;
2042
2043 if (plain_len > data.pw_max) plain_len = data.pw_max;
2044 }
2045 else if (data.attack_mode == ATTACK_MODE_COMBI)
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 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2059 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2060
2061 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2062 {
2063 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2064 }
2065 else
2066 {
2067 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2068
2069 memcpy (plain_ptr, comb_buf, comb_len);
2070 }
2071
2072 plain_len += comb_len;
2073
2074 crackpos += gidvid;
2075 crackpos *= data.combs_cnt;
2076 crackpos += device_param->innerloop_pos + il_pos;
2077
2078 if (data.pw_max != PW_DICTMAX1)
2079 {
2080 if (plain_len > data.pw_max) plain_len = data.pw_max;
2081 }
2082 }
2083 else if (data.attack_mode == ATTACK_MODE_BF)
2084 {
2085 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2086 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2087
2088 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2089 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2090
2091 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2092 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2093
2094 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2095 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2096
2097 plain_len = data.css_cnt;
2098
2099 crackpos += gidvid;
2100 crackpos *= data.bfs_cnt;
2101 crackpos += device_param->innerloop_pos + il_pos;
2102 }
2103 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2104 {
2105 pw_t pw;
2106
2107 gidd_to_pw_t (device_param, gidvid, &pw);
2108
2109 for (int i = 0; i < 16; i++)
2110 {
2111 plain_buf[i] = pw.i[i];
2112 }
2113
2114 plain_len = pw.pw_len;
2115
2116 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2117
2118 uint start = 0;
2119 uint stop = device_param->kernel_params_mp_buf32[4];
2120
2121 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2122
2123 plain_len += start + stop;
2124
2125 crackpos += gidvid;
2126 crackpos *= data.combs_cnt;
2127 crackpos += device_param->innerloop_pos + il_pos;
2128
2129 if (data.pw_max != PW_DICTMAX1)
2130 {
2131 if (plain_len > data.pw_max) plain_len = data.pw_max;
2132 }
2133 }
2134 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2135 {
2136 pw_t pw;
2137
2138 gidd_to_pw_t (device_param, gidvid, &pw);
2139
2140 for (int i = 0; i < 16; i++)
2141 {
2142 plain_buf[i] = pw.i[i];
2143 }
2144
2145 plain_len = pw.pw_len;
2146
2147 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2148
2149 uint start = 0;
2150 uint stop = device_param->kernel_params_mp_buf32[4];
2151
2152 memmove (plain_ptr + stop, plain_ptr, plain_len);
2153
2154 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2155
2156 plain_len += start + stop;
2157
2158 crackpos += gidvid;
2159 crackpos *= data.combs_cnt;
2160 crackpos += device_param->innerloop_pos + il_pos;
2161
2162 if (data.pw_max != PW_DICTMAX1)
2163 {
2164 if (plain_len > data.pw_max) plain_len = data.pw_max;
2165 }
2166 }
2167
2168 if (data.attack_mode == ATTACK_MODE_BF)
2169 {
2170 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2171 {
2172 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2173 {
2174 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2175 {
2176 plain_len = plain_len - data.salts_buf[0].salt_len;
2177 }
2178 }
2179
2180 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2181 {
2182 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2183 {
2184 plain_ptr[j] = plain_ptr[i];
2185 }
2186
2187 plain_len = plain_len / 2;
2188 }
2189 }
2190 }
2191
2192 // if enabled, update also the potfile
2193
2194 if (pot_fp)
2195 {
2196 lock_file (pot_fp);
2197
2198 fprintf (pot_fp, "%s:", out_buf);
2199
2200 format_plain (pot_fp, plain_ptr, plain_len, 1);
2201
2202 fputc ('\n', pot_fp);
2203
2204 fflush (pot_fp);
2205
2206 unlock_file (pot_fp);
2207 }
2208
2209 // outfile
2210
2211 FILE *out_fp = NULL;
2212
2213 if (outfile != NULL)
2214 {
2215 if ((out_fp = fopen (outfile, "ab")) == NULL)
2216 {
2217 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2218
2219 out_fp = stdout;
2220 }
2221
2222 lock_file (out_fp);
2223 }
2224 else
2225 {
2226 out_fp = stdout;
2227
2228 if (quiet == 0) clear_prompt ();
2229 }
2230
2231 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2232
2233 if (outfile != NULL)
2234 {
2235 if (out_fp != stdout)
2236 {
2237 fclose (out_fp);
2238 }
2239 }
2240 else
2241 {
2242 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2243 {
2244 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2245 {
2246 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2247 if (quiet == 0) fflush (stdout);
2248 }
2249 }
2250 }
2251
2252 // loopback
2253
2254 if (loopback)
2255 {
2256 char *loopback_file = data.loopback_file;
2257
2258 FILE *fb_fp = NULL;
2259
2260 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2261 {
2262 lock_file (fb_fp);
2263
2264 format_plain (fb_fp, plain_ptr, plain_len, 1);
2265
2266 fputc ('\n', fb_fp);
2267
2268 fclose (fb_fp);
2269 }
2270 }
2271
2272 // (rule) debug mode
2273
2274 // the next check implies that:
2275 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2276 // - debug_mode > 0
2277
2278 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2279 {
2280 if (debug_rule_len < 0) debug_rule_len = 0;
2281
2282 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2283
2284 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2285
2286 if ((quiet == 0) && (debug_file == NULL))
2287 {
2288 fprintf (stdout, "%s", PROMPT);
2289
2290 fflush (stdout);
2291 }
2292 }
2293 }
2294
2295 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2296 {
2297 salt_t *salt_buf = &data.salts_buf[salt_pos];
2298
2299 u32 num_cracked;
2300
2301 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2302
2303 if (num_cracked)
2304 {
2305 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2306
2307 log_info_nn ("");
2308
2309 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2310
2311 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);
2312
2313 uint cpt_cracked = 0;
2314
2315 hc_thread_mutex_lock (mux_display);
2316
2317 for (uint i = 0; i < num_cracked; i++)
2318 {
2319 const uint hash_pos = cracked[i].hash_pos;
2320
2321 if (data.digests_shown[hash_pos] == 1) continue;
2322
2323 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2324 {
2325 data.digests_shown[hash_pos] = 1;
2326
2327 data.digests_done++;
2328
2329 cpt_cracked++;
2330
2331 salt_buf->digests_done++;
2332
2333 if (salt_buf->digests_done == salt_buf->digests_cnt)
2334 {
2335 data.salts_shown[salt_pos] = 1;
2336
2337 data.salts_done++;
2338 }
2339 }
2340
2341 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2342
2343 check_hash (device_param, &cracked[i]);
2344 }
2345
2346 hc_thread_mutex_unlock (mux_display);
2347
2348 myfree (cracked);
2349
2350 if (cpt_cracked > 0)
2351 {
2352 hc_thread_mutex_lock (mux_display);
2353
2354 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2355 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2356
2357 data.cpt_pos++;
2358
2359 data.cpt_total += cpt_cracked;
2360
2361 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2362
2363 hc_thread_mutex_unlock (mux_display);
2364 }
2365
2366 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2367 {
2368 // we need to reset cracked state on the device
2369 // otherwise host thinks again and again the hash was cracked
2370 // and returns invalid password each time
2371
2372 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2373
2374 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);
2375 }
2376
2377 num_cracked = 0;
2378
2379 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2380 }
2381 }
2382
2383 // stolen from princeprocessor ;)
2384
2385 typedef struct
2386 {
2387 FILE *fp;
2388
2389 char buf[BUFSIZ];
2390 int len;
2391
2392 } out_t;
2393
2394 static void out_flush (out_t *out)
2395 {
2396 fwrite (out->buf, 1, out->len, out->fp);
2397
2398 out->len = 0;
2399 }
2400
2401 static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
2402 {
2403 char *ptr = out->buf + out->len;
2404
2405 memcpy (ptr, pw_buf, pw_len);
2406
2407 ptr[pw_len] = '\n';
2408
2409 out->len += pw_len + 1;
2410
2411 if (out->len >= BUFSIZ - 100)
2412 {
2413 out_flush (out);
2414 }
2415 }
2416
2417 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2418 {
2419 out_t out;
2420
2421 out.fp = stdout;
2422 out.len = 0;
2423
2424 uint plain_buf[16] = { 0 };
2425
2426 u8 *plain_ptr = (u8 *) plain_buf;
2427
2428 uint plain_len = 0;
2429
2430 const uint il_cnt = device_param->kernel_params_buf32[30]; // ugly, i know
2431
2432 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2433 {
2434 pw_t pw;
2435
2436 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2437 {
2438 gidd_to_pw_t (device_param, gidvid, &pw);
2439
2440 const uint pos = device_param->innerloop_pos;
2441
2442 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2443 {
2444 for (int i = 0; i < 8; i++)
2445 {
2446 plain_buf[i] = pw.i[i];
2447 }
2448
2449 plain_len = pw.pw_len;
2450
2451 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2452
2453 if (plain_len > data.pw_max) plain_len = data.pw_max;
2454
2455 out_push (&out, plain_ptr, plain_len);
2456 }
2457 }
2458 }
2459 else if (data.attack_mode == ATTACK_MODE_COMBI)
2460 {
2461 pw_t pw;
2462
2463 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2464 {
2465 gidd_to_pw_t (device_param, gidvid, &pw);
2466
2467 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2468 {
2469 for (int i = 0; i < 8; i++)
2470 {
2471 plain_buf[i] = pw.i[i];
2472 }
2473
2474 plain_len = pw.pw_len;
2475
2476 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2477 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2478
2479 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2480 {
2481 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2482 }
2483 else
2484 {
2485 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2486
2487 memcpy (plain_ptr, comb_buf, comb_len);
2488 }
2489
2490 plain_len += comb_len;
2491
2492 if (data.pw_max != PW_DICTMAX1)
2493 {
2494 if (plain_len > data.pw_max) plain_len = data.pw_max;
2495 }
2496
2497 out_push (&out, plain_ptr, plain_len);
2498 }
2499 }
2500 }
2501 else if (data.attack_mode == ATTACK_MODE_BF)
2502 {
2503 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2504 {
2505 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2506 {
2507 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2508 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2509
2510 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2511 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2512
2513 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2514 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2515
2516 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2517 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2518
2519 plain_len = data.css_cnt;
2520
2521 out_push (&out, plain_ptr, plain_len);
2522 }
2523 }
2524 }
2525 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2526 {
2527 pw_t pw;
2528
2529 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2530 {
2531 gidd_to_pw_t (device_param, gidvid, &pw);
2532
2533 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2534 {
2535 for (int i = 0; i < 8; i++)
2536 {
2537 plain_buf[i] = pw.i[i];
2538 }
2539
2540 plain_len = pw.pw_len;
2541
2542 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2543
2544 uint start = 0;
2545 uint stop = device_param->kernel_params_mp_buf32[4];
2546
2547 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2548
2549 plain_len += start + stop;
2550
2551 out_push (&out, plain_ptr, plain_len);
2552 }
2553 }
2554 }
2555 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2556 {
2557 pw_t pw;
2558
2559 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2560 {
2561 gidd_to_pw_t (device_param, gidvid, &pw);
2562
2563 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2564 {
2565 for (int i = 0; i < 8; i++)
2566 {
2567 plain_buf[i] = pw.i[i];
2568 }
2569
2570 plain_len = pw.pw_len;
2571
2572 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2573
2574 uint start = 0;
2575 uint stop = device_param->kernel_params_mp_buf32[4];
2576
2577 memmove (plain_ptr + stop, plain_ptr, plain_len);
2578
2579 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2580
2581 plain_len += start + stop;
2582
2583 out_push (&out, plain_ptr, plain_len);
2584 }
2585 }
2586 }
2587
2588 out_flush (&out);
2589 }
2590
2591 static void save_hash ()
2592 {
2593 char *hashfile = data.hashfile;
2594
2595 char new_hashfile[256] = { 0 };
2596 char old_hashfile[256] = { 0 };
2597
2598 snprintf (new_hashfile, 255, "%s.new", hashfile);
2599 snprintf (old_hashfile, 255, "%s.old", hashfile);
2600
2601 unlink (new_hashfile);
2602
2603 char separator = data.separator;
2604
2605 FILE *fp = fopen (new_hashfile, "wb");
2606
2607 if (fp == NULL)
2608 {
2609 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2610
2611 exit (-1);
2612 }
2613
2614 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2615 {
2616 if (data.salts_shown[salt_pos] == 1) continue;
2617
2618 salt_t *salt_buf = &data.salts_buf[salt_pos];
2619
2620 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2621 {
2622 uint idx = salt_buf->digests_offset + digest_pos;
2623
2624 if (data.digests_shown[idx] == 1) continue;
2625
2626 if (data.hash_mode != 2500)
2627 {
2628 if (data.username == 1)
2629 {
2630 user_t *user = data.hash_info[idx]->user;
2631
2632 uint i;
2633
2634 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2635
2636 fputc (separator, fp);
2637 }
2638
2639 char out_buf[HCBUFSIZ]; // scratch buffer
2640
2641 out_buf[0] = 0;
2642
2643 ascii_digest (out_buf, salt_pos, digest_pos);
2644
2645 fputs (out_buf, fp);
2646
2647 fputc ('\n', fp);
2648 }
2649 else
2650 {
2651 hccap_t hccap;
2652
2653 to_hccap_t (&hccap, salt_pos, digest_pos);
2654
2655 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2656 }
2657 }
2658 }
2659
2660 fflush (fp);
2661
2662 fclose (fp);
2663
2664 unlink (old_hashfile);
2665
2666 if (rename (hashfile, old_hashfile) != 0)
2667 {
2668 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2669
2670 exit (-1);
2671 }
2672
2673 unlink (hashfile);
2674
2675 if (rename (new_hashfile, hashfile) != 0)
2676 {
2677 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2678
2679 exit (-1);
2680 }
2681
2682 unlink (old_hashfile);
2683 }
2684
2685 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2686 {
2687 uint num_elements = num;
2688
2689 device_param->kernel_params_buf32[33] = data.combs_mode;
2690 device_param->kernel_params_buf32[34] = num;
2691
2692 uint kernel_threads = device_param->kernel_threads;
2693
2694 while (num_elements % kernel_threads) num_elements++;
2695
2696 cl_kernel kernel = NULL;
2697
2698 switch (kern_run)
2699 {
2700 case KERN_RUN_1: kernel = device_param->kernel1; break;
2701 case KERN_RUN_12: kernel = device_param->kernel12; break;
2702 case KERN_RUN_2: kernel = device_param->kernel2; break;
2703 case KERN_RUN_23: kernel = device_param->kernel23; break;
2704 case KERN_RUN_3: kernel = device_param->kernel3; break;
2705 }
2706
2707 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2708 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2709 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2710 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2711 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2712 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2713 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2714 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2715 hc_clSetKernelArg (data.ocl, kernel, 32, sizeof (cl_uint), device_param->kernel_params[32]);
2716 hc_clSetKernelArg (data.ocl, kernel, 33, sizeof (cl_uint), device_param->kernel_params[33]);
2717 hc_clSetKernelArg (data.ocl, kernel, 34, sizeof (cl_uint), device_param->kernel_params[34]);
2718
2719 cl_event event;
2720
2721 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2722 {
2723 const size_t global_work_size[3] = { num_elements, 32, 1 };
2724 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2725
2726 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2727 }
2728 else
2729 {
2730 if (kern_run == KERN_RUN_2)
2731 {
2732 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2733 {
2734 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2735 }
2736 }
2737
2738 while (num_elements % kernel_threads) num_elements++;
2739
2740 const size_t global_work_size[3] = { num_elements, 1, 1 };
2741 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2742
2743 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2744 }
2745
2746 hc_clFlush (data.ocl, device_param->command_queue);
2747
2748 if (device_param->nvidia_spin_damp)
2749 {
2750 if (data.devices_status == STATUS_RUNNING)
2751 {
2752 if (iteration < EXPECTED_ITERATIONS)
2753 {
2754 switch (kern_run)
2755 {
2756 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2757 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2758 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2759 }
2760 }
2761 }
2762 }
2763
2764 hc_clWaitForEvents (data.ocl, 1, &event);
2765
2766 cl_ulong time_start;
2767 cl_ulong time_end;
2768
2769 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2770 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2771
2772 const double exec_us = (double) (time_end - time_start) / 1000;
2773
2774 if (data.devices_status == STATUS_RUNNING)
2775 {
2776 if (iteration < EXPECTED_ITERATIONS)
2777 {
2778 switch (kern_run)
2779 {
2780 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2781 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2782 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2783 }
2784 }
2785 }
2786
2787 if (event_update)
2788 {
2789 uint exec_pos = device_param->exec_pos;
2790
2791 device_param->exec_ms[exec_pos] = exec_us / 1000;
2792
2793 exec_pos++;
2794
2795 if (exec_pos == EXEC_CACHE)
2796 {
2797 exec_pos = 0;
2798 }
2799
2800 device_param->exec_pos = exec_pos;
2801 }
2802
2803 hc_clReleaseEvent (data.ocl, event);
2804
2805 hc_clFinish (data.ocl, device_param->command_queue);
2806 }
2807
2808 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2809 {
2810 uint num_elements = num;
2811
2812 switch (kern_run)
2813 {
2814 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2815 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2816 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2817 }
2818
2819 // causes problems with special threads like in bcrypt
2820 // const uint kernel_threads = device_param->kernel_threads;
2821
2822 uint kernel_threads = device_param->kernel_threads;
2823
2824 while (num_elements % kernel_threads) num_elements++;
2825
2826 cl_kernel kernel = NULL;
2827
2828 switch (kern_run)
2829 {
2830 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2831 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2832 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2833 }
2834
2835 switch (kern_run)
2836 {
2837 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2838 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2839 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2840 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2841 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2842 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2843 break;
2844 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2845 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2846 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2847 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2848 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2849 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2850 break;
2851 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2852 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2853 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2854 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2855 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2856 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2857 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2858 break;
2859 }
2860
2861 const size_t global_work_size[3] = { num_elements, 1, 1 };
2862 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2863
2864 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2865
2866 hc_clFlush (data.ocl, device_param->command_queue);
2867
2868 hc_clFinish (data.ocl, device_param->command_queue);
2869 }
2870
2871 static void run_kernel_tm (hc_device_param_t *device_param)
2872 {
2873 const uint num_elements = 1024; // fixed
2874
2875 uint kernel_threads = 32;
2876
2877 cl_kernel kernel = device_param->kernel_tm;
2878
2879 const size_t global_work_size[3] = { num_elements, 1, 1 };
2880 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2881
2882 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2883
2884 hc_clFlush (data.ocl, device_param->command_queue);
2885
2886 hc_clFinish (data.ocl, device_param->command_queue);
2887 }
2888
2889 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2890 {
2891 uint num_elements = num;
2892
2893 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2894 device_param->kernel_params_amp_buf32[6] = num_elements;
2895
2896 // causes problems with special threads like in bcrypt
2897 // const uint kernel_threads = device_param->kernel_threads;
2898
2899 uint kernel_threads = device_param->kernel_threads;
2900
2901 while (num_elements % kernel_threads) num_elements++;
2902
2903 cl_kernel kernel = device_param->kernel_amp;
2904
2905 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2906 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2907
2908 const size_t global_work_size[3] = { num_elements, 1, 1 };
2909 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2910
2911 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2912
2913 hc_clFlush (data.ocl, device_param->command_queue);
2914
2915 hc_clFinish (data.ocl, device_param->command_queue);
2916 }
2917
2918 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2919 {
2920 const u32 num16d = num / 16;
2921 const u32 num16m = num % 16;
2922
2923 if (num16d)
2924 {
2925 device_param->kernel_params_memset_buf32[1] = value;
2926 device_param->kernel_params_memset_buf32[2] = num16d;
2927
2928 uint kernel_threads = device_param->kernel_threads;
2929
2930 uint num_elements = num16d;
2931
2932 while (num_elements % kernel_threads) num_elements++;
2933
2934 cl_kernel kernel = device_param->kernel_memset;
2935
2936 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2937 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2938 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2939
2940 const size_t global_work_size[3] = { num_elements, 1, 1 };
2941 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2942
2943 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2944
2945 hc_clFlush (data.ocl, device_param->command_queue);
2946
2947 hc_clFinish (data.ocl, device_param->command_queue);
2948 }
2949
2950 if (num16m)
2951 {
2952 u32 tmp[4];
2953
2954 tmp[0] = value;
2955 tmp[1] = value;
2956 tmp[2] = value;
2957 tmp[3] = value;
2958
2959 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2960 }
2961 }
2962
2963 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2964 {
2965 run_kernel_memset (device_param, buf, 0, size);
2966
2967 /*
2968 int rc = -1;
2969
2970 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2971 {
2972 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2973
2974 const cl_uchar zero = 0;
2975
2976 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2977 }
2978
2979 if (rc != 0)
2980 {
2981 // NOTE: clEnqueueFillBuffer () always fails with -59
2982 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2983 // How's that possible, OpenCL 1.2 support is advertised??
2984 // We need to workaround...
2985
2986 #define FILLSZ 0x100000
2987
2988 char *tmp = (char *) mymalloc (FILLSZ);
2989
2990 for (size_t i = 0; i < size; i += FILLSZ)
2991 {
2992 const size_t left = size - i;
2993
2994 const size_t fillsz = MIN (FILLSZ, left);
2995
2996 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2997 }
2998
2999 myfree (tmp);
3000 }
3001 */
3002 }
3003
3004 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, const uint fast_iteration)
3005 {
3006 if (data.hash_mode == 2000)
3007 {
3008 process_stdout (device_param, pws_cnt);
3009
3010 return;
3011 }
3012
3013 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3014 {
3015 if (attack_mode == ATTACK_MODE_BF)
3016 {
3017 if (opts_type & OPTS_TYPE_PT_BITSLICE)
3018 {
3019 const uint size_tm = 32 * sizeof (bs_word_t);
3020
3021 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
3022
3023 run_kernel_tm (device_param);
3024
3025 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);
3026 }
3027 }
3028
3029 if (highest_pw_len < 16)
3030 {
3031 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
3032 }
3033 else if (highest_pw_len < 32)
3034 {
3035 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
3036 }
3037 else
3038 {
3039 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
3040 }
3041 }
3042 else
3043 {
3044 run_kernel_amp (device_param, pws_cnt);
3045
3046 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
3047
3048 if (opts_type & OPTS_TYPE_HOOK12)
3049 {
3050 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
3051
3052 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);
3053
3054 // do something with data
3055
3056 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);
3057 }
3058
3059 uint iter = salt_buf->salt_iter;
3060
3061 uint loop_step = device_param->kernel_loops;
3062
3063 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
3064 {
3065 uint loop_left = iter - loop_pos;
3066
3067 loop_left = MIN (loop_left, loop_step);
3068
3069 device_param->kernel_params_buf32[28] = loop_pos;
3070 device_param->kernel_params_buf32[29] = loop_left;
3071
3072 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
3073
3074 if (data.devices_status == STATUS_CRACKED) break;
3075 if (data.devices_status == STATUS_ABORTED) break;
3076 if (data.devices_status == STATUS_QUIT) break;
3077 if (data.devices_status == STATUS_BYPASS) break;
3078
3079 /**
3080 * speed
3081 */
3082
3083 const float iter_part = (float) (loop_pos + loop_left) / iter;
3084
3085 const u64 perf_sum_all = pws_cnt * iter_part;
3086
3087 double speed_ms;
3088
3089 hc_timer_get (device_param->timer_speed, speed_ms);
3090
3091 const u32 speed_pos = device_param->speed_pos;
3092
3093 device_param->speed_cnt[speed_pos] = perf_sum_all;
3094
3095 device_param->speed_ms[speed_pos] = speed_ms;
3096
3097 if (data.benchmark == 1)
3098 {
3099 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3100 }
3101 }
3102
3103 if (opts_type & OPTS_TYPE_HOOK23)
3104 {
3105 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3106
3107 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);
3108
3109 // do something with data
3110
3111 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);
3112 }
3113
3114 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3115 }
3116 }
3117
3118 static int run_rule_engine (const int rule_len, const char *rule_buf)
3119 {
3120 if (rule_len == 0)
3121 {
3122 return 0;
3123 }
3124 else if (rule_len == 1)
3125 {
3126 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3127 }
3128
3129 return 1;
3130 }
3131
3132 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3133 {
3134 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3135 {
3136 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);
3137 }
3138 else if (data.attack_kern == ATTACK_KERN_COMBI)
3139 {
3140 if (data.attack_mode == ATTACK_MODE_COMBI)
3141 {
3142 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3143 {
3144 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3145 {
3146 for (u32 i = 0; i < pws_cnt; i++)
3147 {
3148 const u32 pw_len = device_param->pws_buf[i].pw_len;
3149
3150 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3151
3152 ptr[pw_len] = 0x01;
3153 }
3154 }
3155 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3156 {
3157 for (u32 i = 0; i < pws_cnt; i++)
3158 {
3159 const u32 pw_len = device_param->pws_buf[i].pw_len;
3160
3161 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3162
3163 ptr[pw_len] = 0x80;
3164 }
3165 }
3166 }
3167 }
3168 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3169 {
3170 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3171 {
3172 for (u32 i = 0; i < pws_cnt; i++)
3173 {
3174 const u32 pw_len = device_param->pws_buf[i].pw_len;
3175
3176 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3177
3178 ptr[pw_len] = 0x01;
3179 }
3180 }
3181 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3182 {
3183 for (u32 i = 0; i < pws_cnt; i++)
3184 {
3185 const u32 pw_len = device_param->pws_buf[i].pw_len;
3186
3187 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3188
3189 ptr[pw_len] = 0x80;
3190 }
3191 }
3192 }
3193
3194 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);
3195 }
3196 else if (data.attack_kern == ATTACK_KERN_BF)
3197 {
3198 const u64 off = device_param->words_off;
3199
3200 device_param->kernel_params_mp_l_buf64[3] = off;
3201
3202 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3203 }
3204 }
3205
3206 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3207 {
3208 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3209
3210 device_param->kernel_params_buf32[28] = 0;
3211 device_param->kernel_params_buf32[29] = kernel_loops; // not a bug, both need to be set
3212 device_param->kernel_params_buf32[30] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3213
3214 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3215 {
3216 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3217 }
3218 else
3219 {
3220 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3221 }
3222
3223 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3224
3225 return exec_ms_prev;
3226 }
3227
3228 static void autotune (hc_device_param_t *device_param)
3229 {
3230 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3231
3232 const u32 kernel_accel_min = device_param->kernel_accel_min;
3233 const u32 kernel_accel_max = device_param->kernel_accel_max;
3234
3235 const u32 kernel_loops_min = device_param->kernel_loops_min;
3236 const u32 kernel_loops_max = device_param->kernel_loops_max;
3237
3238 u32 kernel_accel = kernel_accel_min;
3239 u32 kernel_loops = kernel_loops_min;
3240
3241 // in this case the user specified a fixed -u and -n on the commandline
3242 // no way to tune anything
3243 // but we need to run a few caching rounds
3244
3245 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3246 {
3247 if (data.hash_mode != 2000)
3248 {
3249 try_run (device_param, kernel_accel, kernel_loops);
3250 try_run (device_param, kernel_accel, kernel_loops);
3251 try_run (device_param, kernel_accel, kernel_loops);
3252 try_run (device_param, kernel_accel, kernel_loops);
3253 }
3254
3255 device_param->kernel_accel = kernel_accel;
3256 device_param->kernel_loops = kernel_loops;
3257
3258 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3259
3260 device_param->kernel_power = kernel_power;
3261
3262 return;
3263 }
3264
3265 // from here it's clear we are allowed to autotune
3266 // so let's init some fake words
3267
3268 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3269
3270 if (data.attack_kern == ATTACK_KERN_BF)
3271 {
3272 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3273 }
3274 else
3275 {
3276 for (u32 i = 0; i < kernel_power_max; i++)
3277 {
3278 device_param->pws_buf[i].i[0] = i;
3279 device_param->pws_buf[i].i[1] = 0x01234567;
3280 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3281 }
3282
3283 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);
3284 }
3285
3286 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3287 {
3288 if (data.kernel_rules_cnt > 1)
3289 {
3290 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, 0, 0, MIN (kernel_loops_max, KERNEL_RULES) * sizeof (kernel_rule_t), 0, NULL, NULL);
3291 }
3292 }
3293 else
3294 {
3295 run_kernel_amp (device_param, kernel_power_max);
3296 }
3297
3298 #define VERIFIER_CNT 1
3299
3300 // first find out highest kernel-loops that stays below target_ms
3301
3302 if (kernel_loops_min < kernel_loops_max)
3303 {
3304 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3305 {
3306 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3307
3308 for (int i = 0; i < VERIFIER_CNT; i++)
3309 {
3310 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3311
3312 exec_ms = MIN (exec_ms, exec_ms_v);
3313 }
3314
3315 if (exec_ms < target_ms) break;
3316 }
3317 }
3318
3319 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3320
3321 #define STEPS_CNT 10
3322
3323 if (kernel_accel_min < kernel_accel_max)
3324 {
3325 for (int i = 0; i < STEPS_CNT; i++)
3326 {
3327 const u32 kernel_accel_try = 1 << i;
3328
3329 if (kernel_accel_try < kernel_accel_min) continue;
3330 if (kernel_accel_try > kernel_accel_max) break;
3331
3332 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3333
3334 for (int i = 0; i < VERIFIER_CNT; i++)
3335 {
3336 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3337
3338 exec_ms = MIN (exec_ms, exec_ms_v);
3339 }
3340
3341 if (exec_ms > target_ms) break;
3342
3343 kernel_accel = kernel_accel_try;
3344 }
3345 }
3346
3347 // at this point we want to know the actual runtime for the following reason:
3348 // we need a reference for the balancing loop following up, and this
3349 // the balancing loop can have an effect that the creates a new opportunity, for example:
3350 // if the target is 95 ms and the current runtime is 48ms the above loop
3351 // stopped the execution because the previous exec_ms was > 95ms
3352 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3353 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3354
3355 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3356
3357 for (int i = 0; i < VERIFIER_CNT; i++)
3358 {
3359 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3360
3361 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3362 }
3363
3364 u32 diff = kernel_loops - kernel_accel;
3365
3366 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3367 {
3368 u32 kernel_accel_orig = kernel_accel;
3369 u32 kernel_loops_orig = kernel_loops;
3370
3371 for (u32 f = 1; f < 1024; f++)
3372 {
3373 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3374 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3375
3376 if (kernel_accel_try > kernel_accel_max) break;
3377 if (kernel_loops_try < kernel_loops_min) break;
3378
3379 u32 diff_new = kernel_loops_try - kernel_accel_try;
3380
3381 if (diff_new > diff) break;
3382
3383 diff_new = diff;
3384
3385 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3386
3387 for (int i = 0; i < VERIFIER_CNT; i++)
3388 {
3389 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3390
3391 exec_ms = MIN (exec_ms, exec_ms_v);
3392 }
3393
3394 if (exec_ms < exec_ms_pre_final)
3395 {
3396 exec_ms_pre_final = exec_ms;
3397
3398 kernel_accel = kernel_accel_try;
3399 kernel_loops = kernel_loops_try;
3400 }
3401 }
3402 }
3403
3404 const double exec_left = target_ms / exec_ms_pre_final;
3405
3406 const double accel_left = kernel_accel_max / kernel_accel;
3407
3408 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3409
3410 if (exec_accel_min >= 1.0)
3411 {
3412 // this is safe to not overflow kernel_accel_max because of accel_left
3413
3414 kernel_accel = (double) kernel_accel * exec_accel_min;
3415 }
3416
3417 // reset them fake words
3418
3419 /*
3420 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3421
3422 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);
3423 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);
3424 */
3425
3426 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3427
3428 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3429 {
3430 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3431 }
3432
3433 // reset timer
3434
3435 device_param->exec_pos = 0;
3436
3437 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3438
3439 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3440 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3441 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3442
3443 // store
3444
3445 device_param->kernel_accel = kernel_accel;
3446 device_param->kernel_loops = kernel_loops;
3447
3448 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3449
3450 device_param->kernel_power = kernel_power;
3451
3452 #ifdef DEBUG
3453
3454 if (data.quiet == 0)
3455 {
3456 clear_prompt ();
3457
3458 log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3459 "- Device #%u: autotuned kernel-loops to %u\n",
3460 device_param->device_id + 1, kernel_accel,
3461 device_param->device_id + 1, kernel_loops);
3462
3463 fprintf (stdout, "%s", PROMPT);
3464
3465 fflush (stdout);
3466 }
3467
3468 #endif
3469 }
3470
3471 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3472 {
3473 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3474
3475 // init speed timer
3476
3477 uint speed_pos = device_param->speed_pos;
3478
3479 #ifdef _POSIX
3480 if (device_param->timer_speed.tv_sec == 0)
3481 {
3482 hc_timer_set (&device_param->timer_speed);
3483 }
3484 #endif
3485
3486 #ifdef _WIN
3487 if (device_param->timer_speed.QuadPart == 0)
3488 {
3489 hc_timer_set (&device_param->timer_speed);
3490 }
3491 #endif
3492
3493 // find higest password length, this is for optimization stuff
3494
3495 uint highest_pw_len = 0;
3496
3497 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3498 {
3499 }
3500 else if (data.attack_kern == ATTACK_KERN_COMBI)
3501 {
3502 }
3503 else if (data.attack_kern == ATTACK_KERN_BF)
3504 {
3505 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3506 + device_param->kernel_params_mp_l_buf32[5];
3507 }
3508
3509 // iteration type
3510
3511 uint innerloop_step = 0;
3512 uint innerloop_cnt = 0;
3513
3514 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3515 else innerloop_step = 1;
3516
3517 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3518 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3519 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3520
3521 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3522
3523 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3524 {
3525 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3526
3527 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3528
3529 if (data.devices_status == STATUS_CRACKED) break;
3530 if (data.devices_status == STATUS_ABORTED) break;
3531 if (data.devices_status == STATUS_QUIT) break;
3532 if (data.devices_status == STATUS_BYPASS) break;
3533
3534 salt_t *salt_buf = &data.salts_buf[salt_pos];
3535
3536 device_param->kernel_params_buf32[27] = salt_pos;
3537 device_param->kernel_params_buf32[31] = salt_buf->digests_cnt;
3538 device_param->kernel_params_buf32[32] = salt_buf->digests_offset;
3539
3540 FILE *combs_fp = device_param->combs_fp;
3541
3542 if (data.attack_mode == ATTACK_MODE_COMBI)
3543 {
3544 rewind (combs_fp);
3545 }
3546
3547 // innerloops
3548
3549 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3550 {
3551 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3552
3553 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3554
3555 if (data.devices_status == STATUS_CRACKED) break;
3556 if (data.devices_status == STATUS_ABORTED) break;
3557 if (data.devices_status == STATUS_QUIT) break;
3558 if (data.devices_status == STATUS_BYPASS) break;
3559
3560 uint fast_iteration = 0;
3561
3562 uint innerloop_left = innerloop_cnt - innerloop_pos;
3563
3564 if (innerloop_left > innerloop_step)
3565 {
3566 innerloop_left = innerloop_step;
3567
3568 fast_iteration = 1;
3569 }
3570
3571 device_param->innerloop_pos = innerloop_pos;
3572 device_param->innerloop_left = innerloop_left;
3573
3574 device_param->kernel_params_buf32[30] = innerloop_left;
3575
3576 // i think we can get rid of this
3577 if (innerloop_left == 0)
3578 {
3579 puts ("bug, how should this happen????\n");
3580
3581 continue;
3582 }
3583
3584 if (data.salts_shown[salt_pos] == 1)
3585 {
3586 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3587
3588 continue;
3589 }
3590
3591 // initialize amplifiers
3592
3593 if (data.attack_mode == ATTACK_MODE_COMBI)
3594 {
3595 uint i = 0;
3596
3597 while (i < innerloop_left)
3598 {
3599 if (feof (combs_fp)) break;
3600
3601 int line_len = fgetl (combs_fp, line_buf);
3602
3603 if (line_len >= PW_MAX1) continue;
3604
3605 line_len = convert_from_hex (line_buf, line_len);
3606
3607 char *line_buf_new = line_buf;
3608
3609 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3610 {
3611 char rule_buf_out[BLOCK_SIZE] = { 0 };
3612
3613 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3614
3615 if (rule_len_out < 0)
3616 {
3617 data.words_progress_rejected[salt_pos] += pws_cnt;
3618
3619 continue;
3620 }
3621
3622 line_len = rule_len_out;
3623
3624 line_buf_new = rule_buf_out;
3625 }
3626
3627 line_len = MIN (line_len, PW_DICTMAX);
3628
3629 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3630
3631 memcpy (ptr, line_buf_new, line_len);
3632
3633 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3634
3635 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3636 {
3637 uppercase (ptr, line_len);
3638 }
3639
3640 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3641 {
3642 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3643 {
3644 ptr[line_len] = 0x80;
3645 }
3646
3647 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3648 {
3649 ptr[line_len] = 0x01;
3650 }
3651 }
3652
3653 device_param->combs_buf[i].pw_len = line_len;
3654
3655 i++;
3656 }
3657
3658 for (uint j = i; j < innerloop_left; j++)
3659 {
3660 device_param->combs_buf[j].i[0] = 0;
3661 device_param->combs_buf[j].i[1] = 0;
3662 device_param->combs_buf[j].i[2] = 0;
3663 device_param->combs_buf[j].i[3] = 0;
3664 device_param->combs_buf[j].i[4] = 0;
3665 device_param->combs_buf[j].i[5] = 0;
3666 device_param->combs_buf[j].i[6] = 0;
3667 device_param->combs_buf[j].i[7] = 0;
3668
3669 device_param->combs_buf[j].pw_len = 0;
3670 }
3671
3672 innerloop_left = i;
3673 }
3674 else if (data.attack_mode == ATTACK_MODE_BF)
3675 {
3676 u64 off = innerloop_pos;
3677
3678 device_param->kernel_params_mp_r_buf64[3] = off;
3679
3680 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3681 }
3682 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3683 {
3684 u64 off = innerloop_pos;
3685
3686 device_param->kernel_params_mp_buf64[3] = off;
3687
3688 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3689 }
3690 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3691 {
3692 u64 off = innerloop_pos;
3693
3694 device_param->kernel_params_mp_buf64[3] = off;
3695
3696 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3697 }
3698
3699 // copy amplifiers
3700
3701 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3702 {
3703 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);
3704 }
3705 else if (data.attack_mode == ATTACK_MODE_COMBI)
3706 {
3707 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);
3708 }
3709 else if (data.attack_mode == ATTACK_MODE_BF)
3710 {
3711 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);
3712 }
3713 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3714 {
3715 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);
3716 }
3717 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3718 {
3719 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);
3720 }
3721
3722 if (data.benchmark == 1)
3723 {
3724 hc_timer_set (&device_param->timer_speed);
3725 }
3726
3727 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3728
3729 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3730
3731 if (data.devices_status == STATUS_CRACKED) break;
3732 if (data.devices_status == STATUS_ABORTED) break;
3733 if (data.devices_status == STATUS_QUIT) break;
3734 if (data.devices_status == STATUS_BYPASS) break;
3735
3736 /**
3737 * result
3738 */
3739
3740 if (data.benchmark == 0)
3741 {
3742 check_cracked (device_param, salt_pos);
3743 }
3744
3745 /**
3746 * progress
3747 */
3748
3749 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3750
3751 hc_thread_mutex_lock (mux_counter);
3752
3753 data.words_progress_done[salt_pos] += perf_sum_all;
3754
3755 hc_thread_mutex_unlock (mux_counter);
3756
3757 /**
3758 * speed
3759 */
3760
3761 double speed_ms;
3762
3763 hc_timer_get (device_param->timer_speed, speed_ms);
3764
3765 hc_timer_set (&device_param->timer_speed);
3766
3767 // current speed
3768
3769 //hc_thread_mutex_lock (mux_display);
3770
3771 device_param->speed_cnt[speed_pos] = perf_sum_all;
3772
3773 device_param->speed_ms[speed_pos] = speed_ms;
3774
3775 //hc_thread_mutex_unlock (mux_display);
3776
3777 speed_pos++;
3778
3779 if (speed_pos == SPEED_CACHE)
3780 {
3781 speed_pos = 0;
3782 }
3783
3784 /**
3785 * benchmark
3786 */
3787
3788 if (data.benchmark == 1) break;
3789 }
3790 }
3791
3792 device_param->speed_pos = speed_pos;
3793
3794 myfree (line_buf);
3795 }
3796
3797 static void load_segment (wl_data_t *wl_data, FILE *fd)
3798 {
3799 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3800
3801 wl_data->pos = 0;
3802
3803 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3804
3805 wl_data->buf[wl_data->cnt] = 0;
3806
3807 if (wl_data->cnt == 0) return;
3808
3809 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3810
3811 while (!feof (fd))
3812 {
3813 if (wl_data->cnt == wl_data->avail)
3814 {
3815 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3816
3817 wl_data->avail += wl_data->incr;
3818 }
3819
3820 const int c = fgetc (fd);
3821
3822 if (c == EOF) break;
3823
3824 wl_data->buf[wl_data->cnt] = (char) c;
3825
3826 wl_data->cnt++;
3827
3828 if (c == '\n') break;
3829 }
3830
3831 // ensure stream ends with a newline
3832
3833 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3834 {
3835 wl_data->cnt++;
3836
3837 wl_data->buf[wl_data->cnt - 1] = '\n';
3838 }
3839
3840 return;
3841 }
3842
3843 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3844 {
3845 char *ptr = buf;
3846
3847 for (u32 i = 0; i < sz; i++, ptr++)
3848 {
3849 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3850
3851 if (i == 7)
3852 {
3853 *off = i;
3854 *len = i;
3855
3856 return;
3857 }
3858
3859 if (*ptr != '\n') continue;
3860
3861 *off = i + 1;
3862
3863 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3864
3865 *len = i;
3866
3867 return;
3868 }
3869
3870 *off = sz;
3871 *len = sz;
3872 }
3873
3874 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3875 {
3876 char *ptr = buf;
3877
3878 for (u32 i = 0; i < sz; i++, ptr++)
3879 {
3880 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3881
3882 if (*ptr != '\n') continue;
3883
3884 *off = i + 1;
3885
3886 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3887
3888 *len = i;
3889
3890 return;
3891 }
3892
3893 *off = sz;
3894 *len = sz;
3895 }
3896
3897 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3898 {
3899 char *ptr = buf;
3900
3901 for (u32 i = 0; i < sz; i++, ptr++)
3902 {
3903 if (*ptr != '\n') continue;
3904
3905 *off = i + 1;
3906
3907 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3908
3909 *len = i;
3910
3911 return;
3912 }
3913
3914 *off = sz;
3915 *len = sz;
3916 }
3917
3918 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3919 {
3920 while (wl_data->pos < wl_data->cnt)
3921 {
3922 uint off;
3923 uint len;
3924
3925 char *ptr = wl_data->buf + wl_data->pos;
3926
3927 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3928
3929 wl_data->pos += off;
3930
3931 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3932 {
3933 char rule_buf_out[BLOCK_SIZE] = { 0 };
3934
3935 int rule_len_out = -1;
3936
3937 if (len < BLOCK_SIZE)
3938 {
3939 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3940 }
3941
3942 if (rule_len_out < 0)
3943 {
3944 continue;
3945 }
3946
3947 if (rule_len_out > PW_MAX)
3948 {
3949 continue;
3950 }
3951 }
3952 else
3953 {
3954 if (len > PW_MAX)
3955 {
3956 continue;
3957 }
3958 }
3959
3960 *out_buf = ptr;
3961 *out_len = len;
3962
3963 return;
3964 }
3965
3966 if (feof (fd))
3967 {
3968 fprintf (stderr, "BUG feof()!!\n");
3969
3970 return;
3971 }
3972
3973 load_segment (wl_data, fd);
3974
3975 get_next_word (wl_data, fd, out_buf, out_len);
3976 }
3977
3978 #ifdef _POSIX
3979 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3980 #endif
3981
3982 #ifdef _WIN
3983 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3984 #endif
3985 {
3986 hc_signal (NULL);
3987
3988 dictstat_t d;
3989
3990 d.cnt = 0;
3991
3992 #ifdef _POSIX
3993 fstat (fileno (fd), &d.stat);
3994 #endif
3995
3996 #ifdef _WIN
3997 _fstat64 (fileno (fd), &d.stat);
3998 #endif
3999
4000 d.stat.st_mode = 0;
4001 d.stat.st_nlink = 0;
4002 d.stat.st_uid = 0;
4003 d.stat.st_gid = 0;
4004 d.stat.st_rdev = 0;
4005 d.stat.st_atime = 0;
4006
4007 #ifdef _POSIX
4008 d.stat.st_blksize = 0;
4009 d.stat.st_blocks = 0;
4010 #endif
4011
4012 if (d.stat.st_size == 0) return 0;
4013
4014 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4015
4016 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
4017 {
4018 if (d_cache)
4019 {
4020 u64 cnt = d_cache->cnt;
4021
4022 u64 keyspace = cnt;
4023
4024 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4025 {
4026 keyspace *= data.kernel_rules_cnt;
4027 }
4028 else if (data.attack_kern == ATTACK_KERN_COMBI)
4029 {
4030 keyspace *= data.combs_cnt;
4031 }
4032
4033 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);
4034 if (data.quiet == 0) log_info ("");
4035
4036 hc_signal (sigHandler_default);
4037
4038 return (keyspace);
4039 }
4040 }
4041
4042 time_t now = 0;
4043 time_t prev = 0;
4044
4045 u64 comp = 0;
4046 u64 cnt = 0;
4047 u64 cnt2 = 0;
4048
4049 while (!feof (fd))
4050 {
4051 load_segment (wl_data, fd);
4052
4053 comp += wl_data->cnt;
4054
4055 u32 i = 0;
4056
4057 while (i < wl_data->cnt)
4058 {
4059 u32 len;
4060 u32 off;
4061
4062 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
4063
4064 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4065 {
4066 char rule_buf_out[BLOCK_SIZE] = { 0 };
4067
4068 int rule_len_out = -1;
4069
4070 if (len < BLOCK_SIZE)
4071 {
4072 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
4073 }
4074
4075 if (rule_len_out < 0)
4076 {
4077 len = PW_MAX1;
4078 }
4079 else
4080 {
4081 len = rule_len_out;
4082 }
4083 }
4084
4085 if (len < PW_MAX1)
4086 {
4087 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4088 {
4089 cnt += data.kernel_rules_cnt;
4090 }
4091 else if (data.attack_kern == ATTACK_KERN_COMBI)
4092 {
4093 cnt += data.combs_cnt;
4094 }
4095
4096 d.cnt++;
4097 }
4098
4099 i += off;
4100
4101 cnt2++;
4102 }
4103
4104 time (&now);
4105
4106 if ((now - prev) == 0) continue;
4107
4108 float percent = (float) comp / (float) d.stat.st_size;
4109
4110 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);
4111
4112 time (&prev);
4113 }
4114
4115 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);
4116 if (data.quiet == 0) log_info ("");
4117
4118 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4119
4120 hc_signal (sigHandler_default);
4121
4122 return (cnt);
4123 }
4124
4125 static void *thread_monitor (void *p)
4126 {
4127 uint runtime_check = 0;
4128 uint remove_check = 0;
4129 uint status_check = 0;
4130 uint restore_check = 0;
4131
4132 uint restore_left = data.restore_timer;
4133 uint remove_left = data.remove_timer;
4134 uint status_left = data.status_timer;
4135
4136 #ifdef HAVE_HWMON
4137 uint hwmon_check = 0;
4138
4139 int slowdown_warnings = 0;
4140
4141 // these variables are mainly used for fan control
4142
4143 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4144
4145 // temperature controller "loopback" values
4146
4147 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4148 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4149
4150 int temp_threshold = 1; // degrees celcius
4151
4152 int fan_speed_min = 15; // in percentage
4153 int fan_speed_max = 100;
4154
4155 time_t last_temp_check_time;
4156 #endif // HAVE_HWMON
4157
4158 uint sleep_time = 1;
4159
4160 if (data.runtime)
4161 {
4162 runtime_check = 1;
4163 }
4164
4165 if (data.restore_timer)
4166 {
4167 restore_check = 1;
4168 }
4169
4170 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4171 {
4172 remove_check = 1;
4173 }
4174
4175 if (data.status == 1)
4176 {
4177 status_check = 1;
4178 }
4179
4180 #ifdef HAVE_HWMON
4181 if (data.gpu_temp_disable == 0)
4182 {
4183 time (&last_temp_check_time);
4184
4185 hwmon_check = 1;
4186 }
4187 #endif
4188
4189 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4190 {
4191 #ifdef HAVE_HWMON
4192 if (hwmon_check == 0)
4193 #endif
4194 return (p);
4195 }
4196
4197 while (data.shutdown_inner == 0)
4198 {
4199 hc_sleep (sleep_time);
4200
4201 if (data.devices_status != STATUS_RUNNING) continue;
4202
4203 #ifdef HAVE_HWMON
4204
4205 if (hwmon_check == 1)
4206 {
4207 hc_thread_mutex_lock (mux_adl);
4208
4209 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4210 {
4211 hc_device_param_t *device_param = &data.devices_param[device_id];
4212
4213 if (device_param->skipped) continue;
4214
4215 if (device_param->device_vendor_id == VENDOR_ID_NV)
4216 {
4217 if (data.hm_nvapi)
4218 {
4219 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
4220 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4221
4222 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4223 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4224
4225 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4226
4227 perfPolicies_status.info_value = perfPolicies_info.info_value;
4228
4229 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4230
4231 if (perfPolicies_status.throttle & 2)
4232 {
4233 if (slowdown_warnings < 3)
4234 {
4235 if (data.quiet == 0) clear_prompt ();
4236
4237 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4238
4239 if (slowdown_warnings == 2)
4240 {
4241 log_info ("");
4242 }
4243
4244 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4245 if (data.quiet == 0) fflush (stdout);
4246
4247 slowdown_warnings++;
4248 }
4249 }
4250 else
4251 {
4252 slowdown_warnings = 0;
4253 }
4254 }
4255 }
4256 }
4257
4258 hc_thread_mutex_unlock (mux_adl);
4259 }
4260
4261 if (hwmon_check == 1)
4262 {
4263 hc_thread_mutex_lock (mux_adl);
4264
4265 time_t temp_check_time;
4266
4267 time (&temp_check_time);
4268
4269 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4270
4271 if (Ta == 0) Ta = 1;
4272
4273 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4274 {
4275 hc_device_param_t *device_param = &data.devices_param[device_id];
4276
4277 if (device_param->skipped) continue;
4278
4279 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4280
4281 const int temperature = hm_get_temperature_with_device_id (device_id);
4282
4283 if (temperature > (int) data.gpu_temp_abort)
4284 {
4285 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4286
4287 if (data.devices_status != STATUS_QUIT) myabort ();
4288
4289 break;
4290 }
4291
4292 const int gpu_temp_retain = data.gpu_temp_retain;
4293
4294 if (gpu_temp_retain)
4295 {
4296 if (data.hm_device[device_id].fan_set_supported == 1)
4297 {
4298 int temp_cur = temperature;
4299
4300 int temp_diff_new = gpu_temp_retain - temp_cur;
4301
4302 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4303
4304 // calculate Ta value (time difference in seconds between the last check and this check)
4305
4306 last_temp_check_time = temp_check_time;
4307
4308 float Kp = 1.8;
4309 float Ki = 0.005;
4310 float Kd = 6;
4311
4312 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4313
4314 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);
4315
4316 if (abs (fan_diff_required) >= temp_threshold)
4317 {
4318 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4319
4320 int fan_speed_level = fan_speed_cur;
4321
4322 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4323
4324 int fan_speed_new = fan_speed_level - fan_diff_required;
4325
4326 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4327 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4328
4329 if (fan_speed_new != fan_speed_cur)
4330 {
4331 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4332 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4333
4334 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4335 {
4336 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4337 {
4338 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4339 }
4340 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4341 {
4342 #ifdef WIN
4343 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4344 #endif
4345
4346 #ifdef LINUX
4347 hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4348 #endif
4349 }
4350
4351 fan_speed_chgd[device_id] = 1;
4352 }
4353
4354 temp_diff_old[device_id] = temp_diff_new;
4355 }
4356 }
4357 }
4358 }
4359 }
4360
4361 hc_thread_mutex_unlock (mux_adl);
4362 }
4363 #endif // HAVE_HWMON
4364
4365 if (restore_check == 1)
4366 {
4367 restore_left--;
4368
4369 if (restore_left == 0)
4370 {
4371 if (data.restore_disable == 0) cycle_restore ();
4372
4373 restore_left = data.restore_timer;
4374 }
4375 }
4376
4377 if ((runtime_check == 1) && (data.runtime_start > 0))
4378 {
4379 time_t runtime_cur;
4380
4381 time (&runtime_cur);
4382
4383 int runtime_left = data.proc_start + data.runtime - runtime_cur;
4384
4385 if (runtime_left <= 0)
4386 {
4387 if (data.benchmark == 0)
4388 {
4389 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4390 }
4391
4392 if (data.devices_status != STATUS_QUIT) myabort ();
4393 }
4394 }
4395
4396 if (remove_check == 1)
4397 {
4398 remove_left--;
4399
4400 if (remove_left == 0)
4401 {
4402 if (data.digests_saved != data.digests_done)
4403 {
4404 data.digests_saved = data.digests_done;
4405
4406 save_hash ();
4407 }
4408
4409 remove_left = data.remove_timer;
4410 }
4411 }
4412
4413 if (status_check == 1)
4414 {
4415 status_left--;
4416
4417 if (status_left == 0)
4418 {
4419 hc_thread_mutex_lock (mux_display);
4420
4421 if (data.quiet == 0) clear_prompt ();
4422
4423 if (data.quiet == 0) log_info ("");
4424
4425 status_display ();
4426
4427 if (data.quiet == 0) log_info ("");
4428
4429 hc_thread_mutex_unlock (mux_display);
4430
4431 status_left = data.status_timer;
4432 }
4433 }
4434 }
4435
4436 #ifdef HAVE_HWMON
4437 myfree (fan_speed_chgd);
4438
4439 myfree (temp_diff_old);
4440 myfree (temp_diff_sum);
4441 #endif
4442
4443 p = NULL;
4444
4445 return (p);
4446 }
4447
4448 static void *thread_outfile_remove (void *p)
4449 {
4450 // some hash-dependent constants
4451 char *outfile_dir = data.outfile_check_directory;
4452 uint dgst_size = data.dgst_size;
4453 uint isSalted = data.isSalted;
4454 uint esalt_size = data.esalt_size;
4455 uint hash_mode = data.hash_mode;
4456
4457 uint outfile_check_timer = data.outfile_check_timer;
4458
4459 char separator = data.separator;
4460
4461 // some hash-dependent functions
4462 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4463 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4464
4465 // buffers
4466 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4467
4468 hash_buf.digest = mymalloc (dgst_size);
4469
4470 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4471
4472 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4473
4474 uint digest_buf[64] = { 0 };
4475
4476 outfile_data_t *out_info = NULL;
4477
4478 char **out_files = NULL;
4479
4480 time_t folder_mtime = 0;
4481
4482 int out_cnt = 0;
4483
4484 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4485
4486 while (data.shutdown_inner == 0)
4487 {
4488 hc_sleep (1);
4489
4490 if (data.devices_status != STATUS_RUNNING) continue;
4491
4492 check_left--;
4493
4494 if (check_left == 0)
4495 {
4496 struct stat outfile_check_stat;
4497
4498 if (stat (outfile_dir, &outfile_check_stat) == 0)
4499 {
4500 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4501
4502 if (is_dir == 1)
4503 {
4504 if (outfile_check_stat.st_mtime > folder_mtime)
4505 {
4506 char **out_files_new = scan_directory (outfile_dir);
4507
4508 int out_cnt_new = count_dictionaries (out_files_new);
4509
4510 outfile_data_t *out_info_new = NULL;
4511
4512 if (out_cnt_new > 0)
4513 {
4514 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4515
4516 for (int i = 0; i < out_cnt_new; i++)
4517 {
4518 out_info_new[i].file_name = out_files_new[i];
4519
4520 // check if there are files that we have seen/checked before (and not changed)
4521
4522 for (int j = 0; j < out_cnt; j++)
4523 {
4524 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4525 {
4526 struct stat outfile_stat;
4527
4528 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4529 {
4530 if (outfile_stat.st_ctime == out_info[j].ctime)
4531 {
4532 out_info_new[i].ctime = out_info[j].ctime;
4533 out_info_new[i].seek = out_info[j].seek;
4534 }
4535 }
4536 }
4537 }
4538 }
4539 }
4540
4541 local_free (out_info);
4542 local_free (out_files);
4543
4544 out_files = out_files_new;
4545 out_cnt = out_cnt_new;
4546 out_info = out_info_new;
4547
4548 folder_mtime = outfile_check_stat.st_mtime;
4549 }
4550
4551 for (int j = 0; j < out_cnt; j++)
4552 {
4553 FILE *fp = fopen (out_info[j].file_name, "rb");
4554
4555 if (fp != NULL)
4556 {
4557 //hc_thread_mutex_lock (mux_display);
4558
4559 #ifdef _POSIX
4560 struct stat outfile_stat;
4561
4562 fstat (fileno (fp), &outfile_stat);
4563 #endif
4564
4565 #ifdef _WIN
4566 struct stat64 outfile_stat;
4567
4568 _fstat64 (fileno (fp), &outfile_stat);
4569 #endif
4570
4571 if (outfile_stat.st_ctime > out_info[j].ctime)
4572 {
4573 out_info[j].ctime = outfile_stat.st_ctime;
4574 out_info[j].seek = 0;
4575 }
4576
4577 fseek (fp, out_info[j].seek, SEEK_SET);
4578
4579 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4580
4581 while (!feof (fp))
4582 {
4583 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4584
4585 if (ptr == NULL) break;
4586
4587 int line_len = strlen (line_buf);
4588
4589 if (line_len <= 0) continue;
4590
4591 int iter = MAX_CUT_TRIES;
4592
4593 for (uint i = line_len - 1; i && iter; i--, line_len--)
4594 {
4595 if (line_buf[i] != separator) continue;
4596
4597 int parser_status = PARSER_OK;
4598
4599 if ((hash_mode != 2500) && (hash_mode != 6800))
4600 {
4601 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4602 }
4603
4604 uint found = 0;
4605
4606 if (parser_status == PARSER_OK)
4607 {
4608 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4609 {
4610 if (data.salts_shown[salt_pos] == 1) continue;
4611
4612 salt_t *salt_buf = &data.salts_buf[salt_pos];
4613
4614 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4615 {
4616 uint idx = salt_buf->digests_offset + digest_pos;
4617
4618 if (data.digests_shown[idx] == 1) continue;
4619
4620 uint cracked = 0;
4621
4622 if (hash_mode == 6800)
4623 {
4624 if (i == salt_buf->salt_len)
4625 {
4626 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4627 }
4628 }
4629 else if (hash_mode == 2500)
4630 {
4631 // BSSID : MAC1 : MAC2 (:plain)
4632 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4633 {
4634 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4635
4636 if (!cracked) continue;
4637
4638 // now compare MAC1 and MAC2 too, since we have this additional info
4639 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4640 char *mac2_pos = mac1_pos + 12 + 1;
4641
4642 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4643 wpa_t *wpa = &wpas[salt_pos];
4644
4645 // compare hex string(s) vs binary MAC address(es)
4646
4647 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4648 {
4649 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4650 {
4651 cracked = 0;
4652
4653 break;
4654 }
4655 }
4656
4657 // early skip ;)
4658 if (!cracked) continue;
4659
4660 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4661 {
4662 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4663 {
4664 cracked = 0;
4665
4666 break;
4667 }
4668 }
4669 }
4670 }
4671 else
4672 {
4673 char *digests_buf_ptr = (char *) data.digests_buf;
4674
4675 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4676
4677 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4678 }
4679
4680 if (cracked == 1)
4681 {
4682 found = 1;
4683
4684 data.digests_shown[idx] = 1;
4685
4686 data.digests_done++;
4687
4688 salt_buf->digests_done++;
4689
4690 if (salt_buf->digests_done == salt_buf->digests_cnt)
4691 {
4692 data.salts_shown[salt_pos] = 1;
4693
4694 data.salts_done++;
4695
4696 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4697 }
4698 }
4699 }
4700
4701 if (data.devices_status == STATUS_CRACKED) break;
4702 }
4703 }
4704
4705 if (found) break;
4706
4707 if (data.devices_status == STATUS_CRACKED) break;
4708
4709 iter--;
4710 }
4711
4712 if (data.devices_status == STATUS_CRACKED) break;
4713 }
4714
4715 myfree (line_buf);
4716
4717 out_info[j].seek = ftell (fp);
4718
4719 //hc_thread_mutex_unlock (mux_display);
4720
4721 fclose (fp);
4722 }
4723 }
4724 }
4725 }
4726
4727 check_left = outfile_check_timer;
4728 }
4729 }
4730
4731 if (esalt_size) local_free (hash_buf.esalt);
4732
4733 if (isSalted) local_free (hash_buf.salt);
4734
4735 local_free (hash_buf.digest);
4736
4737 local_free (out_info);
4738
4739 local_free (out_files);
4740
4741 p = NULL;
4742
4743 return (p);
4744 }
4745
4746 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4747 {
4748 //if (device_param->pws_cnt < device_param->kernel_power)
4749 //{
4750 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4751
4752 u8 *ptr = (u8 *) pw->i;
4753
4754 memcpy (ptr, pw_buf, pw_len);
4755
4756 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4757
4758 pw->pw_len = pw_len;
4759
4760 device_param->pws_cnt++;
4761 //}
4762 //else
4763 //{
4764 // fprintf (stderr, "BUG pw_add()!!\n");
4765 //
4766 // return;
4767 //}
4768 }
4769
4770 static void set_kernel_power_final (const u64 kernel_power_final)
4771 {
4772 if (data.quiet == 0)
4773 {
4774 clear_prompt ();
4775
4776 //log_info ("");
4777
4778 log_info ("INFO: approaching final keyspace, workload adjusted");
4779 log_info ("");
4780
4781 fprintf (stdout, "%s", PROMPT);
4782
4783 fflush (stdout);
4784 }
4785
4786 data.kernel_power_final = kernel_power_final;
4787 }
4788
4789 static u32 get_power (hc_device_param_t *device_param)
4790 {
4791 const u64 kernel_power_final = data.kernel_power_final;
4792
4793 if (kernel_power_final)
4794 {
4795 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4796
4797 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4798
4799 // work should be at least the hardware power available without any accelerator
4800
4801 const u64 work = MAX (words_left_device, device_param->hardware_power);
4802
4803 return work;
4804 }
4805
4806 return device_param->kernel_power;
4807 }
4808
4809 static uint get_work (hc_device_param_t *device_param, const u64 max)
4810 {
4811 hc_thread_mutex_lock (mux_dispatcher);
4812
4813 const u64 words_cur = data.words_cur;
4814 const u64 words_base = (data.limit == 0) ? data.words_base : MIN (data.limit, data.words_base);
4815
4816 device_param->words_off = words_cur;
4817
4818 const u64 kernel_power_all = data.kernel_power_all;
4819
4820 const u64 words_left = words_base - words_cur;
4821
4822 if (words_left < kernel_power_all)
4823 {
4824 if (data.kernel_power_final == 0)
4825 {
4826 set_kernel_power_final (words_left);
4827 }
4828 }
4829
4830 const u32 kernel_power = get_power (device_param);
4831
4832 uint work = MIN (words_left, kernel_power);
4833
4834 work = MIN (work, max);
4835
4836 data.words_cur += work;
4837
4838 hc_thread_mutex_unlock (mux_dispatcher);
4839
4840 return work;
4841 }
4842
4843 static void *thread_autotune (void *p)
4844 {
4845 hc_device_param_t *device_param = (hc_device_param_t *) p;
4846
4847 if (device_param->skipped) return NULL;
4848
4849 autotune (device_param);
4850
4851 return NULL;
4852 }
4853
4854 static void *thread_calc_stdin (void *p)
4855 {
4856 hc_device_param_t *device_param = (hc_device_param_t *) p;
4857
4858 if (device_param->skipped) return NULL;
4859
4860 char *buf = (char *) mymalloc (HCBUFSIZ);
4861
4862 const uint attack_kern = data.attack_kern;
4863
4864 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4865 {
4866 hc_thread_mutex_lock (mux_dispatcher);
4867
4868 if (feof (stdin) != 0)
4869 {
4870 hc_thread_mutex_unlock (mux_dispatcher);
4871
4872 break;
4873 }
4874
4875 uint words_cur = 0;
4876
4877 while (words_cur < device_param->kernel_power)
4878 {
4879 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4880
4881 if (line_buf == NULL) break;
4882
4883 uint line_len = in_superchop (line_buf);
4884
4885 line_len = convert_from_hex (line_buf, line_len);
4886
4887 // post-process rule engine
4888
4889 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4890 {
4891 char rule_buf_out[BLOCK_SIZE] = { 0 };
4892
4893 int rule_len_out = -1;
4894
4895 if (line_len < BLOCK_SIZE)
4896 {
4897 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4898 }
4899
4900 if (rule_len_out < 0) continue;
4901
4902 line_buf = rule_buf_out;
4903 line_len = rule_len_out;
4904 }
4905
4906 if (line_len > PW_MAX)
4907 {
4908 continue;
4909 }
4910
4911 // hmm that's always the case, or?
4912
4913 if (attack_kern == ATTACK_KERN_STRAIGHT)
4914 {
4915 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4916 {
4917 hc_thread_mutex_lock (mux_counter);
4918
4919 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4920 {
4921 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4922 }
4923
4924 hc_thread_mutex_unlock (mux_counter);
4925
4926 continue;
4927 }
4928 }
4929
4930 pw_add (device_param, (u8 *) line_buf, line_len);
4931
4932 words_cur++;
4933
4934 if (data.devices_status == STATUS_CRACKED) break;
4935 if (data.devices_status == STATUS_ABORTED) break;
4936 if (data.devices_status == STATUS_QUIT) break;
4937 if (data.devices_status == STATUS_BYPASS) break;
4938 }
4939
4940 hc_thread_mutex_unlock (mux_dispatcher);
4941
4942 if (data.devices_status == STATUS_CRACKED) break;
4943 if (data.devices_status == STATUS_ABORTED) break;
4944 if (data.devices_status == STATUS_QUIT) break;
4945 if (data.devices_status == STATUS_BYPASS) break;
4946
4947 // flush
4948
4949 const uint pws_cnt = device_param->pws_cnt;
4950
4951 if (pws_cnt)
4952 {
4953 run_copy (device_param, pws_cnt);
4954
4955 run_cracker (device_param, pws_cnt);
4956
4957 device_param->pws_cnt = 0;
4958
4959 /*
4960 still required?
4961 if (attack_kern == ATTACK_KERN_STRAIGHT)
4962 {
4963 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4964 }
4965 else if (attack_kern == ATTACK_KERN_COMBI)
4966 {
4967 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4968 }
4969 */
4970 }
4971 }
4972
4973 device_param->kernel_accel = 0;
4974 device_param->kernel_loops = 0;
4975
4976 myfree (buf);
4977
4978 return NULL;
4979 }
4980
4981 static void *thread_calc (void *p)
4982 {
4983 hc_device_param_t *device_param = (hc_device_param_t *) p;
4984
4985 if (device_param->skipped) return NULL;
4986
4987 const uint attack_mode = data.attack_mode;
4988 const uint attack_kern = data.attack_kern;
4989
4990 if (attack_mode == ATTACK_MODE_BF)
4991 {
4992 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4993 {
4994 const uint work = get_work (device_param, -1);
4995
4996 if (work == 0) break;
4997
4998 const u64 words_off = device_param->words_off;
4999 const u64 words_fin = words_off + work;
5000
5001 const uint pws_cnt = work;
5002
5003 device_param->pws_cnt = pws_cnt;
5004
5005 if (pws_cnt)
5006 {
5007 run_copy (device_param, pws_cnt);
5008
5009 run_cracker (device_param, pws_cnt);
5010
5011 device_param->pws_cnt = 0;
5012
5013 /*
5014 still required?
5015 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
5016 */
5017 }
5018
5019 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5020
5021 if (data.devices_status == STATUS_CRACKED) break;
5022 if (data.devices_status == STATUS_ABORTED) break;
5023 if (data.devices_status == STATUS_QUIT) break;
5024 if (data.devices_status == STATUS_BYPASS) break;
5025
5026 if (data.benchmark == 1) break;
5027
5028 device_param->words_done = words_fin;
5029 }
5030 }
5031 else
5032 {
5033 const uint segment_size = data.segment_size;
5034
5035 char *dictfile = data.dictfile;
5036
5037 if (attack_mode == ATTACK_MODE_COMBI)
5038 {
5039 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5040 {
5041 dictfile = data.dictfile2;
5042 }
5043 }
5044
5045 FILE *fd = fopen (dictfile, "rb");
5046
5047 if (fd == NULL)
5048 {
5049 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
5050
5051 return NULL;
5052 }
5053
5054 if (attack_mode == ATTACK_MODE_COMBI)
5055 {
5056 const uint combs_mode = data.combs_mode;
5057
5058 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
5059 {
5060 const char *dictfilec = data.dictfile2;
5061
5062 FILE *combs_fp = fopen (dictfilec, "rb");
5063
5064 if (combs_fp == NULL)
5065 {
5066 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5067
5068 fclose (fd);
5069
5070 return NULL;
5071 }
5072
5073 device_param->combs_fp = combs_fp;
5074 }
5075 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5076 {
5077 const char *dictfilec = data.dictfile;
5078
5079 FILE *combs_fp = fopen (dictfilec, "rb");
5080
5081 if (combs_fp == NULL)
5082 {
5083 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5084
5085 fclose (fd);
5086
5087 return NULL;
5088 }
5089
5090 device_param->combs_fp = combs_fp;
5091 }
5092 }
5093
5094 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5095
5096 wl_data->buf = (char *) mymalloc (segment_size);
5097 wl_data->avail = segment_size;
5098 wl_data->incr = segment_size;
5099 wl_data->cnt = 0;
5100 wl_data->pos = 0;
5101
5102 u64 words_cur = 0;
5103
5104 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5105 {
5106 u64 words_off = 0;
5107 u64 words_fin = 0;
5108
5109 u64 max = -1;
5110
5111 while (max)
5112 {
5113 const uint work = get_work (device_param, max);
5114
5115 if (work == 0) break;
5116
5117 max = 0;
5118
5119 words_off = device_param->words_off;
5120 words_fin = words_off + work;
5121
5122 char *line_buf;
5123 uint line_len;
5124
5125 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5126
5127 for ( ; words_cur < words_fin; words_cur++)
5128 {
5129 get_next_word (wl_data, fd, &line_buf, &line_len);
5130
5131 line_len = convert_from_hex (line_buf, line_len);
5132
5133 // post-process rule engine
5134
5135 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5136 {
5137 char rule_buf_out[BLOCK_SIZE] = { 0 };
5138
5139 int rule_len_out = -1;
5140
5141 if (line_len < BLOCK_SIZE)
5142 {
5143 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5144 }
5145
5146 if (rule_len_out < 0) continue;
5147
5148 line_buf = rule_buf_out;
5149 line_len = rule_len_out;
5150 }
5151
5152 if (attack_kern == ATTACK_KERN_STRAIGHT)
5153 {
5154 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5155 {
5156 max++;
5157
5158 hc_thread_mutex_lock (mux_counter);
5159
5160 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5161 {
5162 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5163 }
5164
5165 hc_thread_mutex_unlock (mux_counter);
5166
5167 continue;
5168 }
5169 }
5170 else if (attack_kern == ATTACK_KERN_COMBI)
5171 {
5172 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5173 // since we still need to combine the plains
5174
5175 if (line_len > data.pw_max)
5176 {
5177 max++;
5178
5179 hc_thread_mutex_lock (mux_counter);
5180
5181 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5182 {
5183 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5184 }
5185
5186 hc_thread_mutex_unlock (mux_counter);
5187
5188 continue;
5189 }
5190 }
5191
5192 pw_add (device_param, (u8 *) line_buf, line_len);
5193
5194 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5195
5196 if (data.devices_status == STATUS_CRACKED) break;
5197 if (data.devices_status == STATUS_ABORTED) break;
5198 if (data.devices_status == STATUS_QUIT) break;
5199 if (data.devices_status == STATUS_BYPASS) break;
5200 }
5201
5202 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5203
5204 if (data.devices_status == STATUS_CRACKED) break;
5205 if (data.devices_status == STATUS_ABORTED) break;
5206 if (data.devices_status == STATUS_QUIT) break;
5207 if (data.devices_status == STATUS_BYPASS) break;
5208 }
5209
5210 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5211
5212 if (data.devices_status == STATUS_CRACKED) break;
5213 if (data.devices_status == STATUS_ABORTED) break;
5214 if (data.devices_status == STATUS_QUIT) break;
5215 if (data.devices_status == STATUS_BYPASS) break;
5216
5217 //
5218 // flush
5219 //
5220
5221 const uint pws_cnt = device_param->pws_cnt;
5222
5223 if (pws_cnt)
5224 {
5225 run_copy (device_param, pws_cnt);
5226
5227 run_cracker (device_param, pws_cnt);
5228
5229 device_param->pws_cnt = 0;
5230
5231 /*
5232 still required?
5233 if (attack_kern == ATTACK_KERN_STRAIGHT)
5234 {
5235 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5236 }
5237 else if (attack_kern == ATTACK_KERN_COMBI)
5238 {
5239 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5240 }
5241 */
5242 }
5243
5244 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5245
5246 if (data.devices_status == STATUS_CRACKED) break;
5247 if (data.devices_status == STATUS_ABORTED) break;
5248 if (data.devices_status == STATUS_QUIT) break;
5249 if (data.devices_status == STATUS_BYPASS) break;
5250
5251 if (words_fin == 0) break;
5252
5253 device_param->words_done = words_fin;
5254 }
5255
5256 if (attack_mode == ATTACK_MODE_COMBI)
5257 {
5258 fclose (device_param->combs_fp);
5259 }
5260
5261 free (wl_data->buf);
5262 free (wl_data);
5263
5264 fclose (fd);
5265 }
5266
5267 device_param->kernel_accel = 0;
5268 device_param->kernel_loops = 0;
5269
5270 return NULL;
5271 }
5272
5273 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5274 {
5275 if (!device_param)
5276 {
5277 log_error ("ERROR: %s : Invalid argument", __func__);
5278
5279 exit (-1);
5280 }
5281
5282 salt_t *salt_buf = &data.salts_buf[salt_pos];
5283
5284 device_param->kernel_params_buf32[27] = salt_pos;
5285 device_param->kernel_params_buf32[30] = 1;
5286 device_param->kernel_params_buf32[31] = salt_buf->digests_cnt;
5287 device_param->kernel_params_buf32[32] = salt_buf->digests_offset;
5288 device_param->kernel_params_buf32[33] = 0;
5289 device_param->kernel_params_buf32[34] = 1;
5290
5291 char *dictfile_old = data.dictfile;
5292
5293 const char *weak_hash_check = "weak-hash-check";
5294
5295 data.dictfile = (char *) weak_hash_check;
5296
5297 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5298
5299 data.kernel_rules_buf[0].cmds[0] = 0;
5300
5301 /**
5302 * run the kernel
5303 */
5304
5305 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5306 {
5307 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5308 }
5309 else
5310 {
5311 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5312
5313 uint loop_step = 16;
5314
5315 const uint iter = salt_buf->salt_iter;
5316
5317 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5318 {
5319 uint loop_left = iter - loop_pos;
5320
5321 loop_left = MIN (loop_left, loop_step);
5322
5323 device_param->kernel_params_buf32[28] = loop_pos;
5324 device_param->kernel_params_buf32[29] = loop_left;
5325
5326 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5327 }
5328
5329 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5330 }
5331
5332 /**
5333 * result
5334 */
5335
5336 check_cracked (device_param, salt_pos);
5337
5338 /**
5339 * cleanup
5340 */
5341
5342 device_param->kernel_params_buf32[27] = 0;
5343 device_param->kernel_params_buf32[28] = 0;
5344 device_param->kernel_params_buf32[29] = 0;
5345 device_param->kernel_params_buf32[30] = 0;
5346 device_param->kernel_params_buf32[31] = 0;
5347 device_param->kernel_params_buf32[32] = 0;
5348 device_param->kernel_params_buf32[33] = 0;
5349 device_param->kernel_params_buf32[34] = 0;
5350
5351 data.dictfile = dictfile_old;
5352
5353 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5354 }
5355
5356 // hlfmt hashcat
5357
5358 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5359 {
5360 if (data.username == 0)
5361 {
5362 *hashbuf_pos = line_buf;
5363 *hashbuf_len = line_len;
5364 }
5365 else
5366 {
5367 char *pos = line_buf;
5368 int len = line_len;
5369
5370 for (int i = 0; i < line_len; i++, pos++, len--)
5371 {
5372 if (line_buf[i] == data.separator)
5373 {
5374 pos++;
5375
5376 len--;
5377
5378 break;
5379 }
5380 }
5381
5382 *hashbuf_pos = pos;
5383 *hashbuf_len = len;
5384 }
5385 }
5386
5387 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5388 {
5389 char *pos = NULL;
5390 int len = 0;
5391
5392 int sep_cnt = 0;
5393
5394 for (int i = 0; i < line_len; i++)
5395 {
5396 if (line_buf[i] == data.separator)
5397 {
5398 sep_cnt++;
5399
5400 continue;
5401 }
5402
5403 if (sep_cnt == 0)
5404 {
5405 if (pos == NULL) pos = line_buf + i;
5406
5407 len++;
5408 }
5409 }
5410
5411 *userbuf_pos = pos;
5412 *userbuf_len = len;
5413 }
5414
5415 // hlfmt pwdump
5416
5417 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5418 {
5419 int sep_cnt = 0;
5420
5421 int sep2_len = 0;
5422 int sep3_len = 0;
5423
5424 for (int i = 0; i < line_len; i++)
5425 {
5426 if (line_buf[i] == ':')
5427 {
5428 sep_cnt++;
5429
5430 continue;
5431 }
5432
5433 if (sep_cnt == 2) sep2_len++;
5434 if (sep_cnt == 3) sep3_len++;
5435 }
5436
5437 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5438
5439 return 0;
5440 }
5441
5442 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5443 {
5444 char *pos = NULL;
5445 int len = 0;
5446
5447 int sep_cnt = 0;
5448
5449 for (int i = 0; i < line_len; i++)
5450 {
5451 if (line_buf[i] == ':')
5452 {
5453 sep_cnt++;
5454
5455 continue;
5456 }
5457
5458 if (data.hash_mode == 1000)
5459 {
5460 if (sep_cnt == 3)
5461 {
5462 if (pos == NULL) pos = line_buf + i;
5463
5464 len++;
5465 }
5466 }
5467 else if (data.hash_mode == 3000)
5468 {
5469 if (sep_cnt == 2)
5470 {
5471 if (pos == NULL) pos = line_buf + i;
5472
5473 len++;
5474 }
5475 }
5476 }
5477
5478 *hashbuf_pos = pos;
5479 *hashbuf_len = len;
5480 }
5481
5482 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5483 {
5484 char *pos = NULL;
5485 int len = 0;
5486
5487 int sep_cnt = 0;
5488
5489 for (int i = 0; i < line_len; i++)
5490 {
5491 if (line_buf[i] == ':')
5492 {
5493 sep_cnt++;
5494
5495 continue;
5496 }
5497
5498 if (sep_cnt == 0)
5499 {
5500 if (pos == NULL) pos = line_buf + i;
5501
5502 len++;
5503 }
5504 }
5505
5506 *userbuf_pos = pos;
5507 *userbuf_len = len;
5508 }
5509
5510 // hlfmt passwd
5511
5512 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5513 {
5514 int sep_cnt = 0;
5515
5516 char sep5_first = 0;
5517 char sep6_first = 0;
5518
5519 for (int i = 0; i < line_len; i++)
5520 {
5521 if (line_buf[i] == ':')
5522 {
5523 sep_cnt++;
5524
5525 continue;
5526 }
5527
5528 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5529 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5530 }
5531
5532 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5533
5534 return 0;
5535 }
5536
5537 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5538 {
5539 char *pos = NULL;
5540 int len = 0;
5541
5542 int sep_cnt = 0;
5543
5544 for (int i = 0; i < line_len; i++)
5545 {
5546 if (line_buf[i] == ':')
5547 {
5548 sep_cnt++;
5549
5550 continue;
5551 }
5552
5553 if (sep_cnt == 1)
5554 {
5555 if (pos == NULL) pos = line_buf + i;
5556
5557 len++;
5558 }
5559 }
5560
5561 *hashbuf_pos = pos;
5562 *hashbuf_len = len;
5563 }
5564
5565 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5566 {
5567 char *pos = NULL;
5568 int len = 0;
5569
5570 int sep_cnt = 0;
5571
5572 for (int i = 0; i < line_len; i++)
5573 {
5574 if (line_buf[i] == ':')
5575 {
5576 sep_cnt++;
5577
5578 continue;
5579 }
5580
5581 if (sep_cnt == 0)
5582 {
5583 if (pos == NULL) pos = line_buf + i;
5584
5585 len++;
5586 }
5587 }
5588
5589 *userbuf_pos = pos;
5590 *userbuf_len = len;
5591 }
5592
5593 // hlfmt shadow
5594
5595 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5596 {
5597 int sep_cnt = 0;
5598
5599 for (int i = 0; i < line_len; i++)
5600 {
5601 if (line_buf[i] == ':') sep_cnt++;
5602 }
5603
5604 if (sep_cnt == 8) return 1;
5605
5606 return 0;
5607 }
5608
5609 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5610 {
5611 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5612 }
5613
5614 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5615 {
5616 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5617 }
5618
5619 // hlfmt main
5620
5621 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5622 {
5623 switch (hashfile_format)
5624 {
5625 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5626 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5627 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5628 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5629 }
5630 }
5631
5632 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5633 {
5634 switch (hashfile_format)
5635 {
5636 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5637 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5638 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5639 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5640 }
5641 }
5642
5643 char *strhlfmt (const uint hashfile_format)
5644 {
5645 switch (hashfile_format)
5646 {
5647 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5648 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5649 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5650 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5651 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5652 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5653 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5654 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5655 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5656 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5657 }
5658
5659 return ((char *) "Unknown");
5660 }
5661
5662 static uint hlfmt_detect (FILE *fp, uint max_check)
5663 {
5664 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5665
5666 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5667 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5668
5669 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5670
5671 uint num_check = 0;
5672
5673 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5674
5675 while (!feof (fp))
5676 {
5677 int line_len = fgetl (fp, line_buf);
5678
5679 if (line_len == 0) continue;
5680
5681 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5682 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5683 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5684
5685 if (num_check == max_check) break;
5686
5687 num_check++;
5688 }
5689
5690 myfree (line_buf);
5691
5692 uint hashlist_format = HLFMT_HASHCAT;
5693
5694 for (int i = 1; i < HLFMTS_CNT; i++)
5695 {
5696 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5697
5698 hashlist_format = i;
5699 }
5700
5701 free (formats_cnt);
5702
5703 return hashlist_format;
5704 }
5705
5706 /**
5707 * some further helper function
5708 */
5709
5710 // wrapper around mymalloc for ADL
5711
5712 #if defined(HAVE_HWMON)
5713 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5714 {
5715 return mymalloc (iSize);
5716 }
5717 #endif
5718
5719 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)
5720 {
5721 u64 collisions = 0;
5722
5723 const uint dgst_pos0 = data.dgst_pos0;
5724 const uint dgst_pos1 = data.dgst_pos1;
5725 const uint dgst_pos2 = data.dgst_pos2;
5726 const uint dgst_pos3 = data.dgst_pos3;
5727
5728 memset (bitmap_a, 0, bitmap_size);
5729 memset (bitmap_b, 0, bitmap_size);
5730 memset (bitmap_c, 0, bitmap_size);
5731 memset (bitmap_d, 0, bitmap_size);
5732
5733 for (uint i = 0; i < digests_cnt; i++)
5734 {
5735 uint *digest_ptr = (uint *) digests_buf_ptr;
5736
5737 digests_buf_ptr += dgst_size;
5738
5739 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5740 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5741 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5742 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5743
5744 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5745 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5746 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5747 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5748
5749 if (bitmap_a[idx0] & val0) collisions++;
5750 if (bitmap_b[idx1] & val1) collisions++;
5751 if (bitmap_c[idx2] & val2) collisions++;
5752 if (bitmap_d[idx3] & val3) collisions++;
5753
5754 bitmap_a[idx0] |= val0;
5755 bitmap_b[idx1] |= val1;
5756 bitmap_c[idx2] |= val2;
5757 bitmap_d[idx3] |= val3;
5758
5759 if (collisions >= collisions_max) return 0x7fffffff;
5760 }
5761
5762 return collisions;
5763 }
5764
5765 /**
5766 * main
5767 */
5768
5769 #ifdef WIN
5770 void SetConsoleWindowSize (const int x)
5771 {
5772 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5773
5774 if (h == INVALID_HANDLE_VALUE) return;
5775
5776 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5777
5778 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5779
5780 SMALL_RECT *sr = &bufferInfo.srWindow;
5781
5782 sr->Right = MAX (sr->Right, x - 1);
5783
5784 COORD co;
5785
5786 co.X = sr->Right + 1;
5787 co.Y = 9999;
5788
5789 if (!SetConsoleScreenBufferSize (h, co)) return;
5790
5791 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5792 }
5793 #endif
5794
5795 int main (int argc, char **argv)
5796 {
5797 #ifdef WIN
5798 SetConsoleWindowSize (132);
5799 #endif
5800
5801 /**
5802 * To help users a bit
5803 */
5804
5805 char *compute = getenv ("COMPUTE");
5806
5807 if (compute)
5808 {
5809 static char display[100];
5810
5811 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5812
5813 putenv (display);
5814 }
5815 else
5816 {
5817 if (getenv ("DISPLAY") == NULL)
5818 putenv ((char *) "DISPLAY=:0");
5819 }
5820
5821 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5822 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5823
5824 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5825 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5826
5827 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5828 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5829
5830 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5831 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5832
5833 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5834 putenv ((char *) "POCL_KERNEL_CACHE=0");
5835
5836 umask (077);
5837
5838 /**
5839 * Real init
5840 */
5841
5842 memset (&data, 0, sizeof (hc_global_data_t));
5843
5844 time_t proc_start;
5845
5846 time (&proc_start);
5847
5848 data.proc_start = proc_start;
5849
5850 int myargc = argc;
5851 char **myargv = argv;
5852
5853 hc_thread_mutex_init (mux_dispatcher);
5854 hc_thread_mutex_init (mux_counter);
5855 hc_thread_mutex_init (mux_display);
5856 hc_thread_mutex_init (mux_adl);
5857
5858 /**
5859 * commandline parameters
5860 */
5861
5862 uint usage = USAGE;
5863 uint version = VERSION;
5864 uint quiet = QUIET;
5865 uint benchmark = BENCHMARK;
5866 uint stdout_flag = STDOUT_FLAG;
5867 uint show = SHOW;
5868 uint left = LEFT;
5869 uint username = USERNAME;
5870 uint remove = REMOVE;
5871 uint remove_timer = REMOVE_TIMER;
5872 u64 skip = SKIP;
5873 u64 limit = LIMIT;
5874 uint keyspace = KEYSPACE;
5875 uint potfile_disable = POTFILE_DISABLE;
5876 char *potfile_path = NULL;
5877 uint debug_mode = DEBUG_MODE;
5878 char *debug_file = NULL;
5879 char *induction_dir = NULL;
5880 char *outfile_check_dir = NULL;
5881 uint force = FORCE;
5882 uint runtime = RUNTIME;
5883 uint hash_mode = HASH_MODE;
5884 uint attack_mode = ATTACK_MODE;
5885 uint markov_disable = MARKOV_DISABLE;
5886 uint markov_classic = MARKOV_CLASSIC;
5887 uint markov_threshold = MARKOV_THRESHOLD;
5888 char *markov_hcstat = NULL;
5889 char *outfile = NULL;
5890 uint outfile_format = OUTFILE_FORMAT;
5891 uint outfile_autohex = OUTFILE_AUTOHEX;
5892 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5893 uint restore = RESTORE;
5894 uint restore_timer = RESTORE_TIMER;
5895 uint restore_disable = RESTORE_DISABLE;
5896 uint status = STATUS;
5897 uint status_timer = STATUS_TIMER;
5898 uint machine_readable = MACHINE_READABLE;
5899 uint loopback = LOOPBACK;
5900 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5901 char *session = NULL;
5902 uint hex_charset = HEX_CHARSET;
5903 uint hex_salt = HEX_SALT;
5904 uint hex_wordlist = HEX_WORDLIST;
5905 uint rp_gen = RP_GEN;
5906 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5907 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5908 uint rp_gen_seed = RP_GEN_SEED;
5909 char *rule_buf_l = (char *) RULE_BUF_L;
5910 char *rule_buf_r = (char *) RULE_BUF_R;
5911 uint increment = INCREMENT;
5912 uint increment_min = INCREMENT_MIN;
5913 uint increment_max = INCREMENT_MAX;
5914 char *cpu_affinity = NULL;
5915 OCL_PTR *ocl = NULL;
5916 char *opencl_devices = NULL;
5917 char *opencl_platforms = NULL;
5918 char *opencl_device_types = NULL;
5919 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5920 char *truecrypt_keyfiles = NULL;
5921 char *veracrypt_keyfiles = NULL;
5922 uint veracrypt_pim = 0;
5923 uint workload_profile = WORKLOAD_PROFILE;
5924 uint kernel_accel = KERNEL_ACCEL;
5925 uint kernel_loops = KERNEL_LOOPS;
5926 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
5927 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5928 #ifdef HAVE_HWMON
5929 uint gpu_temp_abort = GPU_TEMP_ABORT;
5930 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5931 uint powertune_enable = POWERTUNE_ENABLE;
5932 #endif
5933 uint logfile_disable = LOGFILE_DISABLE;
5934 uint segment_size = SEGMENT_SIZE;
5935 uint scrypt_tmto = SCRYPT_TMTO;
5936 char separator = SEPARATOR;
5937 uint bitmap_min = BITMAP_MIN;
5938 uint bitmap_max = BITMAP_MAX;
5939 char *custom_charset_1 = NULL;
5940 char *custom_charset_2 = NULL;
5941 char *custom_charset_3 = NULL;
5942 char *custom_charset_4 = NULL;
5943
5944 #define IDX_HELP 'h'
5945 #define IDX_VERSION 'V'
5946 #define IDX_VERSION_LOWER 'v'
5947 #define IDX_QUIET 0xff02
5948 #define IDX_SHOW 0xff03
5949 #define IDX_LEFT 0xff04
5950 #define IDX_REMOVE 0xff05
5951 #define IDX_REMOVE_TIMER 0xff37
5952 #define IDX_SKIP 's'
5953 #define IDX_LIMIT 'l'
5954 #define IDX_KEYSPACE 0xff35
5955 #define IDX_POTFILE_DISABLE 0xff06
5956 #define IDX_POTFILE_PATH 0xffe0
5957 #define IDX_DEBUG_MODE 0xff43
5958 #define IDX_DEBUG_FILE 0xff44
5959 #define IDX_INDUCTION_DIR 0xff46
5960 #define IDX_OUTFILE_CHECK_DIR 0xff47
5961 #define IDX_USERNAME 0xff07
5962 #define IDX_FORCE 0xff08
5963 #define IDX_RUNTIME 0xff09
5964 #define IDX_BENCHMARK 'b'
5965 #define IDX_STDOUT_FLAG 0xff77
5966 #define IDX_HASH_MODE 'm'
5967 #define IDX_ATTACK_MODE 'a'
5968 #define IDX_RP_FILE 'r'
5969 #define IDX_RP_GEN 'g'
5970 #define IDX_RP_GEN_FUNC_MIN 0xff10
5971 #define IDX_RP_GEN_FUNC_MAX 0xff11
5972 #define IDX_RP_GEN_SEED 0xff34
5973 #define IDX_RULE_BUF_L 'j'
5974 #define IDX_RULE_BUF_R 'k'
5975 #define IDX_INCREMENT 'i'
5976 #define IDX_INCREMENT_MIN 0xff12
5977 #define IDX_INCREMENT_MAX 0xff13
5978 #define IDX_OUTFILE 'o'
5979 #define IDX_OUTFILE_FORMAT 0xff14
5980 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5981 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5982 #define IDX_RESTORE 0xff15
5983 #define IDX_RESTORE_DISABLE 0xff27
5984 #define IDX_STATUS 0xff17
5985 #define IDX_STATUS_TIMER 0xff18
5986 #define IDX_MACHINE_READABLE 0xff50
5987 #define IDX_LOOPBACK 0xff38
5988 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5989 #define IDX_SESSION 0xff19
5990 #define IDX_HEX_CHARSET 0xff20
5991 #define IDX_HEX_SALT 0xff21
5992 #define IDX_HEX_WORDLIST 0xff40
5993 #define IDX_MARKOV_DISABLE 0xff22
5994 #define IDX_MARKOV_CLASSIC 0xff23
5995 #define IDX_MARKOV_THRESHOLD 't'
5996 #define IDX_MARKOV_HCSTAT 0xff24
5997 #define IDX_CPU_AFFINITY 0xff25
5998 #define IDX_OPENCL_DEVICES 'd'
5999 #define IDX_OPENCL_PLATFORMS 0xff72
6000 #define IDX_OPENCL_DEVICE_TYPES 'D'
6001 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
6002 #define IDX_WORKLOAD_PROFILE 'w'
6003 #define IDX_KERNEL_ACCEL 'n'
6004 #define IDX_KERNEL_LOOPS 'u'
6005 #define IDX_NVIDIA_SPIN_DAMP 0xff79
6006 #define IDX_GPU_TEMP_DISABLE 0xff29
6007 #define IDX_GPU_TEMP_ABORT 0xff30
6008 #define IDX_GPU_TEMP_RETAIN 0xff31
6009 #define IDX_POWERTUNE_ENABLE 0xff41
6010 #define IDX_LOGFILE_DISABLE 0xff51
6011 #define IDX_TRUECRYPT_KEYFILES 0xff52
6012 #define IDX_VERACRYPT_KEYFILES 0xff53
6013 #define IDX_VERACRYPT_PIM 0xff54
6014 #define IDX_SCRYPT_TMTO 0xff61
6015 #define IDX_SEGMENT_SIZE 'c'
6016 #define IDX_SEPARATOR 'p'
6017 #define IDX_BITMAP_MIN 0xff70
6018 #define IDX_BITMAP_MAX 0xff71
6019 #define IDX_CUSTOM_CHARSET_1 '1'
6020 #define IDX_CUSTOM_CHARSET_2 '2'
6021 #define IDX_CUSTOM_CHARSET_3 '3'
6022 #define IDX_CUSTOM_CHARSET_4 '4'
6023
6024 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:D:n:u:c:p:s:l:1:2:3:4:ibw:";
6025
6026 struct option long_options[] =
6027 {
6028 {"help", no_argument, 0, IDX_HELP},
6029 {"version", no_argument, 0, IDX_VERSION},
6030 {"quiet", no_argument, 0, IDX_QUIET},
6031 {"show", no_argument, 0, IDX_SHOW},
6032 {"left", no_argument, 0, IDX_LEFT},
6033 {"username", no_argument, 0, IDX_USERNAME},
6034 {"remove", no_argument, 0, IDX_REMOVE},
6035 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
6036 {"skip", required_argument, 0, IDX_SKIP},
6037 {"limit", required_argument, 0, IDX_LIMIT},
6038 {"keyspace", no_argument, 0, IDX_KEYSPACE},
6039 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
6040 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
6041 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
6042 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
6043 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
6044 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
6045 {"force", no_argument, 0, IDX_FORCE},
6046 {"benchmark", no_argument, 0, IDX_BENCHMARK},
6047 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
6048 {"restore", no_argument, 0, IDX_RESTORE},
6049 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
6050 {"status", no_argument, 0, IDX_STATUS},
6051 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
6052 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
6053 {"loopback", no_argument, 0, IDX_LOOPBACK},
6054 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
6055 {"session", required_argument, 0, IDX_SESSION},
6056 {"runtime", required_argument, 0, IDX_RUNTIME},
6057 {"generate-rules", required_argument, 0, IDX_RP_GEN},
6058 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
6059 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
6060 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
6061 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
6062 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
6063 {"hash-type", required_argument, 0, IDX_HASH_MODE},
6064 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
6065 {"rules-file", required_argument, 0, IDX_RP_FILE},
6066 {"outfile", required_argument, 0, IDX_OUTFILE},
6067 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
6068 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
6069 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
6070 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
6071 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
6072 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
6073 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
6074 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
6075 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
6076 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
6077 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
6078 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
6079 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
6080 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
6081 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
6082 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
6083 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
6084 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
6085 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6086 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
6087 #ifdef HAVE_HWMON
6088 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
6089 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
6090 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
6091 #endif // HAVE_HWMON
6092 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
6093 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6094 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
6095 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
6096 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
6097 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
6098 {"seperator", required_argument, 0, IDX_SEPARATOR},
6099 {"separator", required_argument, 0, IDX_SEPARATOR},
6100 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
6101 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
6102 {"increment", no_argument, 0, IDX_INCREMENT},
6103 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
6104 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
6105 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
6106 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
6107 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6108 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6109 {0, 0, 0, 0}
6110 };
6111
6112 uint rp_files_cnt = 0;
6113
6114 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6115
6116 int option_index = 0;
6117 int c = -1;
6118
6119 optind = 1;
6120 optopt = 0;
6121
6122 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6123 {
6124 switch (c)
6125 {
6126 case IDX_HELP: usage = 1; break;
6127 case IDX_VERSION:
6128 case IDX_VERSION_LOWER: version = 1; break;
6129 case IDX_RESTORE: restore = 1; break;
6130 case IDX_SESSION: session = optarg; break;
6131 case IDX_SHOW: show = 1; break;
6132 case IDX_LEFT: left = 1; break;
6133 case '?': return (-1);
6134 }
6135 }
6136
6137 if (optopt != 0)
6138 {
6139 log_error ("ERROR: Invalid argument specified");
6140
6141 return (-1);
6142 }
6143
6144 /**
6145 * exit functions
6146 */
6147
6148 if (version)
6149 {
6150 log_info ("%s", VERSION_TAG);
6151
6152 return (0);
6153 }
6154
6155 if (usage)
6156 {
6157 usage_big_print (PROGNAME);
6158
6159 return (0);
6160 }
6161
6162 /**
6163 * session needs to be set, always!
6164 */
6165
6166 if (session == NULL) session = (char *) PROGNAME;
6167
6168 /**
6169 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6170 */
6171
6172 char *exec_path = get_exec_path ();
6173
6174
6175 #if defined(LINUX) || defined(__APPLE__) || defined(__FreeBSD__)
6176
6177 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6178 char *resolved_exec_path = realpath (exec_path, NULL);
6179
6180 if (resolved_install_folder == NULL)
6181 {
6182 log_error ("ERROR: %s: %s", resolved_install_folder, strerror (errno));
6183
6184 return (-1);
6185 }
6186
6187 if (resolved_exec_path == NULL)
6188 {
6189 log_error ("ERROR: %s: %s", resolved_exec_path, strerror (errno));
6190
6191 return (-1);
6192 }
6193
6194 char *install_dir = get_install_dir (resolved_exec_path);
6195 char *profile_dir = NULL;
6196 char *session_dir = NULL;
6197 char *shared_dir = NULL;
6198
6199 if (strcmp (install_dir, resolved_install_folder) == 0)
6200 {
6201 struct passwd *pw = getpwuid (getuid ());
6202
6203 const char *homedir = pw->pw_dir;
6204
6205 profile_dir = get_profile_dir (homedir);
6206 session_dir = get_session_dir (profile_dir);
6207 shared_dir = strdup (SHARED_FOLDER);
6208
6209 mkdir (profile_dir, 0700);
6210 mkdir (session_dir, 0700);
6211 }
6212 else
6213 {
6214 profile_dir = install_dir;
6215 session_dir = install_dir;
6216 shared_dir = install_dir;
6217 }
6218
6219 myfree (resolved_install_folder);
6220 myfree (resolved_exec_path);
6221
6222 #else
6223
6224 char *install_dir = get_install_dir (exec_path);
6225 char *profile_dir = install_dir;
6226 char *session_dir = install_dir;
6227 char *shared_dir = install_dir;
6228
6229 #endif
6230
6231 data.install_dir = install_dir;
6232 data.profile_dir = profile_dir;
6233 data.session_dir = session_dir;
6234 data.shared_dir = shared_dir;
6235
6236 myfree (exec_path);
6237
6238 /**
6239 * kernel cache, we need to make sure folder exist
6240 */
6241
6242 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6243
6244 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6245
6246 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6247
6248 mkdir (kernels_folder, 0700);
6249
6250 myfree (kernels_folder);
6251
6252 /**
6253 * session
6254 */
6255
6256 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6257
6258 data.session = session;
6259
6260 char *eff_restore_file = (char *) mymalloc (session_size);
6261 char *new_restore_file = (char *) mymalloc (session_size);
6262
6263 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6264 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6265
6266 data.eff_restore_file = eff_restore_file;
6267 data.new_restore_file = new_restore_file;
6268
6269 if (((show == 1) || (left == 1)) && (restore == 1))
6270 {
6271 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6272 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6273
6274 return (-1);
6275 }
6276
6277 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6278 if ((show == 1) || (left == 1))
6279 {
6280 restore_disable = 1;
6281
6282 restore = 0;
6283 }
6284
6285 data.restore_disable = restore_disable;
6286
6287 restore_data_t *rd = init_restore (argc, argv);
6288
6289 data.rd = rd;
6290
6291 /**
6292 * restore file
6293 */
6294
6295 if (restore == 1)
6296 {
6297 read_restore (eff_restore_file, rd);
6298
6299 if (rd->version_bin < RESTORE_MIN)
6300 {
6301 log_error ("ERROR: Incompatible restore-file version");
6302
6303 return (-1);
6304 }
6305
6306 myargc = rd->argc;
6307 myargv = rd->argv;
6308
6309 #ifdef _POSIX
6310 rd->pid = getpid ();
6311 #elif _WIN
6312 rd->pid = GetCurrentProcessId ();
6313 #endif
6314 }
6315
6316 uint hash_mode_chgd = 0;
6317 uint runtime_chgd = 0;
6318 uint kernel_loops_chgd = 0;
6319 uint kernel_accel_chgd = 0;
6320 uint nvidia_spin_damp_chgd = 0;
6321 uint attack_mode_chgd = 0;
6322 uint outfile_format_chgd = 0;
6323 uint rp_gen_seed_chgd = 0;
6324 uint remove_timer_chgd = 0;
6325 uint increment_min_chgd = 0;
6326 uint increment_max_chgd = 0;
6327 uint workload_profile_chgd = 0;
6328 uint opencl_vector_width_chgd = 0;
6329
6330 optind = 1;
6331 optopt = 0;
6332 option_index = 0;
6333
6334 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6335 {
6336 switch (c)
6337 {
6338 //case IDX_HELP: usage = 1; break;
6339 //case IDX_VERSION: version = 1; break;
6340 //case IDX_RESTORE: restore = 1; break;
6341 case IDX_QUIET: quiet = 1; break;
6342 //case IDX_SHOW: show = 1; break;
6343 case IDX_SHOW: break;
6344 //case IDX_LEFT: left = 1; break;
6345 case IDX_LEFT: break;
6346 case IDX_USERNAME: username = 1; break;
6347 case IDX_REMOVE: remove = 1; break;
6348 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6349 remove_timer_chgd = 1; break;
6350 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6351 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6352 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6353 case IDX_DEBUG_FILE: debug_file = optarg; break;
6354 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6355 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6356 case IDX_FORCE: force = 1; break;
6357 case IDX_SKIP: skip = atoll (optarg); break;
6358 case IDX_LIMIT: limit = atoll (optarg); break;
6359 case IDX_KEYSPACE: keyspace = 1; break;
6360 case IDX_BENCHMARK: benchmark = 1; break;
6361 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6362 case IDX_RESTORE: break;
6363 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6364 case IDX_STATUS: status = 1; break;
6365 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6366 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6367 case IDX_LOOPBACK: loopback = 1; break;
6368 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6369 //case IDX_SESSION: session = optarg; break;
6370 case IDX_SESSION: break;
6371 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6372 hash_mode_chgd = 1; break;
6373 case IDX_RUNTIME: runtime = atoi (optarg);
6374 runtime_chgd = 1; break;
6375 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6376 attack_mode_chgd = 1; break;
6377 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6378 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6379 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6380 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6381 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6382 rp_gen_seed_chgd = 1; break;
6383 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6384 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6385 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6386 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6387 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6388 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6389 case IDX_OUTFILE: outfile = optarg; break;
6390 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6391 outfile_format_chgd = 1; break;
6392 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6393 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6394 case IDX_HEX_CHARSET: hex_charset = 1; break;
6395 case IDX_HEX_SALT: hex_salt = 1; break;
6396 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6397 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6398 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6399 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6400 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6401 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6402 opencl_vector_width_chgd = 1; break;
6403 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6404 workload_profile_chgd = 1; break;
6405 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6406 kernel_accel_chgd = 1; break;
6407 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6408 kernel_loops_chgd = 1; break;
6409 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6410 nvidia_spin_damp_chgd = 1; break;
6411 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6412 #ifdef HAVE_HWMON
6413 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6414 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6415 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6416 #endif // HAVE_HWMON
6417 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6418 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6419 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6420 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6421 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6422 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6423 case IDX_SEPARATOR: separator = optarg[0]; break;
6424 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6425 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6426 case IDX_INCREMENT: increment = 1; break;
6427 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6428 increment_min_chgd = 1; break;
6429 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6430 increment_max_chgd = 1; break;
6431 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6432 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6433 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6434 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6435
6436 default:
6437 log_error ("ERROR: Invalid argument specified");
6438 return (-1);
6439 }
6440 }
6441
6442 if (optopt != 0)
6443 {
6444 log_error ("ERROR: Invalid argument specified");
6445
6446 return (-1);
6447 }
6448
6449 /**
6450 * Inform user things getting started,
6451 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6452 * - we do not need to check algorithm_pos
6453 */
6454
6455 if (quiet == 0)
6456 {
6457 if (benchmark == 1)
6458 {
6459 if (machine_readable == 0)
6460 {
6461 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6462 log_info ("");
6463 }
6464 else
6465 {
6466 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6467 }
6468 }
6469 else if (restore == 1)
6470 {
6471 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6472 log_info ("");
6473 }
6474 else if (stdout_flag == 1)
6475 {
6476 // do nothing
6477 }
6478 else if (keyspace == 1)
6479 {
6480 // do nothing
6481 }
6482 else
6483 {
6484 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6485 log_info ("");
6486 }
6487 }
6488
6489 /**
6490 * sanity check
6491 */
6492
6493 if (attack_mode > 7)
6494 {
6495 log_error ("ERROR: Invalid attack-mode specified");
6496
6497 return (-1);
6498 }
6499
6500 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6501 {
6502 log_error ("ERROR: Invalid runtime specified");
6503
6504 return (-1);
6505 }
6506
6507 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6508 {
6509 log_error ("ERROR: Invalid hash-type specified");
6510
6511 return (-1);
6512 }
6513
6514 // renamed hash modes
6515
6516 if (hash_mode_chgd)
6517 {
6518 int n = -1;
6519
6520 switch (hash_mode)
6521 {
6522 case 123: n = 124;
6523 break;
6524 }
6525
6526 if (n >= 0)
6527 {
6528 log_error ("Old -m specified, use -m %d instead", n);
6529
6530 return (-1);
6531 }
6532 }
6533
6534 if (username == 1)
6535 {
6536 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6537 {
6538 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6539
6540 return (-1);
6541 }
6542 }
6543
6544 if (outfile_format > 16)
6545 {
6546 log_error ("ERROR: Invalid outfile-format specified");
6547
6548 return (-1);
6549 }
6550
6551 if (left == 1)
6552 {
6553 if (outfile_format_chgd == 1)
6554 {
6555 if (outfile_format > 1)
6556 {
6557 log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
6558
6559 return (-1);
6560 }
6561 }
6562 else
6563 {
6564 outfile_format = OUTFILE_FMT_HASH;
6565 }
6566 }
6567
6568 if (show == 1)
6569 {
6570 if (outfile_format_chgd == 1)
6571 {
6572 if ((outfile_format > 7) && (outfile_format < 16))
6573 {
6574 log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
6575
6576 return (-1);
6577 }
6578 }
6579 }
6580
6581 if (increment_min < INCREMENT_MIN)
6582 {
6583 log_error ("ERROR: Invalid increment-min specified");
6584
6585 return (-1);
6586 }
6587
6588 if (increment_max > INCREMENT_MAX)
6589 {
6590 log_error ("ERROR: Invalid increment-max specified");
6591
6592 return (-1);
6593 }
6594
6595 if (increment_min > increment_max)
6596 {
6597 log_error ("ERROR: Invalid increment-min specified");
6598
6599 return (-1);
6600 }
6601
6602 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6603 {
6604 log_error ("ERROR: Increment is not allowed in attack-mode 0");
6605
6606 return (-1);
6607 }
6608
6609 if ((increment == 0) && (increment_min_chgd == 1))
6610 {
6611 log_error ("ERROR: Increment-min is only supported combined with increment switch");
6612
6613 return (-1);
6614 }
6615
6616 if ((increment == 0) && (increment_max_chgd == 1))
6617 {
6618 log_error ("ERROR: Increment-max is only supported combined with increment switch");
6619
6620 return (-1);
6621 }
6622
6623 if (rp_files_cnt && rp_gen)
6624 {
6625 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6626
6627 return (-1);
6628 }
6629
6630 if (rp_files_cnt || rp_gen)
6631 {
6632 if (attack_mode != ATTACK_MODE_STRAIGHT)
6633 {
6634 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6635
6636 return (-1);
6637 }
6638 }
6639
6640 if (rp_gen_func_min > rp_gen_func_max)
6641 {
6642 log_error ("ERROR: Invalid rp-gen-func-min specified");
6643
6644 return (-1);
6645 }
6646
6647 if (kernel_accel_chgd == 1)
6648 {
6649 if (force == 0)
6650 {
6651 log_info ("The manual use of the -n option (or --kernel-accel) is outdated");
6652 log_info ("Please consider using the -w option instead");
6653 log_info ("You can use --force to override this but do not post error reports if you do so");
6654 log_info ("");
6655
6656 return (-1);
6657 }
6658
6659 if (kernel_accel < 1)
6660 {
6661 log_error ("ERROR: Invalid kernel-accel specified");
6662
6663 return (-1);
6664 }
6665
6666 if (kernel_accel > 1024)
6667 {
6668 log_error ("ERROR: Invalid kernel-accel specified");
6669
6670 return (-1);
6671 }
6672 }
6673
6674 if (kernel_loops_chgd == 1)
6675 {
6676 if (force == 0)
6677 {
6678 log_info ("The manual use of the -u option (or --kernel-loops) is outdated");
6679 log_info ("Please consider using the -w option instead");
6680 log_info ("You can use --force to override this but do not post error reports if you do so");
6681 log_info ("");
6682
6683 return (-1);
6684 }
6685
6686 if (kernel_loops < 1)
6687 {
6688 log_error ("ERROR: Invalid kernel-loops specified");
6689
6690 return (-1);
6691 }
6692
6693 if (kernel_loops > 1024)
6694 {
6695 log_error ("ERROR: Invalid kernel-loops specified");
6696
6697 return (-1);
6698 }
6699 }
6700
6701 if ((workload_profile < 1) || (workload_profile > 4))
6702 {
6703 log_error ("ERROR: workload-profile %i not available", workload_profile);
6704
6705 return (-1);
6706 }
6707
6708 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6709 {
6710 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6711
6712 return (-1);
6713 }
6714
6715 if (show == 1 || left == 1)
6716 {
6717 attack_mode = ATTACK_MODE_NONE;
6718
6719 if (remove == 1)
6720 {
6721 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6722
6723 return (-1);
6724 }
6725
6726 if (potfile_disable == 1)
6727 {
6728 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6729
6730 return (-1);
6731 }
6732 }
6733
6734 uint attack_kern = ATTACK_KERN_NONE;
6735
6736 switch (attack_mode)
6737 {
6738 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6739 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6740 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6741 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6742 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6743 }
6744
6745 if (benchmark == 1)
6746 {
6747 if (myargv[optind] != 0)
6748 {
6749 log_error ("ERROR: Invalid argument for benchmark mode specified");
6750
6751 return (-1);
6752 }
6753
6754 if (attack_mode_chgd == 1)
6755 {
6756 if (attack_mode != ATTACK_MODE_BF)
6757 {
6758 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6759
6760 return (-1);
6761 }
6762 }
6763 }
6764 else
6765 {
6766 if (stdout_flag == 1) // no hash here
6767 {
6768 optind--;
6769 }
6770
6771 if (keyspace == 1)
6772 {
6773 int num_additional_params = 1;
6774
6775 if (attack_kern == ATTACK_KERN_COMBI)
6776 {
6777 num_additional_params = 2;
6778 }
6779
6780 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6781
6782 if (keyspace_wordlist_specified == 0) optind--;
6783 }
6784
6785 if (attack_kern == ATTACK_KERN_NONE)
6786 {
6787 if ((optind + 1) != myargc)
6788 {
6789 usage_mini_print (myargv[0]);
6790
6791 return (-1);
6792 }
6793 }
6794 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6795 {
6796 if ((optind + 1) > myargc)
6797 {
6798 usage_mini_print (myargv[0]);
6799
6800 return (-1);
6801 }
6802 }
6803 else if (attack_kern == ATTACK_KERN_COMBI)
6804 {
6805 if ((optind + 3) != myargc)
6806 {
6807 usage_mini_print (myargv[0]);
6808
6809 return (-1);
6810 }
6811 }
6812 else if (attack_kern == ATTACK_KERN_BF)
6813 {
6814 if ((optind + 1) > myargc)
6815 {
6816 usage_mini_print (myargv[0]);
6817
6818 return (-1);
6819 }
6820 }
6821 else
6822 {
6823 usage_mini_print (myargv[0]);
6824
6825 return (-1);
6826 }
6827 }
6828
6829 if (skip != 0 && limit != 0)
6830 {
6831 limit += skip;
6832 }
6833
6834 if (keyspace == 1)
6835 {
6836 if (show == 1)
6837 {
6838 log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
6839
6840 return (-1);
6841 }
6842 else if (left == 1)
6843 {
6844 log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
6845
6846 return (-1);
6847 }
6848
6849 potfile_disable = 1;
6850
6851 restore_disable = 1;
6852
6853 restore = 0;
6854
6855 weak_hash_threshold = 0;
6856
6857 quiet = 1;
6858 }
6859
6860 if (stdout_flag == 1)
6861 {
6862 status_timer = 0;
6863 restore_timer = 0;
6864 restore_disable = 1;
6865 restore = 0;
6866 potfile_disable = 1;
6867 weak_hash_threshold = 0;
6868 gpu_temp_disable = 1;
6869 hash_mode = 2000;
6870 quiet = 1;
6871 outfile_format = OUTFILE_FMT_PLAIN;
6872 kernel_accel = 1024;
6873 kernel_loops = 1024;
6874 force = 1;
6875 outfile_check_timer = 0;
6876 session = "stdout";
6877 opencl_vector_width = 1;
6878 }
6879
6880 if (remove_timer_chgd == 1)
6881 {
6882 if (remove == 0)
6883 {
6884 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6885
6886 return (-1);
6887 }
6888
6889 if (remove_timer < 1)
6890 {
6891 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6892
6893 return (-1);
6894 }
6895 }
6896
6897 if (loopback == 1)
6898 {
6899 if (attack_mode == ATTACK_MODE_STRAIGHT)
6900 {
6901 if ((rp_files_cnt == 0) && (rp_gen == 0))
6902 {
6903 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6904
6905 return (-1);
6906 }
6907 }
6908 else
6909 {
6910 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6911
6912 return (-1);
6913 }
6914 }
6915
6916 if (debug_mode > 0)
6917 {
6918 if (attack_mode != ATTACK_MODE_STRAIGHT)
6919 {
6920 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6921
6922 return (-1);
6923 }
6924
6925 if ((rp_files_cnt == 0) && (rp_gen == 0))
6926 {
6927 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6928
6929 return (-1);
6930 }
6931 }
6932
6933 if (debug_mode > 4)
6934 {
6935 log_error ("ERROR: Invalid debug-mode specified");
6936
6937 return (-1);
6938 }
6939
6940 if (debug_file != NULL)
6941 {
6942 if (debug_mode < 1)
6943 {
6944 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6945
6946 return (-1);
6947 }
6948 }
6949
6950 if (induction_dir != NULL)
6951 {
6952 if (attack_mode == ATTACK_MODE_BF)
6953 {
6954 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6955
6956 return (-1);
6957 }
6958 }
6959
6960 if (attack_mode != ATTACK_MODE_STRAIGHT)
6961 {
6962 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6963 {
6964 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6965
6966 return (-1);
6967 }
6968
6969 weak_hash_threshold = 0;
6970 }
6971
6972 if (nvidia_spin_damp > 100)
6973 {
6974 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6975
6976 return (-1);
6977 }
6978
6979
6980 /**
6981 * induction directory
6982 */
6983
6984 char *induction_directory = NULL;
6985
6986 if (attack_mode != ATTACK_MODE_BF)
6987 {
6988 if (induction_dir == NULL)
6989 {
6990 induction_directory = (char *) mymalloc (session_size);
6991
6992 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6993
6994 // create induction folder if it does not already exist
6995
6996 if (keyspace == 0)
6997 {
6998 if (rmdir (induction_directory) == -1)
6999 {
7000 if (errno == ENOENT)
7001 {
7002 // good, we can ignore
7003 }
7004 else if (errno == ENOTEMPTY)
7005 {
7006 char *induction_directory_mv = (char *) mymalloc (session_size);
7007
7008 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
7009
7010 if (rename (induction_directory, induction_directory_mv) != 0)
7011 {
7012 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
7013
7014 return (-1);
7015 }
7016 }
7017 else
7018 {
7019 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
7020
7021 return (-1);
7022 }
7023 }
7024
7025 if (mkdir (induction_directory, 0700) == -1)
7026 {
7027 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
7028
7029 return (-1);
7030 }
7031 }
7032 }
7033 else
7034 {
7035 induction_directory = induction_dir;
7036 }
7037 }
7038
7039 data.induction_directory = induction_directory;
7040
7041 /**
7042 * loopback
7043 */
7044
7045 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
7046
7047 char *loopback_file = (char *) mymalloc (loopback_size);
7048
7049 /**
7050 * tuning db
7051 */
7052
7053 char tuning_db_file[256] = { 0 };
7054
7055 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
7056
7057 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
7058
7059 /**
7060 * outfile-check directory
7061 */
7062
7063 char *outfile_check_directory = NULL;
7064
7065 if (outfile_check_dir == NULL)
7066 {
7067 outfile_check_directory = (char *) mymalloc (session_size);
7068
7069 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
7070 }
7071 else
7072 {
7073 outfile_check_directory = outfile_check_dir;
7074 }
7075
7076 data.outfile_check_directory = outfile_check_directory;
7077
7078 if (keyspace == 0)
7079 {
7080 struct stat outfile_check_stat;
7081
7082 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
7083 {
7084 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
7085
7086 if (is_dir == 0)
7087 {
7088 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
7089
7090 return (-1);
7091 }
7092 }
7093 else if (outfile_check_dir == NULL)
7094 {
7095 if (mkdir (outfile_check_directory, 0700) == -1)
7096 {
7097 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
7098
7099 return (-1);
7100 }
7101 }
7102 }
7103
7104 /**
7105 * special other stuff
7106 */
7107
7108 if (hash_mode == 9710)
7109 {
7110 outfile_format = 5;
7111 outfile_format_chgd = 1;
7112 }
7113
7114 if (hash_mode == 9810)
7115 {
7116 outfile_format = 5;
7117 outfile_format_chgd = 1;
7118 }
7119
7120 if (hash_mode == 10410)
7121 {
7122 outfile_format = 5;
7123 outfile_format_chgd = 1;
7124 }
7125
7126 /**
7127 * store stuff
7128 */
7129
7130 data.hash_mode = hash_mode;
7131 data.restore = restore;
7132 data.restore_timer = restore_timer;
7133 data.restore_disable = restore_disable;
7134 data.status = status;
7135 data.status_timer = status_timer;
7136 data.machine_readable = machine_readable;
7137 data.loopback = loopback;
7138 data.runtime = runtime;
7139 data.remove = remove;
7140 data.remove_timer = remove_timer;
7141 data.debug_mode = debug_mode;
7142 data.debug_file = debug_file;
7143 data.username = username;
7144 data.quiet = quiet;
7145 data.outfile = outfile;
7146 data.outfile_format = outfile_format;
7147 data.outfile_autohex = outfile_autohex;
7148 data.hex_charset = hex_charset;
7149 data.hex_salt = hex_salt;
7150 data.hex_wordlist = hex_wordlist;
7151 data.separator = separator;
7152 data.rp_files = rp_files;
7153 data.rp_files_cnt = rp_files_cnt;
7154 data.rp_gen = rp_gen;
7155 data.rp_gen_seed = rp_gen_seed;
7156 data.force = force;
7157 data.benchmark = benchmark;
7158 data.skip = skip;
7159 data.limit = limit;
7160 #ifdef HAVE_HWMON
7161 data.powertune_enable = powertune_enable;
7162 #endif
7163 data.logfile_disable = logfile_disable;
7164 data.truecrypt_keyfiles = truecrypt_keyfiles;
7165 data.veracrypt_keyfiles = veracrypt_keyfiles;
7166 data.veracrypt_pim = veracrypt_pim;
7167 data.scrypt_tmto = scrypt_tmto;
7168 data.workload_profile = workload_profile;
7169
7170 /**
7171 * cpu affinity
7172 */
7173
7174 if (cpu_affinity)
7175 {
7176 set_cpu_affinity (cpu_affinity);
7177 }
7178
7179 if (rp_gen_seed_chgd == 0)
7180 {
7181 srand (proc_start);
7182 }
7183 else
7184 {
7185 srand (rp_gen_seed);
7186 }
7187
7188 /**
7189 * logfile init
7190 */
7191
7192 if (logfile_disable == 0)
7193 {
7194 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7195
7196 char *logfile = (char *) mymalloc (logfile_size);
7197
7198 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7199
7200 data.logfile = logfile;
7201
7202 char *topid = logfile_generate_topid ();
7203
7204 data.topid = topid;
7205 }
7206
7207 // logfile_append() checks for logfile_disable internally to make it easier from here
7208
7209 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7210 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7211 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7212 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7213 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7214 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7215 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7216 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7217 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7218 #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));
7219
7220 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7221 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7222 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7223 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7224 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7225 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7226 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7227 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7228
7229 logfile_top_msg ("START");
7230
7231 logfile_top_uint (attack_mode);
7232 logfile_top_uint (attack_kern);
7233 logfile_top_uint (benchmark);
7234 logfile_top_uint (stdout_flag);
7235 logfile_top_uint (bitmap_min);
7236 logfile_top_uint (bitmap_max);
7237 logfile_top_uint (debug_mode);
7238 logfile_top_uint (force);
7239 logfile_top_uint (kernel_accel);
7240 logfile_top_uint (kernel_loops);
7241 logfile_top_uint (nvidia_spin_damp);
7242 logfile_top_uint (gpu_temp_disable);
7243 #ifdef HAVE_HWMON
7244 logfile_top_uint (gpu_temp_abort);
7245 logfile_top_uint (gpu_temp_retain);
7246 #endif
7247 logfile_top_uint (hash_mode);
7248 logfile_top_uint (hex_charset);
7249 logfile_top_uint (hex_salt);
7250 logfile_top_uint (hex_wordlist);
7251 logfile_top_uint (increment);
7252 logfile_top_uint (increment_max);
7253 logfile_top_uint (increment_min);
7254 logfile_top_uint (keyspace);
7255 logfile_top_uint (left);
7256 logfile_top_uint (logfile_disable);
7257 logfile_top_uint (loopback);
7258 logfile_top_uint (markov_classic);
7259 logfile_top_uint (markov_disable);
7260 logfile_top_uint (markov_threshold);
7261 logfile_top_uint (outfile_autohex);
7262 logfile_top_uint (outfile_check_timer);
7263 logfile_top_uint (outfile_format);
7264 logfile_top_uint (potfile_disable);
7265 logfile_top_string (potfile_path);
7266 #if defined(HAVE_HWMON)
7267 logfile_top_uint (powertune_enable);
7268 #endif
7269 logfile_top_uint (scrypt_tmto);
7270 logfile_top_uint (quiet);
7271 logfile_top_uint (remove);
7272 logfile_top_uint (remove_timer);
7273 logfile_top_uint (restore);
7274 logfile_top_uint (restore_disable);
7275 logfile_top_uint (restore_timer);
7276 logfile_top_uint (rp_gen);
7277 logfile_top_uint (rp_gen_func_max);
7278 logfile_top_uint (rp_gen_func_min);
7279 logfile_top_uint (rp_gen_seed);
7280 logfile_top_uint (runtime);
7281 logfile_top_uint (segment_size);
7282 logfile_top_uint (show);
7283 logfile_top_uint (status);
7284 logfile_top_uint (machine_readable);
7285 logfile_top_uint (status_timer);
7286 logfile_top_uint (usage);
7287 logfile_top_uint (username);
7288 logfile_top_uint (version);
7289 logfile_top_uint (weak_hash_threshold);
7290 logfile_top_uint (workload_profile);
7291 logfile_top_uint64 (limit);
7292 logfile_top_uint64 (skip);
7293 logfile_top_char (separator);
7294 logfile_top_string (cpu_affinity);
7295 logfile_top_string (custom_charset_1);
7296 logfile_top_string (custom_charset_2);
7297 logfile_top_string (custom_charset_3);
7298 logfile_top_string (custom_charset_4);
7299 logfile_top_string (debug_file);
7300 logfile_top_string (opencl_devices);
7301 logfile_top_string (opencl_platforms);
7302 logfile_top_string (opencl_device_types);
7303 logfile_top_uint (opencl_vector_width);
7304 logfile_top_string (induction_dir);
7305 logfile_top_string (markov_hcstat);
7306 logfile_top_string (outfile);
7307 logfile_top_string (outfile_check_dir);
7308 logfile_top_string (rule_buf_l);
7309 logfile_top_string (rule_buf_r);
7310 logfile_top_string (session);
7311 logfile_top_string (truecrypt_keyfiles);
7312 logfile_top_string (veracrypt_keyfiles);
7313 logfile_top_uint (veracrypt_pim);
7314
7315 /**
7316 * Init OpenCL library loader
7317 */
7318
7319 if (keyspace == 0)
7320 {
7321 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7322
7323 ocl_init (ocl);
7324
7325 data.ocl = ocl;
7326 }
7327
7328 /**
7329 * OpenCL platform selection
7330 */
7331
7332 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7333
7334 /**
7335 * OpenCL device selection
7336 */
7337
7338 u32 devices_filter = setup_devices_filter (opencl_devices);
7339
7340 /**
7341 * OpenCL device type selection
7342 */
7343
7344 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7345
7346 /**
7347 * benchmark
7348 */
7349
7350 if (benchmark == 1)
7351 {
7352 /**
7353 * disable useless stuff for benchmark
7354 */
7355
7356 status_timer = 0;
7357 restore_timer = 0;
7358 restore_disable = 1;
7359 potfile_disable = 1;
7360 weak_hash_threshold = 0;
7361 nvidia_spin_damp = 0;
7362 gpu_temp_disable = 1;
7363 outfile_check_timer = 0;
7364
7365 #ifdef HAVE_HWMON
7366 if (powertune_enable == 1)
7367 {
7368 gpu_temp_disable = 0;
7369 }
7370 #endif
7371
7372 data.status_timer = status_timer;
7373 data.restore_timer = restore_timer;
7374 data.restore_disable = restore_disable;
7375 data.outfile_check_timer = outfile_check_timer;
7376
7377 /**
7378 * force attack mode to be bruteforce
7379 */
7380
7381 attack_mode = ATTACK_MODE_BF;
7382 attack_kern = ATTACK_KERN_BF;
7383
7384 if (workload_profile_chgd == 0)
7385 {
7386 workload_profile = 3;
7387
7388 data.workload_profile = workload_profile;
7389 }
7390 }
7391
7392 /**
7393 * status, monitor and outfile remove threads
7394 */
7395
7396 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
7397
7398 data.wordlist_mode = wordlist_mode;
7399
7400 if (wordlist_mode == WL_MODE_STDIN)
7401 {
7402 status = 1;
7403
7404 data.status = status;
7405 }
7406
7407 uint outer_threads_cnt = 0;
7408
7409 hc_thread_t *outer_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
7410
7411 data.shutdown_outer = 0;
7412
7413 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
7414 {
7415 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
7416 {
7417 hc_thread_create (outer_threads[outer_threads_cnt], thread_keypress, NULL);
7418
7419 outer_threads_cnt++;
7420 }
7421 }
7422
7423 /**
7424 * config
7425 */
7426
7427 uint hash_type = 0;
7428 uint salt_type = 0;
7429 uint attack_exec = 0;
7430 uint opts_type = 0;
7431 uint kern_type = 0;
7432 uint dgst_size = 0;
7433 uint esalt_size = 0;
7434 uint opti_type = 0;
7435 uint dgst_pos0 = -1;
7436 uint dgst_pos1 = -1;
7437 uint dgst_pos2 = -1;
7438 uint dgst_pos3 = -1;
7439
7440 int (*parse_func) (char *, uint, hash_t *);
7441 int (*sort_by_digest) (const void *, const void *);
7442
7443 uint algorithm_pos = 0;
7444 uint algorithm_max = 1;
7445
7446 uint *algorithms = default_benchmark_algorithms;
7447
7448 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7449
7450 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7451 {
7452 /*
7453 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7454 * the following algos are skipped entirely
7455 */
7456
7457 if (algorithm_pos > 0)
7458 {
7459 local_free (rd);
7460
7461 rd = init_restore (argc, argv);
7462
7463 data.rd = rd;
7464 }
7465
7466 /**
7467 * update hash_mode in case of multihash benchmark
7468 */
7469
7470 if (benchmark == 1)
7471 {
7472 if (hash_mode_chgd == 0)
7473 {
7474 hash_mode = algorithms[algorithm_pos];
7475
7476 data.hash_mode = hash_mode;
7477 }
7478
7479 quiet = 1;
7480
7481 data.quiet = quiet;
7482 }
7483
7484 switch (hash_mode)
7485 {
7486 case 0: hash_type = HASH_TYPE_MD5;
7487 salt_type = SALT_TYPE_NONE;
7488 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7489 opts_type = OPTS_TYPE_PT_GENERATE_LE
7490 | OPTS_TYPE_PT_ADD80
7491 | OPTS_TYPE_PT_ADDBITS14;
7492 kern_type = KERN_TYPE_MD5;
7493 dgst_size = DGST_SIZE_4_4;
7494 parse_func = md5_parse_hash;
7495 sort_by_digest = sort_by_digest_4_4;
7496 opti_type = OPTI_TYPE_ZERO_BYTE
7497 | OPTI_TYPE_PRECOMPUTE_INIT
7498 | OPTI_TYPE_PRECOMPUTE_MERKLE
7499 | OPTI_TYPE_MEET_IN_MIDDLE
7500 | OPTI_TYPE_EARLY_SKIP
7501 | OPTI_TYPE_NOT_ITERATED
7502 | OPTI_TYPE_NOT_SALTED
7503 | OPTI_TYPE_RAW_HASH;
7504 dgst_pos0 = 0;
7505 dgst_pos1 = 3;
7506 dgst_pos2 = 2;
7507 dgst_pos3 = 1;
7508 break;
7509
7510 case 10: hash_type = HASH_TYPE_MD5;
7511 salt_type = SALT_TYPE_INTERN;
7512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7513 opts_type = OPTS_TYPE_PT_GENERATE_LE
7514 | OPTS_TYPE_ST_ADD80
7515 | OPTS_TYPE_ST_ADDBITS14;
7516 kern_type = KERN_TYPE_MD5_PWSLT;
7517 dgst_size = DGST_SIZE_4_4;
7518 parse_func = md5s_parse_hash;
7519 sort_by_digest = sort_by_digest_4_4;
7520 opti_type = OPTI_TYPE_ZERO_BYTE
7521 | OPTI_TYPE_PRECOMPUTE_INIT
7522 | OPTI_TYPE_PRECOMPUTE_MERKLE
7523 | OPTI_TYPE_MEET_IN_MIDDLE
7524 | OPTI_TYPE_EARLY_SKIP
7525 | OPTI_TYPE_NOT_ITERATED
7526 | OPTI_TYPE_APPENDED_SALT
7527 | OPTI_TYPE_RAW_HASH;
7528 dgst_pos0 = 0;
7529 dgst_pos1 = 3;
7530 dgst_pos2 = 2;
7531 dgst_pos3 = 1;
7532 break;
7533
7534 case 11: hash_type = HASH_TYPE_MD5;
7535 salt_type = SALT_TYPE_INTERN;
7536 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7537 opts_type = OPTS_TYPE_PT_GENERATE_LE
7538 | OPTS_TYPE_ST_ADD80
7539 | OPTS_TYPE_ST_ADDBITS14;
7540 kern_type = KERN_TYPE_MD5_PWSLT;
7541 dgst_size = DGST_SIZE_4_4;
7542 parse_func = joomla_parse_hash;
7543 sort_by_digest = sort_by_digest_4_4;
7544 opti_type = OPTI_TYPE_ZERO_BYTE
7545 | OPTI_TYPE_PRECOMPUTE_INIT
7546 | OPTI_TYPE_PRECOMPUTE_MERKLE
7547 | OPTI_TYPE_MEET_IN_MIDDLE
7548 | OPTI_TYPE_EARLY_SKIP
7549 | OPTI_TYPE_NOT_ITERATED
7550 | OPTI_TYPE_APPENDED_SALT
7551 | OPTI_TYPE_RAW_HASH;
7552 dgst_pos0 = 0;
7553 dgst_pos1 = 3;
7554 dgst_pos2 = 2;
7555 dgst_pos3 = 1;
7556 break;
7557
7558 case 12: hash_type = HASH_TYPE_MD5;
7559 salt_type = SALT_TYPE_INTERN;
7560 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7561 opts_type = OPTS_TYPE_PT_GENERATE_LE
7562 | OPTS_TYPE_ST_ADD80
7563 | OPTS_TYPE_ST_ADDBITS14;
7564 kern_type = KERN_TYPE_MD5_PWSLT;
7565 dgst_size = DGST_SIZE_4_4;
7566 parse_func = postgresql_parse_hash;
7567 sort_by_digest = sort_by_digest_4_4;
7568 opti_type = OPTI_TYPE_ZERO_BYTE
7569 | OPTI_TYPE_PRECOMPUTE_INIT
7570 | OPTI_TYPE_PRECOMPUTE_MERKLE
7571 | OPTI_TYPE_MEET_IN_MIDDLE
7572 | OPTI_TYPE_EARLY_SKIP
7573 | OPTI_TYPE_NOT_ITERATED
7574 | OPTI_TYPE_APPENDED_SALT
7575 | OPTI_TYPE_RAW_HASH;
7576 dgst_pos0 = 0;
7577 dgst_pos1 = 3;
7578 dgst_pos2 = 2;
7579 dgst_pos3 = 1;
7580 break;
7581
7582 case 20: hash_type = HASH_TYPE_MD5;
7583 salt_type = SALT_TYPE_INTERN;
7584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7585 opts_type = OPTS_TYPE_PT_GENERATE_LE
7586 | OPTS_TYPE_PT_ADD80
7587 | OPTS_TYPE_PT_ADDBITS14;
7588 kern_type = KERN_TYPE_MD5_SLTPW;
7589 dgst_size = DGST_SIZE_4_4;
7590 parse_func = md5s_parse_hash;
7591 sort_by_digest = sort_by_digest_4_4;
7592 opti_type = OPTI_TYPE_ZERO_BYTE
7593 | OPTI_TYPE_PRECOMPUTE_INIT
7594 | OPTI_TYPE_PRECOMPUTE_MERKLE
7595 | OPTI_TYPE_EARLY_SKIP
7596 | OPTI_TYPE_NOT_ITERATED
7597 | OPTI_TYPE_PREPENDED_SALT
7598 | OPTI_TYPE_RAW_HASH;
7599 dgst_pos0 = 0;
7600 dgst_pos1 = 3;
7601 dgst_pos2 = 2;
7602 dgst_pos3 = 1;
7603 break;
7604
7605 case 21: hash_type = HASH_TYPE_MD5;
7606 salt_type = SALT_TYPE_INTERN;
7607 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7608 opts_type = OPTS_TYPE_PT_GENERATE_LE
7609 | OPTS_TYPE_PT_ADD80
7610 | OPTS_TYPE_PT_ADDBITS14;
7611 kern_type = KERN_TYPE_MD5_SLTPW;
7612 dgst_size = DGST_SIZE_4_4;
7613 parse_func = osc_parse_hash;
7614 sort_by_digest = sort_by_digest_4_4;
7615 opti_type = OPTI_TYPE_ZERO_BYTE
7616 | OPTI_TYPE_PRECOMPUTE_INIT
7617 | OPTI_TYPE_PRECOMPUTE_MERKLE
7618 | OPTI_TYPE_EARLY_SKIP
7619 | OPTI_TYPE_NOT_ITERATED
7620 | OPTI_TYPE_PREPENDED_SALT
7621 | OPTI_TYPE_RAW_HASH;
7622 dgst_pos0 = 0;
7623 dgst_pos1 = 3;
7624 dgst_pos2 = 2;
7625 dgst_pos3 = 1;
7626 break;
7627
7628 case 22: hash_type = HASH_TYPE_MD5;
7629 salt_type = SALT_TYPE_EMBEDDED;
7630 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7631 opts_type = OPTS_TYPE_PT_GENERATE_LE
7632 | OPTS_TYPE_PT_ADD80
7633 | OPTS_TYPE_PT_ADDBITS14;
7634 kern_type = KERN_TYPE_MD5_SLTPW;
7635 dgst_size = DGST_SIZE_4_4;
7636 parse_func = netscreen_parse_hash;
7637 sort_by_digest = sort_by_digest_4_4;
7638 opti_type = OPTI_TYPE_ZERO_BYTE
7639 | OPTI_TYPE_PRECOMPUTE_INIT
7640 | OPTI_TYPE_PRECOMPUTE_MERKLE
7641 | OPTI_TYPE_EARLY_SKIP
7642 | OPTI_TYPE_NOT_ITERATED
7643 | OPTI_TYPE_PREPENDED_SALT
7644 | OPTI_TYPE_RAW_HASH;
7645 dgst_pos0 = 0;
7646 dgst_pos1 = 3;
7647 dgst_pos2 = 2;
7648 dgst_pos3 = 1;
7649 break;
7650
7651 case 23: hash_type = HASH_TYPE_MD5;
7652 salt_type = SALT_TYPE_EMBEDDED;
7653 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7654 opts_type = OPTS_TYPE_PT_GENERATE_LE
7655 | OPTS_TYPE_PT_ADD80
7656 | OPTS_TYPE_PT_ADDBITS14;
7657 kern_type = KERN_TYPE_MD5_SLTPW;
7658 dgst_size = DGST_SIZE_4_4;
7659 parse_func = skype_parse_hash;
7660 sort_by_digest = sort_by_digest_4_4;
7661 opti_type = OPTI_TYPE_ZERO_BYTE
7662 | OPTI_TYPE_PRECOMPUTE_INIT
7663 | OPTI_TYPE_PRECOMPUTE_MERKLE
7664 | OPTI_TYPE_EARLY_SKIP
7665 | OPTI_TYPE_NOT_ITERATED
7666 | OPTI_TYPE_PREPENDED_SALT
7667 | OPTI_TYPE_RAW_HASH;
7668 dgst_pos0 = 0;
7669 dgst_pos1 = 3;
7670 dgst_pos2 = 2;
7671 dgst_pos3 = 1;
7672 break;
7673
7674 case 30: hash_type = HASH_TYPE_MD5;
7675 salt_type = SALT_TYPE_INTERN;
7676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7677 opts_type = OPTS_TYPE_PT_GENERATE_LE
7678 | OPTS_TYPE_PT_UNICODE
7679 | OPTS_TYPE_ST_ADD80
7680 | OPTS_TYPE_ST_ADDBITS14;
7681 kern_type = KERN_TYPE_MD5_PWUSLT;
7682 dgst_size = DGST_SIZE_4_4;
7683 parse_func = md5s_parse_hash;
7684 sort_by_digest = sort_by_digest_4_4;
7685 opti_type = OPTI_TYPE_ZERO_BYTE
7686 | OPTI_TYPE_PRECOMPUTE_INIT
7687 | OPTI_TYPE_PRECOMPUTE_MERKLE
7688 | OPTI_TYPE_MEET_IN_MIDDLE
7689 | OPTI_TYPE_EARLY_SKIP
7690 | OPTI_TYPE_NOT_ITERATED
7691 | OPTI_TYPE_APPENDED_SALT
7692 | OPTI_TYPE_RAW_HASH;
7693 dgst_pos0 = 0;
7694 dgst_pos1 = 3;
7695 dgst_pos2 = 2;
7696 dgst_pos3 = 1;
7697 break;
7698
7699 case 40: hash_type = HASH_TYPE_MD5;
7700 salt_type = SALT_TYPE_INTERN;
7701 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7702 opts_type = OPTS_TYPE_PT_GENERATE_LE
7703 | OPTS_TYPE_PT_ADD80
7704 | OPTS_TYPE_PT_ADDBITS14
7705 | OPTS_TYPE_PT_UNICODE;
7706 kern_type = KERN_TYPE_MD5_SLTPWU;
7707 dgst_size = DGST_SIZE_4_4;
7708 parse_func = md5s_parse_hash;
7709 sort_by_digest = sort_by_digest_4_4;
7710 opti_type = OPTI_TYPE_ZERO_BYTE
7711 | OPTI_TYPE_PRECOMPUTE_INIT
7712 | OPTI_TYPE_PRECOMPUTE_MERKLE
7713 | OPTI_TYPE_EARLY_SKIP
7714 | OPTI_TYPE_NOT_ITERATED
7715 | OPTI_TYPE_PREPENDED_SALT
7716 | OPTI_TYPE_RAW_HASH;
7717 dgst_pos0 = 0;
7718 dgst_pos1 = 3;
7719 dgst_pos2 = 2;
7720 dgst_pos3 = 1;
7721 break;
7722
7723 case 50: hash_type = HASH_TYPE_MD5;
7724 salt_type = SALT_TYPE_INTERN;
7725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7726 opts_type = OPTS_TYPE_PT_GENERATE_LE
7727 | OPTS_TYPE_ST_ADD80
7728 | OPTS_TYPE_ST_ADDBITS14;
7729 kern_type = KERN_TYPE_HMACMD5_PW;
7730 dgst_size = DGST_SIZE_4_4;
7731 parse_func = hmacmd5_parse_hash;
7732 sort_by_digest = sort_by_digest_4_4;
7733 opti_type = OPTI_TYPE_ZERO_BYTE
7734 | OPTI_TYPE_NOT_ITERATED;
7735 dgst_pos0 = 0;
7736 dgst_pos1 = 3;
7737 dgst_pos2 = 2;
7738 dgst_pos3 = 1;
7739 break;
7740
7741 case 60: hash_type = HASH_TYPE_MD5;
7742 salt_type = SALT_TYPE_INTERN;
7743 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7744 opts_type = OPTS_TYPE_PT_GENERATE_LE
7745 | OPTS_TYPE_PT_ADD80
7746 | OPTS_TYPE_PT_ADDBITS14;
7747 kern_type = KERN_TYPE_HMACMD5_SLT;
7748 dgst_size = DGST_SIZE_4_4;
7749 parse_func = hmacmd5_parse_hash;
7750 sort_by_digest = sort_by_digest_4_4;
7751 opti_type = OPTI_TYPE_ZERO_BYTE
7752 | OPTI_TYPE_NOT_ITERATED;
7753 dgst_pos0 = 0;
7754 dgst_pos1 = 3;
7755 dgst_pos2 = 2;
7756 dgst_pos3 = 1;
7757 break;
7758
7759 case 100: hash_type = HASH_TYPE_SHA1;
7760 salt_type = SALT_TYPE_NONE;
7761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7762 opts_type = OPTS_TYPE_PT_GENERATE_BE
7763 | OPTS_TYPE_PT_ADD80
7764 | OPTS_TYPE_PT_ADDBITS15;
7765 kern_type = KERN_TYPE_SHA1;
7766 dgst_size = DGST_SIZE_4_5;
7767 parse_func = sha1_parse_hash;
7768 sort_by_digest = sort_by_digest_4_5;
7769 opti_type = OPTI_TYPE_ZERO_BYTE
7770 | OPTI_TYPE_PRECOMPUTE_INIT
7771 | OPTI_TYPE_PRECOMPUTE_MERKLE
7772 | OPTI_TYPE_EARLY_SKIP
7773 | OPTI_TYPE_NOT_ITERATED
7774 | OPTI_TYPE_NOT_SALTED
7775 | OPTI_TYPE_RAW_HASH;
7776 dgst_pos0 = 3;
7777 dgst_pos1 = 4;
7778 dgst_pos2 = 2;
7779 dgst_pos3 = 1;
7780 break;
7781
7782 case 101: hash_type = HASH_TYPE_SHA1;
7783 salt_type = SALT_TYPE_NONE;
7784 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7785 opts_type = OPTS_TYPE_PT_GENERATE_BE
7786 | OPTS_TYPE_PT_ADD80
7787 | OPTS_TYPE_PT_ADDBITS15;
7788 kern_type = KERN_TYPE_SHA1;
7789 dgst_size = DGST_SIZE_4_5;
7790 parse_func = sha1b64_parse_hash;
7791 sort_by_digest = sort_by_digest_4_5;
7792 opti_type = OPTI_TYPE_ZERO_BYTE
7793 | OPTI_TYPE_PRECOMPUTE_INIT
7794 | OPTI_TYPE_PRECOMPUTE_MERKLE
7795 | OPTI_TYPE_EARLY_SKIP
7796 | OPTI_TYPE_NOT_ITERATED
7797 | OPTI_TYPE_NOT_SALTED
7798 | OPTI_TYPE_RAW_HASH;
7799 dgst_pos0 = 3;
7800 dgst_pos1 = 4;
7801 dgst_pos2 = 2;
7802 dgst_pos3 = 1;
7803 break;
7804
7805 case 110: hash_type = HASH_TYPE_SHA1;
7806 salt_type = SALT_TYPE_INTERN;
7807 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7808 opts_type = OPTS_TYPE_PT_GENERATE_BE
7809 | OPTS_TYPE_ST_ADD80
7810 | OPTS_TYPE_ST_ADDBITS15;
7811 kern_type = KERN_TYPE_SHA1_PWSLT;
7812 dgst_size = DGST_SIZE_4_5;
7813 parse_func = sha1s_parse_hash;
7814 sort_by_digest = sort_by_digest_4_5;
7815 opti_type = OPTI_TYPE_ZERO_BYTE
7816 | OPTI_TYPE_PRECOMPUTE_INIT
7817 | OPTI_TYPE_PRECOMPUTE_MERKLE
7818 | OPTI_TYPE_EARLY_SKIP
7819 | OPTI_TYPE_NOT_ITERATED
7820 | OPTI_TYPE_APPENDED_SALT
7821 | OPTI_TYPE_RAW_HASH;
7822 dgst_pos0 = 3;
7823 dgst_pos1 = 4;
7824 dgst_pos2 = 2;
7825 dgst_pos3 = 1;
7826 break;
7827
7828 case 111: hash_type = HASH_TYPE_SHA1;
7829 salt_type = SALT_TYPE_EMBEDDED;
7830 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7831 opts_type = OPTS_TYPE_PT_GENERATE_BE
7832 | OPTS_TYPE_ST_ADD80
7833 | OPTS_TYPE_ST_ADDBITS15;
7834 kern_type = KERN_TYPE_SHA1_PWSLT;
7835 dgst_size = DGST_SIZE_4_5;
7836 parse_func = sha1b64s_parse_hash;
7837 sort_by_digest = sort_by_digest_4_5;
7838 opti_type = OPTI_TYPE_ZERO_BYTE
7839 | OPTI_TYPE_PRECOMPUTE_INIT
7840 | OPTI_TYPE_PRECOMPUTE_MERKLE
7841 | OPTI_TYPE_EARLY_SKIP
7842 | OPTI_TYPE_NOT_ITERATED
7843 | OPTI_TYPE_APPENDED_SALT
7844 | OPTI_TYPE_RAW_HASH;
7845 dgst_pos0 = 3;
7846 dgst_pos1 = 4;
7847 dgst_pos2 = 2;
7848 dgst_pos3 = 1;
7849 break;
7850
7851 case 112: hash_type = HASH_TYPE_SHA1;
7852 salt_type = SALT_TYPE_INTERN;
7853 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7854 opts_type = OPTS_TYPE_PT_GENERATE_BE
7855 | OPTS_TYPE_ST_ADD80
7856 | OPTS_TYPE_ST_ADDBITS15
7857 | OPTS_TYPE_ST_HEX;
7858 kern_type = KERN_TYPE_SHA1_PWSLT;
7859 dgst_size = DGST_SIZE_4_5;
7860 parse_func = oracles_parse_hash;
7861 sort_by_digest = sort_by_digest_4_5;
7862 opti_type = OPTI_TYPE_ZERO_BYTE
7863 | OPTI_TYPE_PRECOMPUTE_INIT
7864 | OPTI_TYPE_PRECOMPUTE_MERKLE
7865 | OPTI_TYPE_EARLY_SKIP
7866 | OPTI_TYPE_NOT_ITERATED
7867 | OPTI_TYPE_APPENDED_SALT
7868 | OPTI_TYPE_RAW_HASH;
7869 dgst_pos0 = 3;
7870 dgst_pos1 = 4;
7871 dgst_pos2 = 2;
7872 dgst_pos3 = 1;
7873 break;
7874
7875 case 120: hash_type = HASH_TYPE_SHA1;
7876 salt_type = SALT_TYPE_INTERN;
7877 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7878 opts_type = OPTS_TYPE_PT_GENERATE_BE
7879 | OPTS_TYPE_PT_ADD80
7880 | OPTS_TYPE_PT_ADDBITS15;
7881 kern_type = KERN_TYPE_SHA1_SLTPW;
7882 dgst_size = DGST_SIZE_4_5;
7883 parse_func = sha1s_parse_hash;
7884 sort_by_digest = sort_by_digest_4_5;
7885 opti_type = OPTI_TYPE_ZERO_BYTE
7886 | OPTI_TYPE_PRECOMPUTE_INIT
7887 | OPTI_TYPE_PRECOMPUTE_MERKLE
7888 | OPTI_TYPE_EARLY_SKIP
7889 | OPTI_TYPE_NOT_ITERATED
7890 | OPTI_TYPE_PREPENDED_SALT
7891 | OPTI_TYPE_RAW_HASH;
7892 dgst_pos0 = 3;
7893 dgst_pos1 = 4;
7894 dgst_pos2 = 2;
7895 dgst_pos3 = 1;
7896 break;
7897
7898 case 121: hash_type = HASH_TYPE_SHA1;
7899 salt_type = SALT_TYPE_INTERN;
7900 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7901 opts_type = OPTS_TYPE_PT_GENERATE_BE
7902 | OPTS_TYPE_PT_ADD80
7903 | OPTS_TYPE_PT_ADDBITS15
7904 | OPTS_TYPE_ST_LOWER;
7905 kern_type = KERN_TYPE_SHA1_SLTPW;
7906 dgst_size = DGST_SIZE_4_5;
7907 parse_func = smf_parse_hash;
7908 sort_by_digest = sort_by_digest_4_5;
7909 opti_type = OPTI_TYPE_ZERO_BYTE
7910 | OPTI_TYPE_PRECOMPUTE_INIT
7911 | OPTI_TYPE_PRECOMPUTE_MERKLE
7912 | OPTI_TYPE_EARLY_SKIP
7913 | OPTI_TYPE_NOT_ITERATED
7914 | OPTI_TYPE_PREPENDED_SALT
7915 | OPTI_TYPE_RAW_HASH;
7916 dgst_pos0 = 3;
7917 dgst_pos1 = 4;
7918 dgst_pos2 = 2;
7919 dgst_pos3 = 1;
7920 break;
7921
7922 case 122: hash_type = HASH_TYPE_SHA1;
7923 salt_type = SALT_TYPE_EMBEDDED;
7924 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7925 opts_type = OPTS_TYPE_PT_GENERATE_BE
7926 | OPTS_TYPE_PT_ADD80
7927 | OPTS_TYPE_PT_ADDBITS15
7928 | OPTS_TYPE_ST_HEX;
7929 kern_type = KERN_TYPE_SHA1_SLTPW;
7930 dgst_size = DGST_SIZE_4_5;
7931 parse_func = osx1_parse_hash;
7932 sort_by_digest = sort_by_digest_4_5;
7933 opti_type = OPTI_TYPE_ZERO_BYTE
7934 | OPTI_TYPE_PRECOMPUTE_INIT
7935 | OPTI_TYPE_PRECOMPUTE_MERKLE
7936 | OPTI_TYPE_EARLY_SKIP
7937 | OPTI_TYPE_NOT_ITERATED
7938 | OPTI_TYPE_PREPENDED_SALT
7939 | OPTI_TYPE_RAW_HASH;
7940 dgst_pos0 = 3;
7941 dgst_pos1 = 4;
7942 dgst_pos2 = 2;
7943 dgst_pos3 = 1;
7944 break;
7945
7946 case 124: hash_type = HASH_TYPE_SHA1;
7947 salt_type = SALT_TYPE_EMBEDDED;
7948 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7949 opts_type = OPTS_TYPE_PT_GENERATE_BE
7950 | OPTS_TYPE_PT_ADD80
7951 | OPTS_TYPE_PT_ADDBITS15;
7952 kern_type = KERN_TYPE_SHA1_SLTPW;
7953 dgst_size = DGST_SIZE_4_5;
7954 parse_func = djangosha1_parse_hash;
7955 sort_by_digest = sort_by_digest_4_5;
7956 opti_type = OPTI_TYPE_ZERO_BYTE
7957 | OPTI_TYPE_PRECOMPUTE_INIT
7958 | OPTI_TYPE_PRECOMPUTE_MERKLE
7959 | OPTI_TYPE_EARLY_SKIP
7960 | OPTI_TYPE_NOT_ITERATED
7961 | OPTI_TYPE_PREPENDED_SALT
7962 | OPTI_TYPE_RAW_HASH;
7963 dgst_pos0 = 3;
7964 dgst_pos1 = 4;
7965 dgst_pos2 = 2;
7966 dgst_pos3 = 1;
7967 break;
7968
7969 case 125: hash_type = HASH_TYPE_SHA1;
7970 salt_type = SALT_TYPE_EMBEDDED;
7971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7972 opts_type = OPTS_TYPE_PT_GENERATE_BE
7973 | OPTS_TYPE_PT_ADD80
7974 | OPTS_TYPE_PT_ADDBITS15
7975 | OPTS_TYPE_ST_HEX;
7976 kern_type = KERN_TYPE_SHA1_SLTPW;
7977 dgst_size = DGST_SIZE_4_5;
7978 parse_func = arubaos_parse_hash;
7979 sort_by_digest = sort_by_digest_4_5;
7980 opti_type = OPTI_TYPE_ZERO_BYTE
7981 | OPTI_TYPE_PRECOMPUTE_INIT
7982 | OPTI_TYPE_PRECOMPUTE_MERKLE
7983 | OPTI_TYPE_EARLY_SKIP
7984 | OPTI_TYPE_NOT_ITERATED
7985 | OPTI_TYPE_PREPENDED_SALT
7986 | OPTI_TYPE_RAW_HASH;
7987 dgst_pos0 = 3;
7988 dgst_pos1 = 4;
7989 dgst_pos2 = 2;
7990 dgst_pos3 = 1;
7991 break;
7992
7993 case 130: hash_type = HASH_TYPE_SHA1;
7994 salt_type = SALT_TYPE_INTERN;
7995 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7996 opts_type = OPTS_TYPE_PT_GENERATE_BE
7997 | OPTS_TYPE_PT_UNICODE
7998 | OPTS_TYPE_ST_ADD80
7999 | OPTS_TYPE_ST_ADDBITS15;
8000 kern_type = KERN_TYPE_SHA1_PWUSLT;
8001 dgst_size = DGST_SIZE_4_5;
8002 parse_func = sha1s_parse_hash;
8003 sort_by_digest = sort_by_digest_4_5;
8004 opti_type = OPTI_TYPE_ZERO_BYTE
8005 | OPTI_TYPE_PRECOMPUTE_INIT
8006 | OPTI_TYPE_PRECOMPUTE_MERKLE
8007 | OPTI_TYPE_EARLY_SKIP
8008 | OPTI_TYPE_NOT_ITERATED
8009 | OPTI_TYPE_APPENDED_SALT
8010 | OPTI_TYPE_RAW_HASH;
8011 dgst_pos0 = 3;
8012 dgst_pos1 = 4;
8013 dgst_pos2 = 2;
8014 dgst_pos3 = 1;
8015 break;
8016
8017 case 131: hash_type = HASH_TYPE_SHA1;
8018 salt_type = SALT_TYPE_EMBEDDED;
8019 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8020 opts_type = OPTS_TYPE_PT_GENERATE_BE
8021 | OPTS_TYPE_PT_UNICODE
8022 | OPTS_TYPE_PT_UPPER
8023 | OPTS_TYPE_ST_ADD80
8024 | OPTS_TYPE_ST_ADDBITS15
8025 | OPTS_TYPE_ST_HEX;
8026 kern_type = KERN_TYPE_SHA1_PWUSLT;
8027 dgst_size = DGST_SIZE_4_5;
8028 parse_func = mssql2000_parse_hash;
8029 sort_by_digest = sort_by_digest_4_5;
8030 opti_type = OPTI_TYPE_ZERO_BYTE
8031 | OPTI_TYPE_PRECOMPUTE_INIT
8032 | OPTI_TYPE_PRECOMPUTE_MERKLE
8033 | OPTI_TYPE_EARLY_SKIP
8034 | OPTI_TYPE_NOT_ITERATED
8035 | OPTI_TYPE_APPENDED_SALT
8036 | OPTI_TYPE_RAW_HASH;
8037 dgst_pos0 = 3;
8038 dgst_pos1 = 4;
8039 dgst_pos2 = 2;
8040 dgst_pos3 = 1;
8041 break;
8042
8043 case 132: hash_type = HASH_TYPE_SHA1;
8044 salt_type = SALT_TYPE_EMBEDDED;
8045 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8046 opts_type = OPTS_TYPE_PT_GENERATE_BE
8047 | OPTS_TYPE_PT_UNICODE
8048 | OPTS_TYPE_ST_ADD80
8049 | OPTS_TYPE_ST_ADDBITS15
8050 | OPTS_TYPE_ST_HEX;
8051 kern_type = KERN_TYPE_SHA1_PWUSLT;
8052 dgst_size = DGST_SIZE_4_5;
8053 parse_func = mssql2005_parse_hash;
8054 sort_by_digest = sort_by_digest_4_5;
8055 opti_type = OPTI_TYPE_ZERO_BYTE
8056 | OPTI_TYPE_PRECOMPUTE_INIT
8057 | OPTI_TYPE_PRECOMPUTE_MERKLE
8058 | OPTI_TYPE_EARLY_SKIP
8059 | OPTI_TYPE_NOT_ITERATED
8060 | OPTI_TYPE_APPENDED_SALT
8061 | OPTI_TYPE_RAW_HASH;
8062 dgst_pos0 = 3;
8063 dgst_pos1 = 4;
8064 dgst_pos2 = 2;
8065 dgst_pos3 = 1;
8066 break;
8067
8068 case 133: hash_type = HASH_TYPE_SHA1;
8069 salt_type = SALT_TYPE_EMBEDDED;
8070 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8071 opts_type = OPTS_TYPE_PT_GENERATE_BE
8072 | OPTS_TYPE_PT_UNICODE
8073 | OPTS_TYPE_ST_ADD80
8074 | OPTS_TYPE_ST_ADDBITS15;
8075 kern_type = KERN_TYPE_SHA1_PWUSLT;
8076 dgst_size = DGST_SIZE_4_5;
8077 parse_func = peoplesoft_parse_hash;
8078 sort_by_digest = sort_by_digest_4_5;
8079 opti_type = OPTI_TYPE_ZERO_BYTE
8080 | OPTI_TYPE_PRECOMPUTE_INIT
8081 | OPTI_TYPE_PRECOMPUTE_MERKLE
8082 | OPTI_TYPE_EARLY_SKIP
8083 | OPTI_TYPE_NOT_ITERATED
8084 | OPTI_TYPE_APPENDED_SALT
8085 | OPTI_TYPE_RAW_HASH;
8086 dgst_pos0 = 3;
8087 dgst_pos1 = 4;
8088 dgst_pos2 = 2;
8089 dgst_pos3 = 1;
8090 break;
8091
8092 case 140: hash_type = HASH_TYPE_SHA1;
8093 salt_type = SALT_TYPE_INTERN;
8094 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8095 opts_type = OPTS_TYPE_PT_GENERATE_BE
8096 | OPTS_TYPE_PT_ADD80
8097 | OPTS_TYPE_PT_ADDBITS15
8098 | OPTS_TYPE_PT_UNICODE;
8099 kern_type = KERN_TYPE_SHA1_SLTPWU;
8100 dgst_size = DGST_SIZE_4_5;
8101 parse_func = sha1s_parse_hash;
8102 sort_by_digest = sort_by_digest_4_5;
8103 opti_type = OPTI_TYPE_ZERO_BYTE
8104 | OPTI_TYPE_PRECOMPUTE_INIT
8105 | OPTI_TYPE_PRECOMPUTE_MERKLE
8106 | OPTI_TYPE_EARLY_SKIP
8107 | OPTI_TYPE_NOT_ITERATED
8108 | OPTI_TYPE_PREPENDED_SALT
8109 | OPTI_TYPE_RAW_HASH;
8110 dgst_pos0 = 3;
8111 dgst_pos1 = 4;
8112 dgst_pos2 = 2;
8113 dgst_pos3 = 1;
8114 break;
8115
8116 case 141: hash_type = HASH_TYPE_SHA1;
8117 salt_type = SALT_TYPE_EMBEDDED;
8118 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8119 opts_type = OPTS_TYPE_PT_GENERATE_BE
8120 | OPTS_TYPE_PT_ADD80
8121 | OPTS_TYPE_PT_ADDBITS15
8122 | OPTS_TYPE_PT_UNICODE
8123 | OPTS_TYPE_ST_BASE64;
8124 kern_type = KERN_TYPE_SHA1_SLTPWU;
8125 dgst_size = DGST_SIZE_4_5;
8126 parse_func = episerver_parse_hash;
8127 sort_by_digest = sort_by_digest_4_5;
8128 opti_type = OPTI_TYPE_ZERO_BYTE
8129 | OPTI_TYPE_PRECOMPUTE_INIT
8130 | OPTI_TYPE_PRECOMPUTE_MERKLE
8131 | OPTI_TYPE_EARLY_SKIP
8132 | OPTI_TYPE_NOT_ITERATED
8133 | OPTI_TYPE_PREPENDED_SALT
8134 | OPTI_TYPE_RAW_HASH;
8135 dgst_pos0 = 3;
8136 dgst_pos1 = 4;
8137 dgst_pos2 = 2;
8138 dgst_pos3 = 1;
8139 break;
8140
8141 case 150: hash_type = HASH_TYPE_SHA1;
8142 salt_type = SALT_TYPE_INTERN;
8143 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8144 opts_type = OPTS_TYPE_PT_GENERATE_BE
8145 | OPTS_TYPE_ST_ADD80
8146 | OPTS_TYPE_ST_ADDBITS15;
8147 kern_type = KERN_TYPE_HMACSHA1_PW;
8148 dgst_size = DGST_SIZE_4_5;
8149 parse_func = hmacsha1_parse_hash;
8150 sort_by_digest = sort_by_digest_4_5;
8151 opti_type = OPTI_TYPE_ZERO_BYTE
8152 | OPTI_TYPE_NOT_ITERATED;
8153 dgst_pos0 = 3;
8154 dgst_pos1 = 4;
8155 dgst_pos2 = 2;
8156 dgst_pos3 = 1;
8157 break;
8158
8159 case 160: hash_type = HASH_TYPE_SHA1;
8160 salt_type = SALT_TYPE_INTERN;
8161 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8162 opts_type = OPTS_TYPE_PT_GENERATE_BE
8163 | OPTS_TYPE_PT_ADD80
8164 | OPTS_TYPE_PT_ADDBITS15;
8165 kern_type = KERN_TYPE_HMACSHA1_SLT;
8166 dgst_size = DGST_SIZE_4_5;
8167 parse_func = hmacsha1_parse_hash;
8168 sort_by_digest = sort_by_digest_4_5;
8169 opti_type = OPTI_TYPE_ZERO_BYTE
8170 | OPTI_TYPE_NOT_ITERATED;
8171 dgst_pos0 = 3;
8172 dgst_pos1 = 4;
8173 dgst_pos2 = 2;
8174 dgst_pos3 = 1;
8175 break;
8176
8177 case 200: hash_type = HASH_TYPE_MYSQL;
8178 salt_type = SALT_TYPE_NONE;
8179 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8180 opts_type = 0;
8181 kern_type = KERN_TYPE_MYSQL;
8182 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8183 parse_func = mysql323_parse_hash;
8184 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8185 opti_type = OPTI_TYPE_ZERO_BYTE;
8186 dgst_pos0 = 0;
8187 dgst_pos1 = 1;
8188 dgst_pos2 = 2;
8189 dgst_pos3 = 3;
8190 break;
8191
8192 case 300: hash_type = HASH_TYPE_SHA1;
8193 salt_type = SALT_TYPE_NONE;
8194 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8195 opts_type = OPTS_TYPE_PT_GENERATE_BE
8196 | OPTS_TYPE_PT_ADD80
8197 | OPTS_TYPE_PT_ADDBITS15;
8198 kern_type = KERN_TYPE_MYSQL41;
8199 dgst_size = DGST_SIZE_4_5;
8200 parse_func = sha1_parse_hash;
8201 sort_by_digest = sort_by_digest_4_5;
8202 opti_type = OPTI_TYPE_ZERO_BYTE
8203 | OPTI_TYPE_PRECOMPUTE_INIT
8204 | OPTI_TYPE_PRECOMPUTE_MERKLE
8205 | OPTI_TYPE_EARLY_SKIP
8206 | OPTI_TYPE_NOT_ITERATED
8207 | OPTI_TYPE_NOT_SALTED;
8208 dgst_pos0 = 3;
8209 dgst_pos1 = 4;
8210 dgst_pos2 = 2;
8211 dgst_pos3 = 1;
8212 break;
8213
8214 case 400: hash_type = HASH_TYPE_MD5;
8215 salt_type = SALT_TYPE_EMBEDDED;
8216 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8217 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8218 kern_type = KERN_TYPE_PHPASS;
8219 dgst_size = DGST_SIZE_4_4;
8220 parse_func = phpass_parse_hash;
8221 sort_by_digest = sort_by_digest_4_4;
8222 opti_type = OPTI_TYPE_ZERO_BYTE
8223 | OPTI_TYPE_SLOW_HASH_SIMD;
8224 dgst_pos0 = 0;
8225 dgst_pos1 = 1;
8226 dgst_pos2 = 2;
8227 dgst_pos3 = 3;
8228 break;
8229
8230 case 500: hash_type = HASH_TYPE_MD5;
8231 salt_type = SALT_TYPE_EMBEDDED;
8232 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8233 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8234 kern_type = KERN_TYPE_MD5CRYPT;
8235 dgst_size = DGST_SIZE_4_4;
8236 parse_func = md5crypt_parse_hash;
8237 sort_by_digest = sort_by_digest_4_4;
8238 opti_type = OPTI_TYPE_ZERO_BYTE;
8239 dgst_pos0 = 0;
8240 dgst_pos1 = 1;
8241 dgst_pos2 = 2;
8242 dgst_pos3 = 3;
8243 break;
8244
8245 case 501: hash_type = HASH_TYPE_MD5;
8246 salt_type = SALT_TYPE_EMBEDDED;
8247 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8248 opts_type = OPTS_TYPE_PT_GENERATE_LE
8249 | OPTS_TYPE_HASH_COPY;
8250 kern_type = KERN_TYPE_MD5CRYPT;
8251 dgst_size = DGST_SIZE_4_4;
8252 parse_func = juniper_parse_hash;
8253 sort_by_digest = sort_by_digest_4_4;
8254 opti_type = OPTI_TYPE_ZERO_BYTE;
8255 dgst_pos0 = 0;
8256 dgst_pos1 = 1;
8257 dgst_pos2 = 2;
8258 dgst_pos3 = 3;
8259 break;
8260
8261 case 900: hash_type = HASH_TYPE_MD4;
8262 salt_type = SALT_TYPE_NONE;
8263 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8264 opts_type = OPTS_TYPE_PT_GENERATE_LE
8265 | OPTS_TYPE_PT_ADD80
8266 | OPTS_TYPE_PT_ADDBITS14;
8267 kern_type = KERN_TYPE_MD4;
8268 dgst_size = DGST_SIZE_4_4;
8269 parse_func = md4_parse_hash;
8270 sort_by_digest = sort_by_digest_4_4;
8271 opti_type = OPTI_TYPE_ZERO_BYTE
8272 | OPTI_TYPE_PRECOMPUTE_INIT
8273 | OPTI_TYPE_PRECOMPUTE_MERKLE
8274 | OPTI_TYPE_MEET_IN_MIDDLE
8275 | OPTI_TYPE_EARLY_SKIP
8276 | OPTI_TYPE_NOT_ITERATED
8277 | OPTI_TYPE_NOT_SALTED
8278 | OPTI_TYPE_RAW_HASH;
8279 dgst_pos0 = 0;
8280 dgst_pos1 = 3;
8281 dgst_pos2 = 2;
8282 dgst_pos3 = 1;
8283 break;
8284
8285 case 1000: hash_type = HASH_TYPE_MD4;
8286 salt_type = SALT_TYPE_NONE;
8287 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8288 opts_type = OPTS_TYPE_PT_GENERATE_LE
8289 | OPTS_TYPE_PT_ADD80
8290 | OPTS_TYPE_PT_ADDBITS14
8291 | OPTS_TYPE_PT_UNICODE;
8292 kern_type = KERN_TYPE_MD4_PWU;
8293 dgst_size = DGST_SIZE_4_4;
8294 parse_func = md4_parse_hash;
8295 sort_by_digest = sort_by_digest_4_4;
8296 opti_type = OPTI_TYPE_ZERO_BYTE
8297 | OPTI_TYPE_PRECOMPUTE_INIT
8298 | OPTI_TYPE_PRECOMPUTE_MERKLE
8299 | OPTI_TYPE_MEET_IN_MIDDLE
8300 | OPTI_TYPE_EARLY_SKIP
8301 | OPTI_TYPE_NOT_ITERATED
8302 | OPTI_TYPE_NOT_SALTED
8303 | OPTI_TYPE_RAW_HASH;
8304 dgst_pos0 = 0;
8305 dgst_pos1 = 3;
8306 dgst_pos2 = 2;
8307 dgst_pos3 = 1;
8308 break;
8309
8310 case 1100: hash_type = HASH_TYPE_MD4;
8311 salt_type = SALT_TYPE_INTERN;
8312 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8313 opts_type = OPTS_TYPE_PT_GENERATE_LE
8314 | OPTS_TYPE_PT_ADD80
8315 | OPTS_TYPE_PT_ADDBITS14
8316 | OPTS_TYPE_PT_UNICODE
8317 | OPTS_TYPE_ST_ADD80
8318 | OPTS_TYPE_ST_UNICODE
8319 | OPTS_TYPE_ST_LOWER;
8320 kern_type = KERN_TYPE_MD44_PWUSLT;
8321 dgst_size = DGST_SIZE_4_4;
8322 parse_func = dcc_parse_hash;
8323 sort_by_digest = sort_by_digest_4_4;
8324 opti_type = OPTI_TYPE_ZERO_BYTE
8325 | OPTI_TYPE_PRECOMPUTE_INIT
8326 | OPTI_TYPE_PRECOMPUTE_MERKLE
8327 | OPTI_TYPE_EARLY_SKIP
8328 | OPTI_TYPE_NOT_ITERATED;
8329 dgst_pos0 = 0;
8330 dgst_pos1 = 3;
8331 dgst_pos2 = 2;
8332 dgst_pos3 = 1;
8333 break;
8334
8335 case 1400: hash_type = HASH_TYPE_SHA256;
8336 salt_type = SALT_TYPE_NONE;
8337 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8338 opts_type = OPTS_TYPE_PT_GENERATE_BE
8339 | OPTS_TYPE_PT_ADD80
8340 | OPTS_TYPE_PT_ADDBITS15;
8341 kern_type = KERN_TYPE_SHA256;
8342 dgst_size = DGST_SIZE_4_8;
8343 parse_func = sha256_parse_hash;
8344 sort_by_digest = sort_by_digest_4_8;
8345 opti_type = OPTI_TYPE_ZERO_BYTE
8346 | OPTI_TYPE_PRECOMPUTE_INIT
8347 | OPTI_TYPE_PRECOMPUTE_MERKLE
8348 | OPTI_TYPE_EARLY_SKIP
8349 | OPTI_TYPE_NOT_ITERATED
8350 | OPTI_TYPE_NOT_SALTED
8351 | OPTI_TYPE_RAW_HASH;
8352 dgst_pos0 = 3;
8353 dgst_pos1 = 7;
8354 dgst_pos2 = 2;
8355 dgst_pos3 = 6;
8356 break;
8357
8358 case 1410: hash_type = HASH_TYPE_SHA256;
8359 salt_type = SALT_TYPE_INTERN;
8360 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8361 opts_type = OPTS_TYPE_PT_GENERATE_BE
8362 | OPTS_TYPE_ST_ADD80
8363 | OPTS_TYPE_ST_ADDBITS15;
8364 kern_type = KERN_TYPE_SHA256_PWSLT;
8365 dgst_size = DGST_SIZE_4_8;
8366 parse_func = sha256s_parse_hash;
8367 sort_by_digest = sort_by_digest_4_8;
8368 opti_type = OPTI_TYPE_ZERO_BYTE
8369 | OPTI_TYPE_PRECOMPUTE_INIT
8370 | OPTI_TYPE_PRECOMPUTE_MERKLE
8371 | OPTI_TYPE_EARLY_SKIP
8372 | OPTI_TYPE_NOT_ITERATED
8373 | OPTI_TYPE_APPENDED_SALT
8374 | OPTI_TYPE_RAW_HASH;
8375 dgst_pos0 = 3;
8376 dgst_pos1 = 7;
8377 dgst_pos2 = 2;
8378 dgst_pos3 = 6;
8379 break;
8380
8381 case 1420: hash_type = HASH_TYPE_SHA256;
8382 salt_type = SALT_TYPE_INTERN;
8383 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8384 opts_type = OPTS_TYPE_PT_GENERATE_BE
8385 | OPTS_TYPE_PT_ADD80
8386 | OPTS_TYPE_PT_ADDBITS15;
8387 kern_type = KERN_TYPE_SHA256_SLTPW;
8388 dgst_size = DGST_SIZE_4_8;
8389 parse_func = sha256s_parse_hash;
8390 sort_by_digest = sort_by_digest_4_8;
8391 opti_type = OPTI_TYPE_ZERO_BYTE
8392 | OPTI_TYPE_PRECOMPUTE_INIT
8393 | OPTI_TYPE_PRECOMPUTE_MERKLE
8394 | OPTI_TYPE_EARLY_SKIP
8395 | OPTI_TYPE_NOT_ITERATED
8396 | OPTI_TYPE_PREPENDED_SALT
8397 | OPTI_TYPE_RAW_HASH;
8398 dgst_pos0 = 3;
8399 dgst_pos1 = 7;
8400 dgst_pos2 = 2;
8401 dgst_pos3 = 6;
8402 break;
8403
8404 case 1421: hash_type = HASH_TYPE_SHA256;
8405 salt_type = SALT_TYPE_EMBEDDED;
8406 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8407 opts_type = OPTS_TYPE_PT_GENERATE_BE
8408 | OPTS_TYPE_PT_ADD80
8409 | OPTS_TYPE_PT_ADDBITS15;
8410 kern_type = KERN_TYPE_SHA256_SLTPW;
8411 dgst_size = DGST_SIZE_4_8;
8412 parse_func = hmailserver_parse_hash;
8413 sort_by_digest = sort_by_digest_4_8;
8414 opti_type = OPTI_TYPE_ZERO_BYTE
8415 | OPTI_TYPE_PRECOMPUTE_INIT
8416 | OPTI_TYPE_PRECOMPUTE_MERKLE
8417 | OPTI_TYPE_EARLY_SKIP
8418 | OPTI_TYPE_NOT_ITERATED
8419 | OPTI_TYPE_PREPENDED_SALT
8420 | OPTI_TYPE_RAW_HASH;
8421 dgst_pos0 = 3;
8422 dgst_pos1 = 7;
8423 dgst_pos2 = 2;
8424 dgst_pos3 = 6;
8425 break;
8426
8427 case 1430: hash_type = HASH_TYPE_SHA256;
8428 salt_type = SALT_TYPE_INTERN;
8429 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8430 opts_type = OPTS_TYPE_PT_GENERATE_BE
8431 | OPTS_TYPE_PT_UNICODE
8432 | OPTS_TYPE_ST_ADD80
8433 | OPTS_TYPE_ST_ADDBITS15;
8434 kern_type = KERN_TYPE_SHA256_PWUSLT;
8435 dgst_size = DGST_SIZE_4_8;
8436 parse_func = sha256s_parse_hash;
8437 sort_by_digest = sort_by_digest_4_8;
8438 opti_type = OPTI_TYPE_ZERO_BYTE
8439 | OPTI_TYPE_PRECOMPUTE_INIT
8440 | OPTI_TYPE_PRECOMPUTE_MERKLE
8441 | OPTI_TYPE_EARLY_SKIP
8442 | OPTI_TYPE_NOT_ITERATED
8443 | OPTI_TYPE_APPENDED_SALT
8444 | OPTI_TYPE_RAW_HASH;
8445 dgst_pos0 = 3;
8446 dgst_pos1 = 7;
8447 dgst_pos2 = 2;
8448 dgst_pos3 = 6;
8449 break;
8450
8451 case 1440: hash_type = HASH_TYPE_SHA256;
8452 salt_type = SALT_TYPE_INTERN;
8453 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8454 opts_type = OPTS_TYPE_PT_GENERATE_BE
8455 | OPTS_TYPE_PT_ADD80
8456 | OPTS_TYPE_PT_ADDBITS15
8457 | OPTS_TYPE_PT_UNICODE;
8458 kern_type = KERN_TYPE_SHA256_SLTPWU;
8459 dgst_size = DGST_SIZE_4_8;
8460 parse_func = sha256s_parse_hash;
8461 sort_by_digest = sort_by_digest_4_8;
8462 opti_type = OPTI_TYPE_ZERO_BYTE
8463 | OPTI_TYPE_PRECOMPUTE_INIT
8464 | OPTI_TYPE_PRECOMPUTE_MERKLE
8465 | OPTI_TYPE_EARLY_SKIP
8466 | OPTI_TYPE_NOT_ITERATED
8467 | OPTI_TYPE_PREPENDED_SALT
8468 | OPTI_TYPE_RAW_HASH;
8469 dgst_pos0 = 3;
8470 dgst_pos1 = 7;
8471 dgst_pos2 = 2;
8472 dgst_pos3 = 6;
8473 break;
8474
8475 case 1441: hash_type = HASH_TYPE_SHA256;
8476 salt_type = SALT_TYPE_EMBEDDED;
8477 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8478 opts_type = OPTS_TYPE_PT_GENERATE_BE
8479 | OPTS_TYPE_PT_ADD80
8480 | OPTS_TYPE_PT_ADDBITS15
8481 | OPTS_TYPE_PT_UNICODE
8482 | OPTS_TYPE_ST_BASE64;
8483 kern_type = KERN_TYPE_SHA256_SLTPWU;
8484 dgst_size = DGST_SIZE_4_8;
8485 parse_func = episerver4_parse_hash;
8486 sort_by_digest = sort_by_digest_4_8;
8487 opti_type = OPTI_TYPE_ZERO_BYTE
8488 | OPTI_TYPE_PRECOMPUTE_INIT
8489 | OPTI_TYPE_PRECOMPUTE_MERKLE
8490 | OPTI_TYPE_EARLY_SKIP
8491 | OPTI_TYPE_NOT_ITERATED
8492 | OPTI_TYPE_PREPENDED_SALT
8493 | OPTI_TYPE_RAW_HASH;
8494 dgst_pos0 = 3;
8495 dgst_pos1 = 7;
8496 dgst_pos2 = 2;
8497 dgst_pos3 = 6;
8498 break;
8499
8500 case 1450: hash_type = HASH_TYPE_SHA256;
8501 salt_type = SALT_TYPE_INTERN;
8502 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8503 opts_type = OPTS_TYPE_PT_GENERATE_BE
8504 | OPTS_TYPE_ST_ADD80;
8505 kern_type = KERN_TYPE_HMACSHA256_PW;
8506 dgst_size = DGST_SIZE_4_8;
8507 parse_func = hmacsha256_parse_hash;
8508 sort_by_digest = sort_by_digest_4_8;
8509 opti_type = OPTI_TYPE_ZERO_BYTE
8510 | OPTI_TYPE_NOT_ITERATED;
8511 dgst_pos0 = 3;
8512 dgst_pos1 = 7;
8513 dgst_pos2 = 2;
8514 dgst_pos3 = 6;
8515 break;
8516
8517 case 1460: hash_type = HASH_TYPE_SHA256;
8518 salt_type = SALT_TYPE_INTERN;
8519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8520 opts_type = OPTS_TYPE_PT_GENERATE_BE
8521 | OPTS_TYPE_PT_ADD80
8522 | OPTS_TYPE_PT_ADDBITS15;
8523 kern_type = KERN_TYPE_HMACSHA256_SLT;
8524 dgst_size = DGST_SIZE_4_8;
8525 parse_func = hmacsha256_parse_hash;
8526 sort_by_digest = sort_by_digest_4_8;
8527 opti_type = OPTI_TYPE_ZERO_BYTE
8528 | OPTI_TYPE_NOT_ITERATED;
8529 dgst_pos0 = 3;
8530 dgst_pos1 = 7;
8531 dgst_pos2 = 2;
8532 dgst_pos3 = 6;
8533 break;
8534
8535 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8536 salt_type = SALT_TYPE_EMBEDDED;
8537 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8538 opts_type = OPTS_TYPE_PT_GENERATE_LE
8539 | OPTS_TYPE_PT_BITSLICE;
8540 kern_type = KERN_TYPE_DESCRYPT;
8541 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8542 parse_func = descrypt_parse_hash;
8543 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8544 opti_type = OPTI_TYPE_ZERO_BYTE
8545 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8546 dgst_pos0 = 0;
8547 dgst_pos1 = 1;
8548 dgst_pos2 = 2;
8549 dgst_pos3 = 3;
8550 break;
8551
8552 case 1600: hash_type = HASH_TYPE_MD5;
8553 salt_type = SALT_TYPE_EMBEDDED;
8554 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8555 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8556 kern_type = KERN_TYPE_APR1CRYPT;
8557 dgst_size = DGST_SIZE_4_4;
8558 parse_func = md5apr1_parse_hash;
8559 sort_by_digest = sort_by_digest_4_4;
8560 opti_type = OPTI_TYPE_ZERO_BYTE;
8561 dgst_pos0 = 0;
8562 dgst_pos1 = 1;
8563 dgst_pos2 = 2;
8564 dgst_pos3 = 3;
8565 break;
8566
8567 case 1700: hash_type = HASH_TYPE_SHA512;
8568 salt_type = SALT_TYPE_NONE;
8569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8570 opts_type = OPTS_TYPE_PT_GENERATE_BE
8571 | OPTS_TYPE_PT_ADD80
8572 | OPTS_TYPE_PT_ADDBITS15;
8573 kern_type = KERN_TYPE_SHA512;
8574 dgst_size = DGST_SIZE_8_8;
8575 parse_func = sha512_parse_hash;
8576 sort_by_digest = sort_by_digest_8_8;
8577 opti_type = OPTI_TYPE_ZERO_BYTE
8578 | OPTI_TYPE_PRECOMPUTE_INIT
8579 | OPTI_TYPE_PRECOMPUTE_MERKLE
8580 | OPTI_TYPE_EARLY_SKIP
8581 | OPTI_TYPE_NOT_ITERATED
8582 | OPTI_TYPE_NOT_SALTED
8583 | OPTI_TYPE_USES_BITS_64
8584 | OPTI_TYPE_RAW_HASH;
8585 dgst_pos0 = 14;
8586 dgst_pos1 = 15;
8587 dgst_pos2 = 6;
8588 dgst_pos3 = 7;
8589 break;
8590
8591 case 1710: hash_type = HASH_TYPE_SHA512;
8592 salt_type = SALT_TYPE_INTERN;
8593 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8594 opts_type = OPTS_TYPE_PT_GENERATE_BE
8595 | OPTS_TYPE_ST_ADD80
8596 | OPTS_TYPE_ST_ADDBITS15;
8597 kern_type = KERN_TYPE_SHA512_PWSLT;
8598 dgst_size = DGST_SIZE_8_8;
8599 parse_func = sha512s_parse_hash;
8600 sort_by_digest = sort_by_digest_8_8;
8601 opti_type = OPTI_TYPE_ZERO_BYTE
8602 | OPTI_TYPE_PRECOMPUTE_INIT
8603 | OPTI_TYPE_PRECOMPUTE_MERKLE
8604 | OPTI_TYPE_EARLY_SKIP
8605 | OPTI_TYPE_NOT_ITERATED
8606 | OPTI_TYPE_APPENDED_SALT
8607 | OPTI_TYPE_USES_BITS_64
8608 | OPTI_TYPE_RAW_HASH;
8609 dgst_pos0 = 14;
8610 dgst_pos1 = 15;
8611 dgst_pos2 = 6;
8612 dgst_pos3 = 7;
8613 break;
8614
8615 case 1711: hash_type = HASH_TYPE_SHA512;
8616 salt_type = SALT_TYPE_EMBEDDED;
8617 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8618 opts_type = OPTS_TYPE_PT_GENERATE_BE
8619 | OPTS_TYPE_ST_ADD80
8620 | OPTS_TYPE_ST_ADDBITS15;
8621 kern_type = KERN_TYPE_SHA512_PWSLT;
8622 dgst_size = DGST_SIZE_8_8;
8623 parse_func = sha512b64s_parse_hash;
8624 sort_by_digest = sort_by_digest_8_8;
8625 opti_type = OPTI_TYPE_ZERO_BYTE
8626 | OPTI_TYPE_PRECOMPUTE_INIT
8627 | OPTI_TYPE_PRECOMPUTE_MERKLE
8628 | OPTI_TYPE_EARLY_SKIP
8629 | OPTI_TYPE_NOT_ITERATED
8630 | OPTI_TYPE_APPENDED_SALT
8631 | OPTI_TYPE_USES_BITS_64
8632 | OPTI_TYPE_RAW_HASH;
8633 dgst_pos0 = 14;
8634 dgst_pos1 = 15;
8635 dgst_pos2 = 6;
8636 dgst_pos3 = 7;
8637 break;
8638
8639 case 1720: hash_type = HASH_TYPE_SHA512;
8640 salt_type = SALT_TYPE_INTERN;
8641 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8642 opts_type = OPTS_TYPE_PT_GENERATE_BE
8643 | OPTS_TYPE_PT_ADD80
8644 | OPTS_TYPE_PT_ADDBITS15;
8645 kern_type = KERN_TYPE_SHA512_SLTPW;
8646 dgst_size = DGST_SIZE_8_8;
8647 parse_func = sha512s_parse_hash;
8648 sort_by_digest = sort_by_digest_8_8;
8649 opti_type = OPTI_TYPE_ZERO_BYTE
8650 | OPTI_TYPE_PRECOMPUTE_INIT
8651 | OPTI_TYPE_PRECOMPUTE_MERKLE
8652 | OPTI_TYPE_EARLY_SKIP
8653 | OPTI_TYPE_NOT_ITERATED
8654 | OPTI_TYPE_PREPENDED_SALT
8655 | OPTI_TYPE_USES_BITS_64
8656 | OPTI_TYPE_RAW_HASH;
8657 dgst_pos0 = 14;
8658 dgst_pos1 = 15;
8659 dgst_pos2 = 6;
8660 dgst_pos3 = 7;
8661 break;
8662
8663 case 1722: hash_type = HASH_TYPE_SHA512;
8664 salt_type = SALT_TYPE_EMBEDDED;
8665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8666 opts_type = OPTS_TYPE_PT_GENERATE_BE
8667 | OPTS_TYPE_PT_ADD80
8668 | OPTS_TYPE_PT_ADDBITS15
8669 | OPTS_TYPE_ST_HEX;
8670 kern_type = KERN_TYPE_SHA512_SLTPW;
8671 dgst_size = DGST_SIZE_8_8;
8672 parse_func = osx512_parse_hash;
8673 sort_by_digest = sort_by_digest_8_8;
8674 opti_type = OPTI_TYPE_ZERO_BYTE
8675 | OPTI_TYPE_PRECOMPUTE_INIT
8676 | OPTI_TYPE_PRECOMPUTE_MERKLE
8677 | OPTI_TYPE_EARLY_SKIP
8678 | OPTI_TYPE_NOT_ITERATED
8679 | OPTI_TYPE_PREPENDED_SALT
8680 | OPTI_TYPE_USES_BITS_64
8681 | OPTI_TYPE_RAW_HASH;
8682 dgst_pos0 = 14;
8683 dgst_pos1 = 15;
8684 dgst_pos2 = 6;
8685 dgst_pos3 = 7;
8686 break;
8687
8688 case 1730: hash_type = HASH_TYPE_SHA512;
8689 salt_type = SALT_TYPE_INTERN;
8690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8691 opts_type = OPTS_TYPE_PT_GENERATE_BE
8692 | OPTS_TYPE_PT_UNICODE
8693 | OPTS_TYPE_ST_ADD80
8694 | OPTS_TYPE_ST_ADDBITS15;
8695 kern_type = KERN_TYPE_SHA512_PWSLTU;
8696 dgst_size = DGST_SIZE_8_8;
8697 parse_func = sha512s_parse_hash;
8698 sort_by_digest = sort_by_digest_8_8;
8699 opti_type = OPTI_TYPE_ZERO_BYTE
8700 | OPTI_TYPE_PRECOMPUTE_INIT
8701 | OPTI_TYPE_PRECOMPUTE_MERKLE
8702 | OPTI_TYPE_EARLY_SKIP
8703 | OPTI_TYPE_NOT_ITERATED
8704 | OPTI_TYPE_APPENDED_SALT
8705 | OPTI_TYPE_USES_BITS_64
8706 | OPTI_TYPE_RAW_HASH;
8707 dgst_pos0 = 14;
8708 dgst_pos1 = 15;
8709 dgst_pos2 = 6;
8710 dgst_pos3 = 7;
8711 break;
8712
8713 case 1731: hash_type = HASH_TYPE_SHA512;
8714 salt_type = SALT_TYPE_EMBEDDED;
8715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8716 opts_type = OPTS_TYPE_PT_GENERATE_BE
8717 | OPTS_TYPE_PT_UNICODE
8718 | OPTS_TYPE_ST_ADD80
8719 | OPTS_TYPE_ST_ADDBITS15
8720 | OPTS_TYPE_ST_HEX;
8721 kern_type = KERN_TYPE_SHA512_PWSLTU;
8722 dgst_size = DGST_SIZE_8_8;
8723 parse_func = mssql2012_parse_hash;
8724 sort_by_digest = sort_by_digest_8_8;
8725 opti_type = OPTI_TYPE_ZERO_BYTE
8726 | OPTI_TYPE_PRECOMPUTE_INIT
8727 | OPTI_TYPE_PRECOMPUTE_MERKLE
8728 | OPTI_TYPE_EARLY_SKIP
8729 | OPTI_TYPE_NOT_ITERATED
8730 | OPTI_TYPE_APPENDED_SALT
8731 | OPTI_TYPE_USES_BITS_64
8732 | OPTI_TYPE_RAW_HASH;
8733 dgst_pos0 = 14;
8734 dgst_pos1 = 15;
8735 dgst_pos2 = 6;
8736 dgst_pos3 = 7;
8737 break;
8738
8739 case 1740: hash_type = HASH_TYPE_SHA512;
8740 salt_type = SALT_TYPE_INTERN;
8741 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8742 opts_type = OPTS_TYPE_PT_GENERATE_BE
8743 | OPTS_TYPE_PT_ADD80
8744 | OPTS_TYPE_PT_ADDBITS15
8745 | OPTS_TYPE_PT_UNICODE;
8746 kern_type = KERN_TYPE_SHA512_SLTPWU;
8747 dgst_size = DGST_SIZE_8_8;
8748 parse_func = sha512s_parse_hash;
8749 sort_by_digest = sort_by_digest_8_8;
8750 opti_type = OPTI_TYPE_ZERO_BYTE
8751 | OPTI_TYPE_PRECOMPUTE_INIT
8752 | OPTI_TYPE_PRECOMPUTE_MERKLE
8753 | OPTI_TYPE_EARLY_SKIP
8754 | OPTI_TYPE_NOT_ITERATED
8755 | OPTI_TYPE_PREPENDED_SALT
8756 | OPTI_TYPE_USES_BITS_64
8757 | OPTI_TYPE_RAW_HASH;
8758 dgst_pos0 = 14;
8759 dgst_pos1 = 15;
8760 dgst_pos2 = 6;
8761 dgst_pos3 = 7;
8762 break;
8763
8764 case 1750: hash_type = HASH_TYPE_SHA512;
8765 salt_type = SALT_TYPE_INTERN;
8766 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8767 opts_type = OPTS_TYPE_PT_GENERATE_BE
8768 | OPTS_TYPE_ST_ADD80;
8769 kern_type = KERN_TYPE_HMACSHA512_PW;
8770 dgst_size = DGST_SIZE_8_8;
8771 parse_func = hmacsha512_parse_hash;
8772 sort_by_digest = sort_by_digest_8_8;
8773 opti_type = OPTI_TYPE_ZERO_BYTE
8774 | OPTI_TYPE_USES_BITS_64
8775 | OPTI_TYPE_NOT_ITERATED;
8776 dgst_pos0 = 14;
8777 dgst_pos1 = 15;
8778 dgst_pos2 = 6;
8779 dgst_pos3 = 7;
8780 break;
8781
8782 case 1760: hash_type = HASH_TYPE_SHA512;
8783 salt_type = SALT_TYPE_INTERN;
8784 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8785 opts_type = OPTS_TYPE_PT_GENERATE_BE
8786 | OPTS_TYPE_PT_ADD80
8787 | OPTS_TYPE_PT_ADDBITS15;
8788 kern_type = KERN_TYPE_HMACSHA512_SLT;
8789 dgst_size = DGST_SIZE_8_8;
8790 parse_func = hmacsha512_parse_hash;
8791 sort_by_digest = sort_by_digest_8_8;
8792 opti_type = OPTI_TYPE_ZERO_BYTE
8793 | OPTI_TYPE_USES_BITS_64
8794 | OPTI_TYPE_NOT_ITERATED;
8795 dgst_pos0 = 14;
8796 dgst_pos1 = 15;
8797 dgst_pos2 = 6;
8798 dgst_pos3 = 7;
8799 break;
8800
8801 case 1800: hash_type = HASH_TYPE_SHA512;
8802 salt_type = SALT_TYPE_EMBEDDED;
8803 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8804 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8805 kern_type = KERN_TYPE_SHA512CRYPT;
8806 dgst_size = DGST_SIZE_8_8;
8807 parse_func = sha512crypt_parse_hash;
8808 sort_by_digest = sort_by_digest_8_8;
8809 opti_type = OPTI_TYPE_ZERO_BYTE
8810 | OPTI_TYPE_USES_BITS_64;
8811 dgst_pos0 = 0;
8812 dgst_pos1 = 1;
8813 dgst_pos2 = 2;
8814 dgst_pos3 = 3;
8815 break;
8816
8817 case 2000: hash_type = HASH_TYPE_STDOUT;
8818 salt_type = SALT_TYPE_NONE;
8819 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8820 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8821 kern_type = KERN_TYPE_STDOUT;
8822 dgst_size = DGST_SIZE_4_4;
8823 parse_func = NULL;
8824 sort_by_digest = NULL;
8825 opti_type = 0;
8826 dgst_pos0 = 0;
8827 dgst_pos1 = 0;
8828 dgst_pos2 = 0;
8829 dgst_pos3 = 0;
8830 break;
8831
8832 case 2100: hash_type = HASH_TYPE_DCC2;
8833 salt_type = SALT_TYPE_EMBEDDED;
8834 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8835 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8836 | OPTS_TYPE_ST_LOWER
8837 | OPTS_TYPE_ST_UNICODE;
8838 kern_type = KERN_TYPE_DCC2;
8839 dgst_size = DGST_SIZE_4_4;
8840 parse_func = dcc2_parse_hash;
8841 sort_by_digest = sort_by_digest_4_4;
8842 opti_type = OPTI_TYPE_ZERO_BYTE
8843 | OPTI_TYPE_SLOW_HASH_SIMD;
8844 dgst_pos0 = 0;
8845 dgst_pos1 = 1;
8846 dgst_pos2 = 2;
8847 dgst_pos3 = 3;
8848 break;
8849
8850 case 2400: hash_type = HASH_TYPE_MD5;
8851 salt_type = SALT_TYPE_NONE;
8852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8853 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8854 kern_type = KERN_TYPE_MD5PIX;
8855 dgst_size = DGST_SIZE_4_4;
8856 parse_func = md5pix_parse_hash;
8857 sort_by_digest = sort_by_digest_4_4;
8858 opti_type = OPTI_TYPE_ZERO_BYTE
8859 | OPTI_TYPE_PRECOMPUTE_INIT
8860 | OPTI_TYPE_PRECOMPUTE_MERKLE
8861 | OPTI_TYPE_EARLY_SKIP
8862 | OPTI_TYPE_NOT_ITERATED
8863 | OPTI_TYPE_NOT_SALTED;
8864 dgst_pos0 = 0;
8865 dgst_pos1 = 3;
8866 dgst_pos2 = 2;
8867 dgst_pos3 = 1;
8868 break;
8869
8870 case 2410: hash_type = HASH_TYPE_MD5;
8871 salt_type = SALT_TYPE_INTERN;
8872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8873 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8874 kern_type = KERN_TYPE_MD5ASA;
8875 dgst_size = DGST_SIZE_4_4;
8876 parse_func = md5asa_parse_hash;
8877 sort_by_digest = sort_by_digest_4_4;
8878 opti_type = OPTI_TYPE_ZERO_BYTE
8879 | OPTI_TYPE_PRECOMPUTE_INIT
8880 | OPTI_TYPE_PRECOMPUTE_MERKLE
8881 | OPTI_TYPE_EARLY_SKIP
8882 | OPTI_TYPE_NOT_ITERATED;
8883 dgst_pos0 = 0;
8884 dgst_pos1 = 3;
8885 dgst_pos2 = 2;
8886 dgst_pos3 = 1;
8887 break;
8888
8889 case 2500: hash_type = HASH_TYPE_WPA;
8890 salt_type = SALT_TYPE_EMBEDDED;
8891 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8892 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8893 kern_type = KERN_TYPE_WPA;
8894 dgst_size = DGST_SIZE_4_4;
8895 parse_func = wpa_parse_hash;
8896 sort_by_digest = sort_by_digest_4_4;
8897 opti_type = OPTI_TYPE_ZERO_BYTE
8898 | OPTI_TYPE_SLOW_HASH_SIMD;
8899 dgst_pos0 = 0;
8900 dgst_pos1 = 1;
8901 dgst_pos2 = 2;
8902 dgst_pos3 = 3;
8903 break;
8904
8905 case 2600: hash_type = HASH_TYPE_MD5;
8906 salt_type = SALT_TYPE_VIRTUAL;
8907 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8908 opts_type = OPTS_TYPE_PT_GENERATE_LE
8909 | OPTS_TYPE_PT_ADD80
8910 | OPTS_TYPE_PT_ADDBITS14
8911 | OPTS_TYPE_ST_ADD80;
8912 kern_type = KERN_TYPE_MD55_PWSLT1;
8913 dgst_size = DGST_SIZE_4_4;
8914 parse_func = md5md5_parse_hash;
8915 sort_by_digest = sort_by_digest_4_4;
8916 opti_type = OPTI_TYPE_ZERO_BYTE
8917 | OPTI_TYPE_PRECOMPUTE_INIT
8918 | OPTI_TYPE_PRECOMPUTE_MERKLE
8919 | OPTI_TYPE_EARLY_SKIP;
8920 dgst_pos0 = 0;
8921 dgst_pos1 = 3;
8922 dgst_pos2 = 2;
8923 dgst_pos3 = 1;
8924 break;
8925
8926 case 2611: hash_type = HASH_TYPE_MD5;
8927 salt_type = SALT_TYPE_INTERN;
8928 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8929 opts_type = OPTS_TYPE_PT_GENERATE_LE
8930 | OPTS_TYPE_PT_ADD80
8931 | OPTS_TYPE_PT_ADDBITS14
8932 | OPTS_TYPE_ST_ADD80;
8933 kern_type = KERN_TYPE_MD55_PWSLT1;
8934 dgst_size = DGST_SIZE_4_4;
8935 parse_func = vb3_parse_hash;
8936 sort_by_digest = sort_by_digest_4_4;
8937 opti_type = OPTI_TYPE_ZERO_BYTE
8938 | OPTI_TYPE_PRECOMPUTE_INIT
8939 | OPTI_TYPE_PRECOMPUTE_MERKLE
8940 | OPTI_TYPE_EARLY_SKIP;
8941 dgst_pos0 = 0;
8942 dgst_pos1 = 3;
8943 dgst_pos2 = 2;
8944 dgst_pos3 = 1;
8945 break;
8946
8947 case 2612: hash_type = HASH_TYPE_MD5;
8948 salt_type = SALT_TYPE_EMBEDDED;
8949 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8950 opts_type = OPTS_TYPE_PT_GENERATE_LE
8951 | OPTS_TYPE_PT_ADD80
8952 | OPTS_TYPE_PT_ADDBITS14
8953 | OPTS_TYPE_ST_ADD80
8954 | OPTS_TYPE_ST_HEX;
8955 kern_type = KERN_TYPE_MD55_PWSLT1;
8956 dgst_size = DGST_SIZE_4_4;
8957 parse_func = phps_parse_hash;
8958 sort_by_digest = sort_by_digest_4_4;
8959 opti_type = OPTI_TYPE_ZERO_BYTE
8960 | OPTI_TYPE_PRECOMPUTE_INIT
8961 | OPTI_TYPE_PRECOMPUTE_MERKLE
8962 | OPTI_TYPE_EARLY_SKIP;
8963 dgst_pos0 = 0;
8964 dgst_pos1 = 3;
8965 dgst_pos2 = 2;
8966 dgst_pos3 = 1;
8967 break;
8968
8969 case 2711: hash_type = HASH_TYPE_MD5;
8970 salt_type = SALT_TYPE_INTERN;
8971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8972 opts_type = OPTS_TYPE_PT_GENERATE_LE
8973 | OPTS_TYPE_PT_ADD80
8974 | OPTS_TYPE_PT_ADDBITS14
8975 | OPTS_TYPE_ST_ADD80;
8976 kern_type = KERN_TYPE_MD55_PWSLT2;
8977 dgst_size = DGST_SIZE_4_4;
8978 parse_func = vb30_parse_hash;
8979 sort_by_digest = sort_by_digest_4_4;
8980 opti_type = OPTI_TYPE_ZERO_BYTE
8981 | OPTI_TYPE_PRECOMPUTE_INIT
8982 | OPTI_TYPE_EARLY_SKIP;
8983 dgst_pos0 = 0;
8984 dgst_pos1 = 3;
8985 dgst_pos2 = 2;
8986 dgst_pos3 = 1;
8987 break;
8988
8989 case 2811: hash_type = HASH_TYPE_MD5;
8990 salt_type = SALT_TYPE_INTERN;
8991 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8992 opts_type = OPTS_TYPE_PT_GENERATE_LE
8993 | OPTS_TYPE_PT_ADD80
8994 | OPTS_TYPE_PT_ADDBITS14;
8995 kern_type = KERN_TYPE_MD55_SLTPW;
8996 dgst_size = DGST_SIZE_4_4;
8997 parse_func = ipb2_parse_hash;
8998 sort_by_digest = sort_by_digest_4_4;
8999 opti_type = OPTI_TYPE_ZERO_BYTE
9000 | OPTI_TYPE_PRECOMPUTE_INIT
9001 | OPTI_TYPE_EARLY_SKIP;
9002 dgst_pos0 = 0;
9003 dgst_pos1 = 3;
9004 dgst_pos2 = 2;
9005 dgst_pos3 = 1;
9006 break;
9007
9008 case 3000: hash_type = HASH_TYPE_LM;
9009 salt_type = SALT_TYPE_NONE;
9010 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9011 opts_type = OPTS_TYPE_PT_GENERATE_LE
9012 | OPTS_TYPE_PT_UPPER
9013 | OPTS_TYPE_PT_BITSLICE;
9014 kern_type = KERN_TYPE_LM;
9015 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9016 parse_func = lm_parse_hash;
9017 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9018 opti_type = OPTI_TYPE_ZERO_BYTE
9019 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9020 dgst_pos0 = 0;
9021 dgst_pos1 = 1;
9022 dgst_pos2 = 2;
9023 dgst_pos3 = 3;
9024 break;
9025
9026 case 3100: hash_type = HASH_TYPE_ORACLEH;
9027 salt_type = SALT_TYPE_INTERN;
9028 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9029 opts_type = OPTS_TYPE_PT_GENERATE_LE
9030 | OPTS_TYPE_PT_UPPER
9031 | OPTS_TYPE_ST_UPPER;
9032 kern_type = KERN_TYPE_ORACLEH;
9033 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9034 parse_func = oracleh_parse_hash;
9035 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9036 opti_type = OPTI_TYPE_ZERO_BYTE;
9037 dgst_pos0 = 0;
9038 dgst_pos1 = 1;
9039 dgst_pos2 = 2;
9040 dgst_pos3 = 3;
9041 break;
9042
9043 case 3200: hash_type = HASH_TYPE_BCRYPT;
9044 salt_type = SALT_TYPE_EMBEDDED;
9045 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9046 opts_type = OPTS_TYPE_PT_GENERATE_LE
9047 | OPTS_TYPE_ST_GENERATE_LE;
9048 kern_type = KERN_TYPE_BCRYPT;
9049 dgst_size = DGST_SIZE_4_6;
9050 parse_func = bcrypt_parse_hash;
9051 sort_by_digest = sort_by_digest_4_6;
9052 opti_type = OPTI_TYPE_ZERO_BYTE;
9053 dgst_pos0 = 0;
9054 dgst_pos1 = 1;
9055 dgst_pos2 = 2;
9056 dgst_pos3 = 3;
9057 break;
9058
9059 case 3710: hash_type = HASH_TYPE_MD5;
9060 salt_type = SALT_TYPE_INTERN;
9061 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9062 opts_type = OPTS_TYPE_PT_GENERATE_LE
9063 | OPTS_TYPE_PT_ADD80
9064 | OPTS_TYPE_PT_ADDBITS14;
9065 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9066 dgst_size = DGST_SIZE_4_4;
9067 parse_func = md5s_parse_hash;
9068 sort_by_digest = sort_by_digest_4_4;
9069 opti_type = OPTI_TYPE_ZERO_BYTE
9070 | OPTI_TYPE_PRECOMPUTE_INIT
9071 | OPTI_TYPE_PRECOMPUTE_MERKLE
9072 | OPTI_TYPE_EARLY_SKIP;
9073 dgst_pos0 = 0;
9074 dgst_pos1 = 3;
9075 dgst_pos2 = 2;
9076 dgst_pos3 = 1;
9077 break;
9078
9079 case 3711: hash_type = HASH_TYPE_MD5;
9080 salt_type = SALT_TYPE_EMBEDDED;
9081 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9082 opts_type = OPTS_TYPE_PT_GENERATE_LE
9083 | OPTS_TYPE_PT_ADD80
9084 | OPTS_TYPE_PT_ADDBITS14;
9085 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9086 dgst_size = DGST_SIZE_4_4;
9087 parse_func = mediawiki_b_parse_hash;
9088 sort_by_digest = sort_by_digest_4_4;
9089 opti_type = OPTI_TYPE_ZERO_BYTE
9090 | OPTI_TYPE_PRECOMPUTE_INIT
9091 | OPTI_TYPE_PRECOMPUTE_MERKLE
9092 | OPTI_TYPE_EARLY_SKIP;
9093 dgst_pos0 = 0;
9094 dgst_pos1 = 3;
9095 dgst_pos2 = 2;
9096 dgst_pos3 = 1;
9097 break;
9098
9099 case 3800: hash_type = HASH_TYPE_MD5;
9100 salt_type = SALT_TYPE_INTERN;
9101 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9102 opts_type = OPTS_TYPE_PT_GENERATE_LE
9103 | OPTS_TYPE_ST_ADDBITS14;
9104 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
9105 dgst_size = DGST_SIZE_4_4;
9106 parse_func = md5s_parse_hash;
9107 sort_by_digest = sort_by_digest_4_4;
9108 opti_type = OPTI_TYPE_ZERO_BYTE
9109 | OPTI_TYPE_PRECOMPUTE_INIT
9110 | OPTI_TYPE_PRECOMPUTE_MERKLE
9111 | OPTI_TYPE_EARLY_SKIP
9112 | OPTI_TYPE_NOT_ITERATED
9113 | OPTI_TYPE_RAW_HASH;
9114 dgst_pos0 = 0;
9115 dgst_pos1 = 3;
9116 dgst_pos2 = 2;
9117 dgst_pos3 = 1;
9118 break;
9119
9120 case 4300: hash_type = HASH_TYPE_MD5;
9121 salt_type = SALT_TYPE_VIRTUAL;
9122 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9123 opts_type = OPTS_TYPE_PT_GENERATE_LE
9124 | OPTS_TYPE_PT_ADD80
9125 | OPTS_TYPE_PT_ADDBITS14
9126 | OPTS_TYPE_ST_ADD80;
9127 kern_type = KERN_TYPE_MD5U5_PWSLT1;
9128 dgst_size = DGST_SIZE_4_4;
9129 parse_func = md5md5_parse_hash;
9130 sort_by_digest = sort_by_digest_4_4;
9131 opti_type = OPTI_TYPE_ZERO_BYTE
9132 | OPTI_TYPE_PRECOMPUTE_INIT
9133 | OPTI_TYPE_PRECOMPUTE_MERKLE
9134 | OPTI_TYPE_EARLY_SKIP;
9135 dgst_pos0 = 0;
9136 dgst_pos1 = 3;
9137 dgst_pos2 = 2;
9138 dgst_pos3 = 1;
9139 break;
9140
9141
9142 case 4400: hash_type = HASH_TYPE_MD5;
9143 salt_type = SALT_TYPE_NONE;
9144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9145 opts_type = OPTS_TYPE_PT_GENERATE_BE
9146 | OPTS_TYPE_PT_ADD80
9147 | OPTS_TYPE_PT_ADDBITS15;
9148 kern_type = KERN_TYPE_MD5_SHA1;
9149 dgst_size = DGST_SIZE_4_4;
9150 parse_func = md5_parse_hash;
9151 sort_by_digest = sort_by_digest_4_4;
9152 opti_type = OPTI_TYPE_ZERO_BYTE
9153 | OPTI_TYPE_PRECOMPUTE_INIT
9154 | OPTI_TYPE_PRECOMPUTE_MERKLE
9155 | OPTI_TYPE_EARLY_SKIP
9156 | OPTI_TYPE_NOT_ITERATED
9157 | OPTI_TYPE_NOT_SALTED
9158 | OPTI_TYPE_RAW_HASH;
9159 dgst_pos0 = 0;
9160 dgst_pos1 = 3;
9161 dgst_pos2 = 2;
9162 dgst_pos3 = 1;
9163 break;
9164
9165 case 4500: hash_type = HASH_TYPE_SHA1;
9166 salt_type = SALT_TYPE_NONE;
9167 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9168 opts_type = OPTS_TYPE_PT_GENERATE_BE
9169 | OPTS_TYPE_PT_ADD80
9170 | OPTS_TYPE_PT_ADDBITS15;
9171 kern_type = KERN_TYPE_SHA11;
9172 dgst_size = DGST_SIZE_4_5;
9173 parse_func = sha1_parse_hash;
9174 sort_by_digest = sort_by_digest_4_5;
9175 opti_type = OPTI_TYPE_ZERO_BYTE
9176 | OPTI_TYPE_PRECOMPUTE_INIT
9177 | OPTI_TYPE_PRECOMPUTE_MERKLE
9178 | OPTI_TYPE_EARLY_SKIP
9179 | OPTI_TYPE_NOT_SALTED;
9180 dgst_pos0 = 3;
9181 dgst_pos1 = 4;
9182 dgst_pos2 = 2;
9183 dgst_pos3 = 1;
9184 break;
9185
9186 case 4700: hash_type = HASH_TYPE_SHA1;
9187 salt_type = SALT_TYPE_NONE;
9188 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9189 opts_type = OPTS_TYPE_PT_GENERATE_LE
9190 | OPTS_TYPE_PT_ADD80
9191 | OPTS_TYPE_PT_ADDBITS14;
9192 kern_type = KERN_TYPE_SHA1_MD5;
9193 dgst_size = DGST_SIZE_4_5;
9194 parse_func = sha1_parse_hash;
9195 sort_by_digest = sort_by_digest_4_5;
9196 opti_type = OPTI_TYPE_ZERO_BYTE
9197 | OPTI_TYPE_PRECOMPUTE_INIT
9198 | OPTI_TYPE_PRECOMPUTE_MERKLE
9199 | OPTI_TYPE_EARLY_SKIP
9200 | OPTI_TYPE_NOT_ITERATED
9201 | OPTI_TYPE_NOT_SALTED
9202 | OPTI_TYPE_RAW_HASH;
9203 dgst_pos0 = 3;
9204 dgst_pos1 = 4;
9205 dgst_pos2 = 2;
9206 dgst_pos3 = 1;
9207 break;
9208
9209 case 4800: hash_type = HASH_TYPE_MD5;
9210 salt_type = SALT_TYPE_EMBEDDED;
9211 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9212 opts_type = OPTS_TYPE_PT_GENERATE_LE
9213 | OPTS_TYPE_PT_ADDBITS14;
9214 kern_type = KERN_TYPE_MD5_CHAP;
9215 dgst_size = DGST_SIZE_4_4;
9216 parse_func = chap_parse_hash;
9217 sort_by_digest = sort_by_digest_4_4;
9218 opti_type = OPTI_TYPE_ZERO_BYTE
9219 | OPTI_TYPE_PRECOMPUTE_INIT
9220 | OPTI_TYPE_PRECOMPUTE_MERKLE
9221 | OPTI_TYPE_MEET_IN_MIDDLE
9222 | OPTI_TYPE_EARLY_SKIP
9223 | OPTI_TYPE_NOT_ITERATED
9224 | OPTI_TYPE_RAW_HASH;
9225 dgst_pos0 = 0;
9226 dgst_pos1 = 3;
9227 dgst_pos2 = 2;
9228 dgst_pos3 = 1;
9229 break;
9230
9231 case 4900: hash_type = HASH_TYPE_SHA1;
9232 salt_type = SALT_TYPE_INTERN;
9233 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9234 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9235 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9236 dgst_size = DGST_SIZE_4_5;
9237 parse_func = sha1s_parse_hash;
9238 sort_by_digest = sort_by_digest_4_5;
9239 opti_type = OPTI_TYPE_ZERO_BYTE
9240 | OPTI_TYPE_PRECOMPUTE_INIT
9241 | OPTI_TYPE_PRECOMPUTE_MERKLE
9242 | OPTI_TYPE_EARLY_SKIP;
9243 dgst_pos0 = 3;
9244 dgst_pos1 = 4;
9245 dgst_pos2 = 2;
9246 dgst_pos3 = 1;
9247 break;
9248
9249 case 5000: hash_type = HASH_TYPE_KECCAK;
9250 salt_type = SALT_TYPE_EMBEDDED;
9251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9252 opts_type = OPTS_TYPE_PT_GENERATE_LE
9253 | OPTS_TYPE_PT_ADD01;
9254 kern_type = KERN_TYPE_KECCAK;
9255 dgst_size = DGST_SIZE_8_25;
9256 parse_func = keccak_parse_hash;
9257 sort_by_digest = sort_by_digest_8_25;
9258 opti_type = OPTI_TYPE_ZERO_BYTE
9259 | OPTI_TYPE_USES_BITS_64
9260 | OPTI_TYPE_RAW_HASH;
9261 dgst_pos0 = 2;
9262 dgst_pos1 = 3;
9263 dgst_pos2 = 4;
9264 dgst_pos3 = 5;
9265 break;
9266
9267 case 5100: hash_type = HASH_TYPE_MD5H;
9268 salt_type = SALT_TYPE_NONE;
9269 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9270 opts_type = OPTS_TYPE_PT_GENERATE_LE
9271 | OPTS_TYPE_PT_ADD80
9272 | OPTS_TYPE_PT_ADDBITS14;
9273 kern_type = KERN_TYPE_MD5H;
9274 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9275 parse_func = md5half_parse_hash;
9276 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9277 opti_type = OPTI_TYPE_ZERO_BYTE
9278 | OPTI_TYPE_RAW_HASH;
9279 dgst_pos0 = 0;
9280 dgst_pos1 = 1;
9281 dgst_pos2 = 2;
9282 dgst_pos3 = 3;
9283 break;
9284
9285 case 5200: hash_type = HASH_TYPE_SHA256;
9286 salt_type = SALT_TYPE_EMBEDDED;
9287 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9288 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9289 kern_type = KERN_TYPE_PSAFE3;
9290 dgst_size = DGST_SIZE_4_8;
9291 parse_func = psafe3_parse_hash;
9292 sort_by_digest = sort_by_digest_4_8;
9293 opti_type = OPTI_TYPE_ZERO_BYTE;
9294 dgst_pos0 = 0;
9295 dgst_pos1 = 1;
9296 dgst_pos2 = 2;
9297 dgst_pos3 = 3;
9298 break;
9299
9300 case 5300: hash_type = HASH_TYPE_MD5;
9301 salt_type = SALT_TYPE_EMBEDDED;
9302 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9303 opts_type = OPTS_TYPE_PT_GENERATE_LE
9304 | OPTS_TYPE_ST_ADD80;
9305 kern_type = KERN_TYPE_IKEPSK_MD5;
9306 dgst_size = DGST_SIZE_4_4;
9307 parse_func = ikepsk_md5_parse_hash;
9308 sort_by_digest = sort_by_digest_4_4;
9309 opti_type = OPTI_TYPE_ZERO_BYTE;
9310 dgst_pos0 = 0;
9311 dgst_pos1 = 3;
9312 dgst_pos2 = 2;
9313 dgst_pos3 = 1;
9314 break;
9315
9316 case 5400: hash_type = HASH_TYPE_SHA1;
9317 salt_type = SALT_TYPE_EMBEDDED;
9318 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9319 opts_type = OPTS_TYPE_PT_GENERATE_BE
9320 | OPTS_TYPE_ST_ADD80;
9321 kern_type = KERN_TYPE_IKEPSK_SHA1;
9322 dgst_size = DGST_SIZE_4_5;
9323 parse_func = ikepsk_sha1_parse_hash;
9324 sort_by_digest = sort_by_digest_4_5;
9325 opti_type = OPTI_TYPE_ZERO_BYTE;
9326 dgst_pos0 = 3;
9327 dgst_pos1 = 4;
9328 dgst_pos2 = 2;
9329 dgst_pos3 = 1;
9330 break;
9331
9332 case 5500: hash_type = HASH_TYPE_NETNTLM;
9333 salt_type = SALT_TYPE_EMBEDDED;
9334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9335 opts_type = OPTS_TYPE_PT_GENERATE_LE
9336 | OPTS_TYPE_PT_ADD80
9337 | OPTS_TYPE_PT_ADDBITS14
9338 | OPTS_TYPE_PT_UNICODE
9339 | OPTS_TYPE_ST_HEX;
9340 kern_type = KERN_TYPE_NETNTLMv1;
9341 dgst_size = DGST_SIZE_4_4;
9342 parse_func = netntlmv1_parse_hash;
9343 sort_by_digest = sort_by_digest_4_4;
9344 opti_type = OPTI_TYPE_ZERO_BYTE
9345 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9346 dgst_pos0 = 0;
9347 dgst_pos1 = 1;
9348 dgst_pos2 = 2;
9349 dgst_pos3 = 3;
9350 break;
9351
9352 case 5600: hash_type = HASH_TYPE_MD5;
9353 salt_type = SALT_TYPE_EMBEDDED;
9354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9355 opts_type = OPTS_TYPE_PT_GENERATE_LE
9356 | OPTS_TYPE_PT_ADD80
9357 | OPTS_TYPE_PT_ADDBITS14
9358 | OPTS_TYPE_PT_UNICODE;
9359 kern_type = KERN_TYPE_NETNTLMv2;
9360 dgst_size = DGST_SIZE_4_4;
9361 parse_func = netntlmv2_parse_hash;
9362 sort_by_digest = sort_by_digest_4_4;
9363 opti_type = OPTI_TYPE_ZERO_BYTE;
9364 dgst_pos0 = 0;
9365 dgst_pos1 = 3;
9366 dgst_pos2 = 2;
9367 dgst_pos3 = 1;
9368 break;
9369
9370 case 5700: hash_type = HASH_TYPE_SHA256;
9371 salt_type = SALT_TYPE_NONE;
9372 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9373 opts_type = OPTS_TYPE_PT_GENERATE_BE
9374 | OPTS_TYPE_PT_ADD80
9375 | OPTS_TYPE_PT_ADDBITS15;
9376 kern_type = KERN_TYPE_SHA256;
9377 dgst_size = DGST_SIZE_4_8;
9378 parse_func = cisco4_parse_hash;
9379 sort_by_digest = sort_by_digest_4_8;
9380 opti_type = OPTI_TYPE_ZERO_BYTE
9381 | OPTI_TYPE_PRECOMPUTE_INIT
9382 | OPTI_TYPE_PRECOMPUTE_MERKLE
9383 | OPTI_TYPE_EARLY_SKIP
9384 | OPTI_TYPE_NOT_ITERATED
9385 | OPTI_TYPE_NOT_SALTED
9386 | OPTI_TYPE_RAW_HASH;
9387 dgst_pos0 = 3;
9388 dgst_pos1 = 7;
9389 dgst_pos2 = 2;
9390 dgst_pos3 = 6;
9391 break;
9392
9393 case 5800: hash_type = HASH_TYPE_SHA1;
9394 salt_type = SALT_TYPE_INTERN;
9395 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9396 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9397 | OPTS_TYPE_ST_ADD80;
9398 kern_type = KERN_TYPE_ANDROIDPIN;
9399 dgst_size = DGST_SIZE_4_5;
9400 parse_func = androidpin_parse_hash;
9401 sort_by_digest = sort_by_digest_4_5;
9402 opti_type = OPTI_TYPE_ZERO_BYTE;
9403 dgst_pos0 = 0;
9404 dgst_pos1 = 1;
9405 dgst_pos2 = 2;
9406 dgst_pos3 = 3;
9407 break;
9408
9409 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9410 salt_type = SALT_TYPE_NONE;
9411 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9412 opts_type = OPTS_TYPE_PT_GENERATE_LE
9413 | OPTS_TYPE_PT_ADD80;
9414 kern_type = KERN_TYPE_RIPEMD160;
9415 dgst_size = DGST_SIZE_4_5;
9416 parse_func = ripemd160_parse_hash;
9417 sort_by_digest = sort_by_digest_4_5;
9418 opti_type = OPTI_TYPE_ZERO_BYTE;
9419 dgst_pos0 = 0;
9420 dgst_pos1 = 1;
9421 dgst_pos2 = 2;
9422 dgst_pos3 = 3;
9423 break;
9424
9425 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9426 salt_type = SALT_TYPE_NONE;
9427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9428 opts_type = OPTS_TYPE_PT_GENERATE_BE
9429 | OPTS_TYPE_PT_ADD80;
9430 kern_type = KERN_TYPE_WHIRLPOOL;
9431 dgst_size = DGST_SIZE_4_16;
9432 parse_func = whirlpool_parse_hash;
9433 sort_by_digest = sort_by_digest_4_16;
9434 opti_type = OPTI_TYPE_ZERO_BYTE;
9435 dgst_pos0 = 0;
9436 dgst_pos1 = 1;
9437 dgst_pos2 = 2;
9438 dgst_pos3 = 3;
9439 break;
9440
9441 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9442 salt_type = SALT_TYPE_EMBEDDED;
9443 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9444 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9445 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9446 dgst_size = DGST_SIZE_4_5;
9447 parse_func = truecrypt_parse_hash_2k;
9448 sort_by_digest = sort_by_digest_4_5;
9449 opti_type = OPTI_TYPE_ZERO_BYTE;
9450 dgst_pos0 = 0;
9451 dgst_pos1 = 1;
9452 dgst_pos2 = 2;
9453 dgst_pos3 = 3;
9454 break;
9455
9456 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9457 salt_type = SALT_TYPE_EMBEDDED;
9458 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9459 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9460 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9461 dgst_size = DGST_SIZE_4_5;
9462 parse_func = truecrypt_parse_hash_2k;
9463 sort_by_digest = sort_by_digest_4_5;
9464 opti_type = OPTI_TYPE_ZERO_BYTE;
9465 dgst_pos0 = 0;
9466 dgst_pos1 = 1;
9467 dgst_pos2 = 2;
9468 dgst_pos3 = 3;
9469 break;
9470
9471 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9472 salt_type = SALT_TYPE_EMBEDDED;
9473 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9474 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9475 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9476 dgst_size = DGST_SIZE_4_5;
9477 parse_func = truecrypt_parse_hash_2k;
9478 sort_by_digest = sort_by_digest_4_5;
9479 opti_type = OPTI_TYPE_ZERO_BYTE;
9480 dgst_pos0 = 0;
9481 dgst_pos1 = 1;
9482 dgst_pos2 = 2;
9483 dgst_pos3 = 3;
9484 break;
9485
9486 case 6221: hash_type = HASH_TYPE_SHA512;
9487 salt_type = SALT_TYPE_EMBEDDED;
9488 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9489 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9490 kern_type = KERN_TYPE_TCSHA512_XTS512;
9491 dgst_size = DGST_SIZE_8_8;
9492 parse_func = truecrypt_parse_hash_1k;
9493 sort_by_digest = sort_by_digest_8_8;
9494 opti_type = OPTI_TYPE_ZERO_BYTE
9495 | OPTI_TYPE_USES_BITS_64;
9496 dgst_pos0 = 0;
9497 dgst_pos1 = 1;
9498 dgst_pos2 = 2;
9499 dgst_pos3 = 3;
9500 break;
9501
9502 case 6222: hash_type = HASH_TYPE_SHA512;
9503 salt_type = SALT_TYPE_EMBEDDED;
9504 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9505 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9506 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9507 dgst_size = DGST_SIZE_8_8;
9508 parse_func = truecrypt_parse_hash_1k;
9509 sort_by_digest = sort_by_digest_8_8;
9510 opti_type = OPTI_TYPE_ZERO_BYTE
9511 | OPTI_TYPE_USES_BITS_64;
9512 dgst_pos0 = 0;
9513 dgst_pos1 = 1;
9514 dgst_pos2 = 2;
9515 dgst_pos3 = 3;
9516 break;
9517
9518 case 6223: hash_type = HASH_TYPE_SHA512;
9519 salt_type = SALT_TYPE_EMBEDDED;
9520 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9521 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9522 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9523 dgst_size = DGST_SIZE_8_8;
9524 parse_func = truecrypt_parse_hash_1k;
9525 sort_by_digest = sort_by_digest_8_8;
9526 opti_type = OPTI_TYPE_ZERO_BYTE
9527 | OPTI_TYPE_USES_BITS_64;
9528 dgst_pos0 = 0;
9529 dgst_pos1 = 1;
9530 dgst_pos2 = 2;
9531 dgst_pos3 = 3;
9532 break;
9533
9534 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9535 salt_type = SALT_TYPE_EMBEDDED;
9536 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9537 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9538 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9539 dgst_size = DGST_SIZE_4_8;
9540 parse_func = truecrypt_parse_hash_1k;
9541 sort_by_digest = sort_by_digest_4_8;
9542 opti_type = OPTI_TYPE_ZERO_BYTE;
9543 dgst_pos0 = 0;
9544 dgst_pos1 = 1;
9545 dgst_pos2 = 2;
9546 dgst_pos3 = 3;
9547 break;
9548
9549 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9550 salt_type = SALT_TYPE_EMBEDDED;
9551 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9552 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9553 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9554 dgst_size = DGST_SIZE_4_8;
9555 parse_func = truecrypt_parse_hash_1k;
9556 sort_by_digest = sort_by_digest_4_8;
9557 opti_type = OPTI_TYPE_ZERO_BYTE;
9558 dgst_pos0 = 0;
9559 dgst_pos1 = 1;
9560 dgst_pos2 = 2;
9561 dgst_pos3 = 3;
9562 break;
9563
9564 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9565 salt_type = SALT_TYPE_EMBEDDED;
9566 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9567 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9568 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9569 dgst_size = DGST_SIZE_4_8;
9570 parse_func = truecrypt_parse_hash_1k;
9571 sort_by_digest = sort_by_digest_4_8;
9572 opti_type = OPTI_TYPE_ZERO_BYTE;
9573 dgst_pos0 = 0;
9574 dgst_pos1 = 1;
9575 dgst_pos2 = 2;
9576 dgst_pos3 = 3;
9577 break;
9578
9579 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9580 salt_type = SALT_TYPE_EMBEDDED;
9581 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9582 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9583 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9584 dgst_size = DGST_SIZE_4_5;
9585 parse_func = truecrypt_parse_hash_1k;
9586 sort_by_digest = sort_by_digest_4_5;
9587 opti_type = OPTI_TYPE_ZERO_BYTE;
9588 dgst_pos0 = 0;
9589 dgst_pos1 = 1;
9590 dgst_pos2 = 2;
9591 dgst_pos3 = 3;
9592 break;
9593
9594 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9595 salt_type = SALT_TYPE_EMBEDDED;
9596 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9597 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9598 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9599 dgst_size = DGST_SIZE_4_5;
9600 parse_func = truecrypt_parse_hash_1k;
9601 sort_by_digest = sort_by_digest_4_5;
9602 opti_type = OPTI_TYPE_ZERO_BYTE;
9603 dgst_pos0 = 0;
9604 dgst_pos1 = 1;
9605 dgst_pos2 = 2;
9606 dgst_pos3 = 3;
9607 break;
9608
9609 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9610 salt_type = SALT_TYPE_EMBEDDED;
9611 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9612 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9613 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9614 dgst_size = DGST_SIZE_4_5;
9615 parse_func = truecrypt_parse_hash_1k;
9616 sort_by_digest = sort_by_digest_4_5;
9617 opti_type = OPTI_TYPE_ZERO_BYTE;
9618 dgst_pos0 = 0;
9619 dgst_pos1 = 1;
9620 dgst_pos2 = 2;
9621 dgst_pos3 = 3;
9622 break;
9623
9624 case 6300: hash_type = HASH_TYPE_MD5;
9625 salt_type = SALT_TYPE_EMBEDDED;
9626 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9627 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9628 kern_type = KERN_TYPE_MD5AIX;
9629 dgst_size = DGST_SIZE_4_4;
9630 parse_func = md5aix_parse_hash;
9631 sort_by_digest = sort_by_digest_4_4;
9632 opti_type = OPTI_TYPE_ZERO_BYTE;
9633 dgst_pos0 = 0;
9634 dgst_pos1 = 1;
9635 dgst_pos2 = 2;
9636 dgst_pos3 = 3;
9637 break;
9638
9639 case 6400: hash_type = HASH_TYPE_SHA256;
9640 salt_type = SALT_TYPE_EMBEDDED;
9641 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9642 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9643 kern_type = KERN_TYPE_SHA256AIX;
9644 dgst_size = DGST_SIZE_4_8;
9645 parse_func = sha256aix_parse_hash;
9646 sort_by_digest = sort_by_digest_4_8;
9647 opti_type = OPTI_TYPE_ZERO_BYTE;
9648 dgst_pos0 = 0;
9649 dgst_pos1 = 1;
9650 dgst_pos2 = 2;
9651 dgst_pos3 = 3;
9652 break;
9653
9654 case 6500: hash_type = HASH_TYPE_SHA512;
9655 salt_type = SALT_TYPE_EMBEDDED;
9656 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9657 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9658 kern_type = KERN_TYPE_SHA512AIX;
9659 dgst_size = DGST_SIZE_8_8;
9660 parse_func = sha512aix_parse_hash;
9661 sort_by_digest = sort_by_digest_8_8;
9662 opti_type = OPTI_TYPE_ZERO_BYTE
9663 | OPTI_TYPE_USES_BITS_64;
9664 dgst_pos0 = 0;
9665 dgst_pos1 = 1;
9666 dgst_pos2 = 2;
9667 dgst_pos3 = 3;
9668 break;
9669
9670 case 6600: hash_type = HASH_TYPE_AES;
9671 salt_type = SALT_TYPE_EMBEDDED;
9672 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9673 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9674 kern_type = KERN_TYPE_AGILEKEY;
9675 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9676 parse_func = agilekey_parse_hash;
9677 sort_by_digest = sort_by_digest_4_5;
9678 opti_type = OPTI_TYPE_ZERO_BYTE;
9679 dgst_pos0 = 0;
9680 dgst_pos1 = 1;
9681 dgst_pos2 = 2;
9682 dgst_pos3 = 3;
9683 break;
9684
9685 case 6700: hash_type = HASH_TYPE_SHA1;
9686 salt_type = SALT_TYPE_EMBEDDED;
9687 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9688 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9689 kern_type = KERN_TYPE_SHA1AIX;
9690 dgst_size = DGST_SIZE_4_5;
9691 parse_func = sha1aix_parse_hash;
9692 sort_by_digest = sort_by_digest_4_5;
9693 opti_type = OPTI_TYPE_ZERO_BYTE;
9694 dgst_pos0 = 0;
9695 dgst_pos1 = 1;
9696 dgst_pos2 = 2;
9697 dgst_pos3 = 3;
9698 break;
9699
9700 case 6800: hash_type = HASH_TYPE_AES;
9701 salt_type = SALT_TYPE_EMBEDDED;
9702 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9703 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9704 kern_type = KERN_TYPE_LASTPASS;
9705 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9706 parse_func = lastpass_parse_hash;
9707 sort_by_digest = sort_by_digest_4_8;
9708 opti_type = OPTI_TYPE_ZERO_BYTE;
9709 dgst_pos0 = 0;
9710 dgst_pos1 = 1;
9711 dgst_pos2 = 2;
9712 dgst_pos3 = 3;
9713 break;
9714
9715 case 6900: hash_type = HASH_TYPE_GOST;
9716 salt_type = SALT_TYPE_NONE;
9717 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9718 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9719 kern_type = KERN_TYPE_GOST;
9720 dgst_size = DGST_SIZE_4_8;
9721 parse_func = gost_parse_hash;
9722 sort_by_digest = sort_by_digest_4_8;
9723 opti_type = OPTI_TYPE_ZERO_BYTE;
9724 dgst_pos0 = 0;
9725 dgst_pos1 = 1;
9726 dgst_pos2 = 2;
9727 dgst_pos3 = 3;
9728 break;
9729
9730 case 7100: hash_type = HASH_TYPE_SHA512;
9731 salt_type = SALT_TYPE_EMBEDDED;
9732 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9733 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9734 kern_type = KERN_TYPE_PBKDF2_SHA512;
9735 dgst_size = DGST_SIZE_8_16;
9736 parse_func = sha512osx_parse_hash;
9737 sort_by_digest = sort_by_digest_8_16;
9738 opti_type = OPTI_TYPE_ZERO_BYTE
9739 | OPTI_TYPE_USES_BITS_64
9740 | OPTI_TYPE_SLOW_HASH_SIMD;
9741 dgst_pos0 = 0;
9742 dgst_pos1 = 1;
9743 dgst_pos2 = 2;
9744 dgst_pos3 = 3;
9745 break;
9746
9747 case 7200: hash_type = HASH_TYPE_SHA512;
9748 salt_type = SALT_TYPE_EMBEDDED;
9749 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9750 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9751 kern_type = KERN_TYPE_PBKDF2_SHA512;
9752 dgst_size = DGST_SIZE_8_16;
9753 parse_func = sha512grub_parse_hash;
9754 sort_by_digest = sort_by_digest_8_16;
9755 opti_type = OPTI_TYPE_ZERO_BYTE
9756 | OPTI_TYPE_USES_BITS_64
9757 | OPTI_TYPE_SLOW_HASH_SIMD;
9758 dgst_pos0 = 0;
9759 dgst_pos1 = 1;
9760 dgst_pos2 = 2;
9761 dgst_pos3 = 3;
9762 break;
9763
9764 case 7300: hash_type = HASH_TYPE_SHA1;
9765 salt_type = SALT_TYPE_EMBEDDED;
9766 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9767 opts_type = OPTS_TYPE_PT_GENERATE_BE
9768 | OPTS_TYPE_ST_ADD80
9769 | OPTS_TYPE_ST_ADDBITS15;
9770 kern_type = KERN_TYPE_RAKP;
9771 dgst_size = DGST_SIZE_4_5;
9772 parse_func = rakp_parse_hash;
9773 sort_by_digest = sort_by_digest_4_5;
9774 opti_type = OPTI_TYPE_ZERO_BYTE
9775 | OPTI_TYPE_NOT_ITERATED;
9776 dgst_pos0 = 3;
9777 dgst_pos1 = 4;
9778 dgst_pos2 = 2;
9779 dgst_pos3 = 1;
9780 break;
9781
9782 case 7400: hash_type = HASH_TYPE_SHA256;
9783 salt_type = SALT_TYPE_EMBEDDED;
9784 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9785 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9786 kern_type = KERN_TYPE_SHA256CRYPT;
9787 dgst_size = DGST_SIZE_4_8;
9788 parse_func = sha256crypt_parse_hash;
9789 sort_by_digest = sort_by_digest_4_8;
9790 opti_type = OPTI_TYPE_ZERO_BYTE;
9791 dgst_pos0 = 0;
9792 dgst_pos1 = 1;
9793 dgst_pos2 = 2;
9794 dgst_pos3 = 3;
9795 break;
9796
9797 case 7500: hash_type = HASH_TYPE_KRB5PA;
9798 salt_type = SALT_TYPE_EMBEDDED;
9799 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9800 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9801 kern_type = KERN_TYPE_KRB5PA;
9802 dgst_size = DGST_SIZE_4_4;
9803 parse_func = krb5pa_parse_hash;
9804 sort_by_digest = sort_by_digest_4_4;
9805 opti_type = OPTI_TYPE_ZERO_BYTE
9806 | OPTI_TYPE_NOT_ITERATED;
9807 dgst_pos0 = 0;
9808 dgst_pos1 = 1;
9809 dgst_pos2 = 2;
9810 dgst_pos3 = 3;
9811 break;
9812
9813 case 7600: hash_type = HASH_TYPE_SHA1;
9814 salt_type = SALT_TYPE_INTERN;
9815 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9816 opts_type = OPTS_TYPE_PT_GENERATE_BE
9817 | OPTS_TYPE_PT_ADD80
9818 | OPTS_TYPE_PT_ADDBITS15;
9819 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9820 dgst_size = DGST_SIZE_4_5;
9821 parse_func = redmine_parse_hash;
9822 sort_by_digest = sort_by_digest_4_5;
9823 opti_type = OPTI_TYPE_ZERO_BYTE
9824 | OPTI_TYPE_PRECOMPUTE_INIT
9825 | OPTI_TYPE_EARLY_SKIP
9826 | OPTI_TYPE_NOT_ITERATED
9827 | OPTI_TYPE_PREPENDED_SALT;
9828 dgst_pos0 = 3;
9829 dgst_pos1 = 4;
9830 dgst_pos2 = 2;
9831 dgst_pos3 = 1;
9832 break;
9833
9834 case 7700: hash_type = HASH_TYPE_SAPB;
9835 salt_type = SALT_TYPE_EMBEDDED;
9836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9837 opts_type = OPTS_TYPE_PT_GENERATE_LE
9838 | OPTS_TYPE_PT_UPPER
9839 | OPTS_TYPE_ST_UPPER;
9840 kern_type = KERN_TYPE_SAPB;
9841 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9842 parse_func = sapb_parse_hash;
9843 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9844 opti_type = OPTI_TYPE_ZERO_BYTE
9845 | OPTI_TYPE_PRECOMPUTE_INIT
9846 | OPTI_TYPE_NOT_ITERATED;
9847 dgst_pos0 = 0;
9848 dgst_pos1 = 1;
9849 dgst_pos2 = 2;
9850 dgst_pos3 = 3;
9851 break;
9852
9853 case 7800: hash_type = HASH_TYPE_SAPG;
9854 salt_type = SALT_TYPE_EMBEDDED;
9855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9856 opts_type = OPTS_TYPE_PT_GENERATE_BE
9857 | OPTS_TYPE_ST_ADD80
9858 | OPTS_TYPE_ST_UPPER;
9859 kern_type = KERN_TYPE_SAPG;
9860 dgst_size = DGST_SIZE_4_5;
9861 parse_func = sapg_parse_hash;
9862 sort_by_digest = sort_by_digest_4_5;
9863 opti_type = OPTI_TYPE_ZERO_BYTE
9864 | OPTI_TYPE_PRECOMPUTE_INIT
9865 | OPTI_TYPE_NOT_ITERATED;
9866 dgst_pos0 = 3;
9867 dgst_pos1 = 4;
9868 dgst_pos2 = 2;
9869 dgst_pos3 = 1;
9870 break;
9871
9872 case 7900: hash_type = HASH_TYPE_SHA512;
9873 salt_type = SALT_TYPE_EMBEDDED;
9874 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9875 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9876 kern_type = KERN_TYPE_DRUPAL7;
9877 dgst_size = DGST_SIZE_8_8;
9878 parse_func = drupal7_parse_hash;
9879 sort_by_digest = sort_by_digest_8_8;
9880 opti_type = OPTI_TYPE_ZERO_BYTE
9881 | OPTI_TYPE_USES_BITS_64;
9882 dgst_pos0 = 0;
9883 dgst_pos1 = 1;
9884 dgst_pos2 = 2;
9885 dgst_pos3 = 3;
9886 break;
9887
9888 case 8000: hash_type = HASH_TYPE_SHA256;
9889 salt_type = SALT_TYPE_EMBEDDED;
9890 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9891 opts_type = OPTS_TYPE_PT_GENERATE_BE
9892 | OPTS_TYPE_PT_UNICODE
9893 | OPTS_TYPE_ST_ADD80
9894 | OPTS_TYPE_ST_HEX;
9895 kern_type = KERN_TYPE_SYBASEASE;
9896 dgst_size = DGST_SIZE_4_8;
9897 parse_func = sybasease_parse_hash;
9898 sort_by_digest = sort_by_digest_4_8;
9899 opti_type = OPTI_TYPE_ZERO_BYTE
9900 | OPTI_TYPE_PRECOMPUTE_INIT
9901 | OPTI_TYPE_EARLY_SKIP
9902 | OPTI_TYPE_NOT_ITERATED
9903 | OPTI_TYPE_RAW_HASH;
9904 dgst_pos0 = 3;
9905 dgst_pos1 = 7;
9906 dgst_pos2 = 2;
9907 dgst_pos3 = 6;
9908 break;
9909
9910 case 8100: hash_type = HASH_TYPE_SHA1;
9911 salt_type = SALT_TYPE_EMBEDDED;
9912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9913 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9914 kern_type = KERN_TYPE_NETSCALER;
9915 dgst_size = DGST_SIZE_4_5;
9916 parse_func = netscaler_parse_hash;
9917 sort_by_digest = sort_by_digest_4_5;
9918 opti_type = OPTI_TYPE_ZERO_BYTE
9919 | OPTI_TYPE_PRECOMPUTE_INIT
9920 | OPTI_TYPE_PRECOMPUTE_MERKLE
9921 | OPTI_TYPE_EARLY_SKIP
9922 | OPTI_TYPE_NOT_ITERATED
9923 | OPTI_TYPE_PREPENDED_SALT
9924 | OPTI_TYPE_RAW_HASH;
9925 dgst_pos0 = 3;
9926 dgst_pos1 = 4;
9927 dgst_pos2 = 2;
9928 dgst_pos3 = 1;
9929 break;
9930
9931 case 8200: hash_type = HASH_TYPE_SHA256;
9932 salt_type = SALT_TYPE_EMBEDDED;
9933 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9934 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9935 kern_type = KERN_TYPE_CLOUDKEY;
9936 dgst_size = DGST_SIZE_4_8;
9937 parse_func = cloudkey_parse_hash;
9938 sort_by_digest = sort_by_digest_4_8;
9939 opti_type = OPTI_TYPE_ZERO_BYTE;
9940 dgst_pos0 = 0;
9941 dgst_pos1 = 1;
9942 dgst_pos2 = 2;
9943 dgst_pos3 = 3;
9944 break;
9945
9946 case 8300: hash_type = HASH_TYPE_SHA1;
9947 salt_type = SALT_TYPE_EMBEDDED;
9948 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9949 opts_type = OPTS_TYPE_PT_GENERATE_BE
9950 | OPTS_TYPE_ST_HEX
9951 | OPTS_TYPE_ST_ADD80;
9952 kern_type = KERN_TYPE_NSEC3;
9953 dgst_size = DGST_SIZE_4_5;
9954 parse_func = nsec3_parse_hash;
9955 sort_by_digest = sort_by_digest_4_5;
9956 opti_type = OPTI_TYPE_ZERO_BYTE;
9957 dgst_pos0 = 3;
9958 dgst_pos1 = 4;
9959 dgst_pos2 = 2;
9960 dgst_pos3 = 1;
9961 break;
9962
9963 case 8400: hash_type = HASH_TYPE_SHA1;
9964 salt_type = SALT_TYPE_INTERN;
9965 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9966 opts_type = OPTS_TYPE_PT_GENERATE_BE
9967 | OPTS_TYPE_PT_ADD80
9968 | OPTS_TYPE_PT_ADDBITS15;
9969 kern_type = KERN_TYPE_WBB3;
9970 dgst_size = DGST_SIZE_4_5;
9971 parse_func = wbb3_parse_hash;
9972 sort_by_digest = sort_by_digest_4_5;
9973 opti_type = OPTI_TYPE_ZERO_BYTE
9974 | OPTI_TYPE_PRECOMPUTE_INIT
9975 | OPTI_TYPE_NOT_ITERATED;
9976 dgst_pos0 = 3;
9977 dgst_pos1 = 4;
9978 dgst_pos2 = 2;
9979 dgst_pos3 = 1;
9980 break;
9981
9982 case 8500: hash_type = HASH_TYPE_DESRACF;
9983 salt_type = SALT_TYPE_EMBEDDED;
9984 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9985 opts_type = OPTS_TYPE_PT_GENERATE_LE
9986 | OPTS_TYPE_ST_UPPER;
9987 kern_type = KERN_TYPE_RACF;
9988 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9989 parse_func = racf_parse_hash;
9990 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9991 opti_type = OPTI_TYPE_ZERO_BYTE
9992 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9993 dgst_pos0 = 0;
9994 dgst_pos1 = 1;
9995 dgst_pos2 = 2;
9996 dgst_pos3 = 3;
9997 break;
9998
9999 case 8600: hash_type = HASH_TYPE_LOTUS5;
10000 salt_type = SALT_TYPE_NONE;
10001 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10002 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10003 kern_type = KERN_TYPE_LOTUS5;
10004 dgst_size = DGST_SIZE_4_4;
10005 parse_func = lotus5_parse_hash;
10006 sort_by_digest = sort_by_digest_4_4;
10007 opti_type = OPTI_TYPE_EARLY_SKIP
10008 | OPTI_TYPE_NOT_ITERATED
10009 | OPTI_TYPE_NOT_SALTED
10010 | OPTI_TYPE_RAW_HASH;
10011 dgst_pos0 = 0;
10012 dgst_pos1 = 1;
10013 dgst_pos2 = 2;
10014 dgst_pos3 = 3;
10015 break;
10016
10017 case 8700: hash_type = HASH_TYPE_LOTUS6;
10018 salt_type = SALT_TYPE_EMBEDDED;
10019 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10020 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10021 kern_type = KERN_TYPE_LOTUS6;
10022 dgst_size = DGST_SIZE_4_4;
10023 parse_func = lotus6_parse_hash;
10024 sort_by_digest = sort_by_digest_4_4;
10025 opti_type = OPTI_TYPE_EARLY_SKIP
10026 | OPTI_TYPE_NOT_ITERATED
10027 | OPTI_TYPE_RAW_HASH;
10028 dgst_pos0 = 0;
10029 dgst_pos1 = 1;
10030 dgst_pos2 = 2;
10031 dgst_pos3 = 3;
10032 break;
10033
10034 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
10035 salt_type = SALT_TYPE_EMBEDDED;
10036 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10037 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10038 kern_type = KERN_TYPE_ANDROIDFDE;
10039 dgst_size = DGST_SIZE_4_4;
10040 parse_func = androidfde_parse_hash;
10041 sort_by_digest = sort_by_digest_4_4;
10042 opti_type = OPTI_TYPE_ZERO_BYTE;
10043 dgst_pos0 = 0;
10044 dgst_pos1 = 1;
10045 dgst_pos2 = 2;
10046 dgst_pos3 = 3;
10047 break;
10048
10049 case 8900: hash_type = HASH_TYPE_SCRYPT;
10050 salt_type = SALT_TYPE_EMBEDDED;
10051 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10052 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10053 kern_type = KERN_TYPE_SCRYPT;
10054 dgst_size = DGST_SIZE_4_8;
10055 parse_func = scrypt_parse_hash;
10056 sort_by_digest = sort_by_digest_4_8;
10057 opti_type = OPTI_TYPE_ZERO_BYTE;
10058 dgst_pos0 = 0;
10059 dgst_pos1 = 1;
10060 dgst_pos2 = 2;
10061 dgst_pos3 = 3;
10062 break;
10063
10064 case 9000: hash_type = HASH_TYPE_SHA1;
10065 salt_type = SALT_TYPE_EMBEDDED;
10066 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10067 opts_type = OPTS_TYPE_PT_GENERATE_LE
10068 | OPTS_TYPE_ST_GENERATE_LE;
10069 kern_type = KERN_TYPE_PSAFE2;
10070 dgst_size = DGST_SIZE_4_5;
10071 parse_func = psafe2_parse_hash;
10072 sort_by_digest = sort_by_digest_4_5;
10073 opti_type = OPTI_TYPE_ZERO_BYTE;
10074 dgst_pos0 = 0;
10075 dgst_pos1 = 1;
10076 dgst_pos2 = 2;
10077 dgst_pos3 = 3;
10078 break;
10079
10080 case 9100: hash_type = HASH_TYPE_LOTUS8;
10081 salt_type = SALT_TYPE_EMBEDDED;
10082 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10083 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10084 kern_type = KERN_TYPE_LOTUS8;
10085 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10086 parse_func = lotus8_parse_hash;
10087 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10088 opti_type = OPTI_TYPE_ZERO_BYTE;
10089 dgst_pos0 = 0;
10090 dgst_pos1 = 1;
10091 dgst_pos2 = 2;
10092 dgst_pos3 = 3;
10093 break;
10094
10095 case 9200: hash_type = HASH_TYPE_SHA256;
10096 salt_type = SALT_TYPE_EMBEDDED;
10097 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10098 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10099 kern_type = KERN_TYPE_PBKDF2_SHA256;
10100 dgst_size = DGST_SIZE_4_32;
10101 parse_func = cisco8_parse_hash;
10102 sort_by_digest = sort_by_digest_4_32;
10103 opti_type = OPTI_TYPE_ZERO_BYTE
10104 | OPTI_TYPE_SLOW_HASH_SIMD;
10105 dgst_pos0 = 0;
10106 dgst_pos1 = 1;
10107 dgst_pos2 = 2;
10108 dgst_pos3 = 3;
10109 break;
10110
10111 case 9300: hash_type = HASH_TYPE_SCRYPT;
10112 salt_type = SALT_TYPE_EMBEDDED;
10113 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10114 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10115 kern_type = KERN_TYPE_SCRYPT;
10116 dgst_size = DGST_SIZE_4_8;
10117 parse_func = cisco9_parse_hash;
10118 sort_by_digest = sort_by_digest_4_8;
10119 opti_type = OPTI_TYPE_ZERO_BYTE;
10120 dgst_pos0 = 0;
10121 dgst_pos1 = 1;
10122 dgst_pos2 = 2;
10123 dgst_pos3 = 3;
10124 break;
10125
10126 case 9400: hash_type = HASH_TYPE_OFFICE2007;
10127 salt_type = SALT_TYPE_EMBEDDED;
10128 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10129 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10130 kern_type = KERN_TYPE_OFFICE2007;
10131 dgst_size = DGST_SIZE_4_4;
10132 parse_func = office2007_parse_hash;
10133 sort_by_digest = sort_by_digest_4_4;
10134 opti_type = OPTI_TYPE_ZERO_BYTE;
10135 dgst_pos0 = 0;
10136 dgst_pos1 = 1;
10137 dgst_pos2 = 2;
10138 dgst_pos3 = 3;
10139 break;
10140
10141 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10142 salt_type = SALT_TYPE_EMBEDDED;
10143 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10144 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10145 kern_type = KERN_TYPE_OFFICE2010;
10146 dgst_size = DGST_SIZE_4_4;
10147 parse_func = office2010_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 9600: hash_type = HASH_TYPE_OFFICE2013;
10157 salt_type = SALT_TYPE_EMBEDDED;
10158 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10159 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10160 kern_type = KERN_TYPE_OFFICE2013;
10161 dgst_size = DGST_SIZE_4_4;
10162 parse_func = office2013_parse_hash;
10163 sort_by_digest = sort_by_digest_4_4;
10164 opti_type = OPTI_TYPE_ZERO_BYTE;
10165 dgst_pos0 = 0;
10166 dgst_pos1 = 1;
10167 dgst_pos2 = 2;
10168 dgst_pos3 = 3;
10169 break;
10170
10171 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10172 salt_type = SALT_TYPE_EMBEDDED;
10173 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10174 opts_type = OPTS_TYPE_PT_GENERATE_LE
10175 | OPTS_TYPE_PT_ADD80
10176 | OPTS_TYPE_PT_UNICODE;
10177 kern_type = KERN_TYPE_OLDOFFICE01;
10178 dgst_size = DGST_SIZE_4_4;
10179 parse_func = oldoffice01_parse_hash;
10180 sort_by_digest = sort_by_digest_4_4;
10181 opti_type = OPTI_TYPE_ZERO_BYTE
10182 | OPTI_TYPE_PRECOMPUTE_INIT
10183 | OPTI_TYPE_NOT_ITERATED;
10184 dgst_pos0 = 0;
10185 dgst_pos1 = 1;
10186 dgst_pos2 = 2;
10187 dgst_pos3 = 3;
10188 break;
10189
10190 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10191 salt_type = SALT_TYPE_EMBEDDED;
10192 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10193 opts_type = OPTS_TYPE_PT_GENERATE_LE
10194 | OPTS_TYPE_PT_ADD80;
10195 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10196 dgst_size = DGST_SIZE_4_4;
10197 parse_func = oldoffice01cm1_parse_hash;
10198 sort_by_digest = sort_by_digest_4_4;
10199 opti_type = OPTI_TYPE_ZERO_BYTE
10200 | OPTI_TYPE_PRECOMPUTE_INIT
10201 | OPTI_TYPE_NOT_ITERATED;
10202 dgst_pos0 = 0;
10203 dgst_pos1 = 1;
10204 dgst_pos2 = 2;
10205 dgst_pos3 = 3;
10206 break;
10207
10208 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10209 salt_type = SALT_TYPE_EMBEDDED;
10210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10211 opts_type = OPTS_TYPE_PT_GENERATE_LE
10212 | OPTS_TYPE_PT_ADD80
10213 | OPTS_TYPE_PT_UNICODE
10214 | OPTS_TYPE_PT_NEVERCRACK;
10215 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10216 dgst_size = DGST_SIZE_4_4;
10217 parse_func = oldoffice01cm2_parse_hash;
10218 sort_by_digest = sort_by_digest_4_4;
10219 opti_type = OPTI_TYPE_ZERO_BYTE
10220 | OPTI_TYPE_PRECOMPUTE_INIT
10221 | OPTI_TYPE_NOT_ITERATED;
10222 dgst_pos0 = 0;
10223 dgst_pos1 = 1;
10224 dgst_pos2 = 2;
10225 dgst_pos3 = 3;
10226 break;
10227
10228 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10229 salt_type = SALT_TYPE_EMBEDDED;
10230 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10231 opts_type = OPTS_TYPE_PT_GENERATE_BE
10232 | OPTS_TYPE_PT_ADD80
10233 | OPTS_TYPE_PT_UNICODE;
10234 kern_type = KERN_TYPE_OLDOFFICE34;
10235 dgst_size = DGST_SIZE_4_4;
10236 parse_func = oldoffice34_parse_hash;
10237 sort_by_digest = sort_by_digest_4_4;
10238 opti_type = OPTI_TYPE_ZERO_BYTE
10239 | OPTI_TYPE_PRECOMPUTE_INIT
10240 | OPTI_TYPE_NOT_ITERATED;
10241 dgst_pos0 = 0;
10242 dgst_pos1 = 1;
10243 dgst_pos2 = 2;
10244 dgst_pos3 = 3;
10245 break;
10246
10247 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10248 salt_type = SALT_TYPE_EMBEDDED;
10249 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10250 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10251 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10252 dgst_size = DGST_SIZE_4_4;
10253 parse_func = oldoffice34cm1_parse_hash;
10254 sort_by_digest = sort_by_digest_4_4;
10255 opti_type = OPTI_TYPE_ZERO_BYTE
10256 | OPTI_TYPE_PRECOMPUTE_INIT
10257 | OPTI_TYPE_NOT_ITERATED;
10258 dgst_pos0 = 0;
10259 dgst_pos1 = 1;
10260 dgst_pos2 = 2;
10261 dgst_pos3 = 3;
10262 break;
10263
10264 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10265 salt_type = SALT_TYPE_EMBEDDED;
10266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10267 opts_type = OPTS_TYPE_PT_GENERATE_BE
10268 | OPTS_TYPE_PT_ADD80
10269 | OPTS_TYPE_PT_UNICODE
10270 | OPTS_TYPE_PT_NEVERCRACK;
10271 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10272 dgst_size = DGST_SIZE_4_4;
10273 parse_func = oldoffice34cm2_parse_hash;
10274 sort_by_digest = sort_by_digest_4_4;
10275 opti_type = OPTI_TYPE_ZERO_BYTE
10276 | OPTI_TYPE_PRECOMPUTE_INIT
10277 | OPTI_TYPE_NOT_ITERATED;
10278 dgst_pos0 = 0;
10279 dgst_pos1 = 1;
10280 dgst_pos2 = 2;
10281 dgst_pos3 = 3;
10282 break;
10283
10284 case 9900: hash_type = HASH_TYPE_MD5;
10285 salt_type = SALT_TYPE_NONE;
10286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10287 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10288 kern_type = KERN_TYPE_RADMIN2;
10289 dgst_size = DGST_SIZE_4_4;
10290 parse_func = radmin2_parse_hash;
10291 sort_by_digest = sort_by_digest_4_4;
10292 opti_type = OPTI_TYPE_ZERO_BYTE
10293 | OPTI_TYPE_PRECOMPUTE_INIT
10294 | OPTI_TYPE_EARLY_SKIP
10295 | OPTI_TYPE_NOT_ITERATED
10296 | OPTI_TYPE_NOT_SALTED;
10297 dgst_pos0 = 0;
10298 dgst_pos1 = 3;
10299 dgst_pos2 = 2;
10300 dgst_pos3 = 1;
10301 break;
10302
10303 case 10000: hash_type = HASH_TYPE_SHA256;
10304 salt_type = SALT_TYPE_EMBEDDED;
10305 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10306 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10307 kern_type = KERN_TYPE_PBKDF2_SHA256;
10308 dgst_size = DGST_SIZE_4_32;
10309 parse_func = djangopbkdf2_parse_hash;
10310 sort_by_digest = sort_by_digest_4_32;
10311 opti_type = OPTI_TYPE_ZERO_BYTE
10312 | OPTI_TYPE_SLOW_HASH_SIMD;
10313 dgst_pos0 = 0;
10314 dgst_pos1 = 1;
10315 dgst_pos2 = 2;
10316 dgst_pos3 = 3;
10317 break;
10318
10319 case 10100: hash_type = HASH_TYPE_SIPHASH;
10320 salt_type = SALT_TYPE_EMBEDDED;
10321 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10322 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10323 kern_type = KERN_TYPE_SIPHASH;
10324 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10325 parse_func = siphash_parse_hash;
10326 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10327 opti_type = OPTI_TYPE_ZERO_BYTE
10328 | OPTI_TYPE_NOT_ITERATED
10329 | OPTI_TYPE_RAW_HASH;
10330 dgst_pos0 = 0;
10331 dgst_pos1 = 1;
10332 dgst_pos2 = 2;
10333 dgst_pos3 = 3;
10334 break;
10335
10336 case 10200: hash_type = HASH_TYPE_MD5;
10337 salt_type = SALT_TYPE_EMBEDDED;
10338 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10339 opts_type = OPTS_TYPE_PT_GENERATE_LE
10340 | OPTS_TYPE_ST_ADD80
10341 | OPTS_TYPE_ST_ADDBITS14;
10342 kern_type = KERN_TYPE_HMACMD5_PW;
10343 dgst_size = DGST_SIZE_4_4;
10344 parse_func = crammd5_parse_hash;
10345 sort_by_digest = sort_by_digest_4_4;
10346 opti_type = OPTI_TYPE_ZERO_BYTE
10347 | OPTI_TYPE_NOT_ITERATED;
10348 dgst_pos0 = 0;
10349 dgst_pos1 = 3;
10350 dgst_pos2 = 2;
10351 dgst_pos3 = 1;
10352 break;
10353
10354 case 10300: hash_type = HASH_TYPE_SHA1;
10355 salt_type = SALT_TYPE_EMBEDDED;
10356 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10357 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10358 kern_type = KERN_TYPE_SAPH_SHA1;
10359 dgst_size = DGST_SIZE_4_5;
10360 parse_func = saph_sha1_parse_hash;
10361 sort_by_digest = sort_by_digest_4_5;
10362 opti_type = OPTI_TYPE_ZERO_BYTE;
10363 dgst_pos0 = 0;
10364 dgst_pos1 = 1;
10365 dgst_pos2 = 2;
10366 dgst_pos3 = 3;
10367 break;
10368
10369 case 10400: hash_type = HASH_TYPE_PDFU16;
10370 salt_type = SALT_TYPE_EMBEDDED;
10371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10372 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10373 kern_type = KERN_TYPE_PDF11;
10374 dgst_size = DGST_SIZE_4_4;
10375 parse_func = pdf11_parse_hash;
10376 sort_by_digest = sort_by_digest_4_4;
10377 opti_type = OPTI_TYPE_ZERO_BYTE
10378 | OPTI_TYPE_NOT_ITERATED;
10379 dgst_pos0 = 0;
10380 dgst_pos1 = 1;
10381 dgst_pos2 = 2;
10382 dgst_pos3 = 3;
10383 break;
10384
10385 case 10410: hash_type = HASH_TYPE_PDFU16;
10386 salt_type = SALT_TYPE_EMBEDDED;
10387 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10388 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10389 kern_type = KERN_TYPE_PDF11CM1;
10390 dgst_size = DGST_SIZE_4_4;
10391 parse_func = pdf11cm1_parse_hash;
10392 sort_by_digest = sort_by_digest_4_4;
10393 opti_type = OPTI_TYPE_ZERO_BYTE
10394 | OPTI_TYPE_NOT_ITERATED;
10395 dgst_pos0 = 0;
10396 dgst_pos1 = 1;
10397 dgst_pos2 = 2;
10398 dgst_pos3 = 3;
10399 break;
10400
10401 case 10420: hash_type = HASH_TYPE_PDFU16;
10402 salt_type = SALT_TYPE_EMBEDDED;
10403 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10404 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10405 kern_type = KERN_TYPE_PDF11CM2;
10406 dgst_size = DGST_SIZE_4_4;
10407 parse_func = pdf11cm2_parse_hash;
10408 sort_by_digest = sort_by_digest_4_4;
10409 opti_type = OPTI_TYPE_ZERO_BYTE
10410 | OPTI_TYPE_NOT_ITERATED;
10411 dgst_pos0 = 0;
10412 dgst_pos1 = 1;
10413 dgst_pos2 = 2;
10414 dgst_pos3 = 3;
10415 break;
10416
10417 case 10500: hash_type = HASH_TYPE_PDFU16;
10418 salt_type = SALT_TYPE_EMBEDDED;
10419 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10420 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10421 kern_type = KERN_TYPE_PDF14;
10422 dgst_size = DGST_SIZE_4_4;
10423 parse_func = pdf14_parse_hash;
10424 sort_by_digest = sort_by_digest_4_4;
10425 opti_type = OPTI_TYPE_ZERO_BYTE
10426 | OPTI_TYPE_NOT_ITERATED;
10427 dgst_pos0 = 0;
10428 dgst_pos1 = 1;
10429 dgst_pos2 = 2;
10430 dgst_pos3 = 3;
10431 break;
10432
10433 case 10600: hash_type = HASH_TYPE_SHA256;
10434 salt_type = SALT_TYPE_EMBEDDED;
10435 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10436 opts_type = OPTS_TYPE_PT_GENERATE_BE
10437 | OPTS_TYPE_ST_ADD80
10438 | OPTS_TYPE_ST_ADDBITS15
10439 | OPTS_TYPE_HASH_COPY;
10440 kern_type = KERN_TYPE_SHA256_PWSLT;
10441 dgst_size = DGST_SIZE_4_8;
10442 parse_func = pdf17l3_parse_hash;
10443 sort_by_digest = sort_by_digest_4_8;
10444 opti_type = OPTI_TYPE_ZERO_BYTE
10445 | OPTI_TYPE_PRECOMPUTE_INIT
10446 | OPTI_TYPE_PRECOMPUTE_MERKLE
10447 | OPTI_TYPE_EARLY_SKIP
10448 | OPTI_TYPE_NOT_ITERATED
10449 | OPTI_TYPE_APPENDED_SALT
10450 | OPTI_TYPE_RAW_HASH;
10451 dgst_pos0 = 3;
10452 dgst_pos1 = 7;
10453 dgst_pos2 = 2;
10454 dgst_pos3 = 6;
10455 break;
10456
10457 case 10700: hash_type = HASH_TYPE_PDFU32;
10458 salt_type = SALT_TYPE_EMBEDDED;
10459 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10460 opts_type = OPTS_TYPE_PT_GENERATE_LE
10461 | OPTS_TYPE_HASH_COPY;
10462 kern_type = KERN_TYPE_PDF17L8;
10463 dgst_size = DGST_SIZE_4_8;
10464 parse_func = pdf17l8_parse_hash;
10465 sort_by_digest = sort_by_digest_4_8;
10466 opti_type = OPTI_TYPE_ZERO_BYTE
10467 | OPTI_TYPE_NOT_ITERATED;
10468 dgst_pos0 = 0;
10469 dgst_pos1 = 1;
10470 dgst_pos2 = 2;
10471 dgst_pos3 = 3;
10472 break;
10473
10474 case 10800: hash_type = HASH_TYPE_SHA384;
10475 salt_type = SALT_TYPE_NONE;
10476 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10477 opts_type = OPTS_TYPE_PT_GENERATE_BE
10478 | OPTS_TYPE_PT_ADD80
10479 | OPTS_TYPE_PT_ADDBITS15;
10480 kern_type = KERN_TYPE_SHA384;
10481 dgst_size = DGST_SIZE_8_8;
10482 parse_func = sha384_parse_hash;
10483 sort_by_digest = sort_by_digest_8_8;
10484 opti_type = OPTI_TYPE_ZERO_BYTE
10485 | OPTI_TYPE_PRECOMPUTE_INIT
10486 | OPTI_TYPE_PRECOMPUTE_MERKLE
10487 | OPTI_TYPE_EARLY_SKIP
10488 | OPTI_TYPE_NOT_ITERATED
10489 | OPTI_TYPE_NOT_SALTED
10490 | OPTI_TYPE_USES_BITS_64
10491 | OPTI_TYPE_RAW_HASH;
10492 dgst_pos0 = 6;
10493 dgst_pos1 = 7;
10494 dgst_pos2 = 4;
10495 dgst_pos3 = 5;
10496 break;
10497
10498 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10499 salt_type = SALT_TYPE_EMBEDDED;
10500 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10501 opts_type = OPTS_TYPE_PT_GENERATE_LE
10502 | OPTS_TYPE_ST_BASE64
10503 | OPTS_TYPE_HASH_COPY;
10504 kern_type = KERN_TYPE_PBKDF2_SHA256;
10505 dgst_size = DGST_SIZE_4_32;
10506 parse_func = pbkdf2_sha256_parse_hash;
10507 sort_by_digest = sort_by_digest_4_32;
10508 opti_type = OPTI_TYPE_ZERO_BYTE
10509 | OPTI_TYPE_SLOW_HASH_SIMD;
10510 dgst_pos0 = 0;
10511 dgst_pos1 = 1;
10512 dgst_pos2 = 2;
10513 dgst_pos3 = 3;
10514 break;
10515
10516 case 11000: hash_type = HASH_TYPE_MD5;
10517 salt_type = SALT_TYPE_INTERN;
10518 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10519 opts_type = OPTS_TYPE_PT_GENERATE_LE
10520 | OPTS_TYPE_PT_ADD80;
10521 kern_type = KERN_TYPE_PRESTASHOP;
10522 dgst_size = DGST_SIZE_4_4;
10523 parse_func = prestashop_parse_hash;
10524 sort_by_digest = sort_by_digest_4_4;
10525 opti_type = OPTI_TYPE_ZERO_BYTE
10526 | OPTI_TYPE_PRECOMPUTE_INIT
10527 | OPTI_TYPE_NOT_ITERATED
10528 | OPTI_TYPE_PREPENDED_SALT;
10529 dgst_pos0 = 0;
10530 dgst_pos1 = 3;
10531 dgst_pos2 = 2;
10532 dgst_pos3 = 1;
10533 break;
10534
10535 case 11100: hash_type = HASH_TYPE_MD5;
10536 salt_type = SALT_TYPE_EMBEDDED;
10537 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10538 opts_type = OPTS_TYPE_PT_GENERATE_LE
10539 | OPTS_TYPE_ST_ADD80;
10540 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10541 dgst_size = DGST_SIZE_4_4;
10542 parse_func = postgresql_auth_parse_hash;
10543 sort_by_digest = sort_by_digest_4_4;
10544 opti_type = OPTI_TYPE_ZERO_BYTE
10545 | OPTI_TYPE_PRECOMPUTE_INIT
10546 | OPTI_TYPE_PRECOMPUTE_MERKLE
10547 | OPTI_TYPE_EARLY_SKIP;
10548 dgst_pos0 = 0;
10549 dgst_pos1 = 3;
10550 dgst_pos2 = 2;
10551 dgst_pos3 = 1;
10552 break;
10553
10554 case 11200: hash_type = HASH_TYPE_SHA1;
10555 salt_type = SALT_TYPE_EMBEDDED;
10556 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10557 opts_type = OPTS_TYPE_PT_GENERATE_BE
10558 | OPTS_TYPE_PT_ADD80
10559 | OPTS_TYPE_ST_HEX;
10560 kern_type = KERN_TYPE_MYSQL_AUTH;
10561 dgst_size = DGST_SIZE_4_5;
10562 parse_func = mysql_auth_parse_hash;
10563 sort_by_digest = sort_by_digest_4_5;
10564 opti_type = OPTI_TYPE_ZERO_BYTE
10565 | OPTI_TYPE_EARLY_SKIP;
10566 dgst_pos0 = 3;
10567 dgst_pos1 = 4;
10568 dgst_pos2 = 2;
10569 dgst_pos3 = 1;
10570 break;
10571
10572 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10573 salt_type = SALT_TYPE_EMBEDDED;
10574 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10575 opts_type = OPTS_TYPE_PT_GENERATE_LE
10576 | OPTS_TYPE_ST_HEX
10577 | OPTS_TYPE_ST_ADD80;
10578 kern_type = KERN_TYPE_BITCOIN_WALLET;
10579 dgst_size = DGST_SIZE_4_4;
10580 parse_func = bitcoin_wallet_parse_hash;
10581 sort_by_digest = sort_by_digest_4_4;
10582 opti_type = OPTI_TYPE_ZERO_BYTE;
10583 dgst_pos0 = 0;
10584 dgst_pos1 = 1;
10585 dgst_pos2 = 2;
10586 dgst_pos3 = 3;
10587 break;
10588
10589 case 11400: hash_type = HASH_TYPE_MD5;
10590 salt_type = SALT_TYPE_EMBEDDED;
10591 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10592 opts_type = OPTS_TYPE_PT_GENERATE_LE
10593 | OPTS_TYPE_PT_ADD80
10594 | OPTS_TYPE_HASH_COPY;
10595 kern_type = KERN_TYPE_SIP_AUTH;
10596 dgst_size = DGST_SIZE_4_4;
10597 parse_func = sip_auth_parse_hash;
10598 sort_by_digest = sort_by_digest_4_4;
10599 opti_type = OPTI_TYPE_ZERO_BYTE;
10600 dgst_pos0 = 0;
10601 dgst_pos1 = 3;
10602 dgst_pos2 = 2;
10603 dgst_pos3 = 1;
10604 break;
10605
10606 case 11500: hash_type = HASH_TYPE_CRC32;
10607 salt_type = SALT_TYPE_INTERN;
10608 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10609 opts_type = OPTS_TYPE_PT_GENERATE_LE
10610 | OPTS_TYPE_ST_GENERATE_LE
10611 | OPTS_TYPE_ST_HEX;
10612 kern_type = KERN_TYPE_CRC32;
10613 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10614 parse_func = crc32_parse_hash;
10615 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10616 opti_type = OPTI_TYPE_ZERO_BYTE;
10617 dgst_pos0 = 0;
10618 dgst_pos1 = 1;
10619 dgst_pos2 = 2;
10620 dgst_pos3 = 3;
10621 break;
10622
10623 case 11600: hash_type = HASH_TYPE_AES;
10624 salt_type = SALT_TYPE_EMBEDDED;
10625 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10626 opts_type = OPTS_TYPE_PT_GENERATE_LE
10627 | OPTS_TYPE_PT_NEVERCRACK;
10628 kern_type = KERN_TYPE_SEVEN_ZIP;
10629 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10630 parse_func = seven_zip_parse_hash;
10631 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10632 opti_type = OPTI_TYPE_ZERO_BYTE;
10633 dgst_pos0 = 0;
10634 dgst_pos1 = 1;
10635 dgst_pos2 = 2;
10636 dgst_pos3 = 3;
10637 break;
10638
10639 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10640 salt_type = SALT_TYPE_NONE;
10641 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10642 opts_type = OPTS_TYPE_PT_GENERATE_LE
10643 | OPTS_TYPE_PT_ADD01;
10644 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10645 dgst_size = DGST_SIZE_4_8;
10646 parse_func = gost2012sbog_256_parse_hash;
10647 sort_by_digest = sort_by_digest_4_8;
10648 opti_type = OPTI_TYPE_ZERO_BYTE;
10649 dgst_pos0 = 0;
10650 dgst_pos1 = 1;
10651 dgst_pos2 = 2;
10652 dgst_pos3 = 3;
10653 break;
10654
10655 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10656 salt_type = SALT_TYPE_NONE;
10657 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10658 opts_type = OPTS_TYPE_PT_GENERATE_LE
10659 | OPTS_TYPE_PT_ADD01;
10660 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10661 dgst_size = DGST_SIZE_4_16;
10662 parse_func = gost2012sbog_512_parse_hash;
10663 sort_by_digest = sort_by_digest_4_16;
10664 opti_type = OPTI_TYPE_ZERO_BYTE;
10665 dgst_pos0 = 0;
10666 dgst_pos1 = 1;
10667 dgst_pos2 = 2;
10668 dgst_pos3 = 3;
10669 break;
10670
10671 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10672 salt_type = SALT_TYPE_EMBEDDED;
10673 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10674 opts_type = OPTS_TYPE_PT_GENERATE_LE
10675 | OPTS_TYPE_ST_BASE64
10676 | OPTS_TYPE_HASH_COPY;
10677 kern_type = KERN_TYPE_PBKDF2_MD5;
10678 dgst_size = DGST_SIZE_4_32;
10679 parse_func = pbkdf2_md5_parse_hash;
10680 sort_by_digest = sort_by_digest_4_32;
10681 opti_type = OPTI_TYPE_ZERO_BYTE
10682 | OPTI_TYPE_SLOW_HASH_SIMD;
10683 dgst_pos0 = 0;
10684 dgst_pos1 = 1;
10685 dgst_pos2 = 2;
10686 dgst_pos3 = 3;
10687 break;
10688
10689 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10690 salt_type = SALT_TYPE_EMBEDDED;
10691 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10692 opts_type = OPTS_TYPE_PT_GENERATE_LE
10693 | OPTS_TYPE_ST_BASE64
10694 | OPTS_TYPE_HASH_COPY;
10695 kern_type = KERN_TYPE_PBKDF2_SHA1;
10696 dgst_size = DGST_SIZE_4_32;
10697 parse_func = pbkdf2_sha1_parse_hash;
10698 sort_by_digest = sort_by_digest_4_32;
10699 opti_type = OPTI_TYPE_ZERO_BYTE
10700 | OPTI_TYPE_SLOW_HASH_SIMD;
10701 dgst_pos0 = 0;
10702 dgst_pos1 = 1;
10703 dgst_pos2 = 2;
10704 dgst_pos3 = 3;
10705 break;
10706
10707 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10708 salt_type = SALT_TYPE_EMBEDDED;
10709 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10710 opts_type = OPTS_TYPE_PT_GENERATE_LE
10711 | OPTS_TYPE_ST_BASE64
10712 | OPTS_TYPE_HASH_COPY;
10713 kern_type = KERN_TYPE_PBKDF2_SHA512;
10714 dgst_size = DGST_SIZE_8_16;
10715 parse_func = pbkdf2_sha512_parse_hash;
10716 sort_by_digest = sort_by_digest_8_16;
10717 opti_type = OPTI_TYPE_ZERO_BYTE
10718 | OPTI_TYPE_USES_BITS_64
10719 | OPTI_TYPE_SLOW_HASH_SIMD;
10720 dgst_pos0 = 0;
10721 dgst_pos1 = 1;
10722 dgst_pos2 = 2;
10723 dgst_pos3 = 3;
10724 break;
10725
10726 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10727 salt_type = SALT_TYPE_EMBEDDED;
10728 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10729 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10730 kern_type = KERN_TYPE_ECRYPTFS;
10731 dgst_size = DGST_SIZE_8_8;
10732 parse_func = ecryptfs_parse_hash;
10733 sort_by_digest = sort_by_digest_8_8;
10734 opti_type = OPTI_TYPE_ZERO_BYTE
10735 | OPTI_TYPE_USES_BITS_64;
10736 dgst_pos0 = 0;
10737 dgst_pos1 = 1;
10738 dgst_pos2 = 2;
10739 dgst_pos3 = 3;
10740 break;
10741
10742 case 12300: hash_type = HASH_TYPE_ORACLET;
10743 salt_type = SALT_TYPE_EMBEDDED;
10744 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10745 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10746 kern_type = KERN_TYPE_ORACLET;
10747 dgst_size = DGST_SIZE_8_16;
10748 parse_func = oraclet_parse_hash;
10749 sort_by_digest = sort_by_digest_8_16;
10750 opti_type = OPTI_TYPE_ZERO_BYTE
10751 | OPTI_TYPE_USES_BITS_64;
10752 dgst_pos0 = 0;
10753 dgst_pos1 = 1;
10754 dgst_pos2 = 2;
10755 dgst_pos3 = 3;
10756 break;
10757
10758 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10759 salt_type = SALT_TYPE_EMBEDDED;
10760 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10761 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10762 kern_type = KERN_TYPE_BSDICRYPT;
10763 dgst_size = DGST_SIZE_4_4;
10764 parse_func = bsdicrypt_parse_hash;
10765 sort_by_digest = sort_by_digest_4_4;
10766 opti_type = OPTI_TYPE_ZERO_BYTE
10767 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10768 dgst_pos0 = 0;
10769 dgst_pos1 = 1;
10770 dgst_pos2 = 2;
10771 dgst_pos3 = 3;
10772 break;
10773
10774 case 12500: hash_type = HASH_TYPE_RAR3HP;
10775 salt_type = SALT_TYPE_EMBEDDED;
10776 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10777 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10778 kern_type = KERN_TYPE_RAR3;
10779 dgst_size = DGST_SIZE_4_4;
10780 parse_func = rar3hp_parse_hash;
10781 sort_by_digest = sort_by_digest_4_4;
10782 opti_type = OPTI_TYPE_ZERO_BYTE;
10783 dgst_pos0 = 0;
10784 dgst_pos1 = 1;
10785 dgst_pos2 = 2;
10786 dgst_pos3 = 3;
10787 break;
10788
10789 case 12600: hash_type = HASH_TYPE_SHA256;
10790 salt_type = SALT_TYPE_INTERN;
10791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10792 opts_type = OPTS_TYPE_PT_GENERATE_BE
10793 | OPTS_TYPE_PT_ADD80;
10794 kern_type = KERN_TYPE_CF10;
10795 dgst_size = DGST_SIZE_4_8;
10796 parse_func = cf10_parse_hash;
10797 sort_by_digest = sort_by_digest_4_8;
10798 opti_type = OPTI_TYPE_ZERO_BYTE
10799 | OPTI_TYPE_PRECOMPUTE_INIT
10800 | OPTI_TYPE_EARLY_SKIP
10801 | OPTI_TYPE_NOT_ITERATED;
10802 dgst_pos0 = 3;
10803 dgst_pos1 = 7;
10804 dgst_pos2 = 2;
10805 dgst_pos3 = 6;
10806 break;
10807
10808 case 12700: hash_type = HASH_TYPE_AES;
10809 salt_type = SALT_TYPE_EMBEDDED;
10810 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10811 opts_type = OPTS_TYPE_PT_GENERATE_LE
10812 | OPTS_TYPE_HASH_COPY;
10813 kern_type = KERN_TYPE_MYWALLET;
10814 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10815 parse_func = mywallet_parse_hash;
10816 sort_by_digest = sort_by_digest_4_5;
10817 opti_type = OPTI_TYPE_ZERO_BYTE;
10818 dgst_pos0 = 0;
10819 dgst_pos1 = 1;
10820 dgst_pos2 = 2;
10821 dgst_pos3 = 3;
10822 break;
10823
10824 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10825 salt_type = SALT_TYPE_EMBEDDED;
10826 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10827 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10828 kern_type = KERN_TYPE_MS_DRSR;
10829 dgst_size = DGST_SIZE_4_8;
10830 parse_func = ms_drsr_parse_hash;
10831 sort_by_digest = sort_by_digest_4_8;
10832 opti_type = OPTI_TYPE_ZERO_BYTE;
10833 dgst_pos0 = 0;
10834 dgst_pos1 = 1;
10835 dgst_pos2 = 2;
10836 dgst_pos3 = 3;
10837 break;
10838
10839 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10840 salt_type = SALT_TYPE_EMBEDDED;
10841 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10842 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10843 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10844 dgst_size = DGST_SIZE_4_8;
10845 parse_func = androidfde_samsung_parse_hash;
10846 sort_by_digest = sort_by_digest_4_8;
10847 opti_type = OPTI_TYPE_ZERO_BYTE;
10848 dgst_pos0 = 0;
10849 dgst_pos1 = 1;
10850 dgst_pos2 = 2;
10851 dgst_pos3 = 3;
10852 break;
10853
10854 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10855 salt_type = SALT_TYPE_EMBEDDED;
10856 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10857 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10858 kern_type = KERN_TYPE_RAR5;
10859 dgst_size = DGST_SIZE_4_4;
10860 parse_func = rar5_parse_hash;
10861 sort_by_digest = sort_by_digest_4_4;
10862 opti_type = OPTI_TYPE_ZERO_BYTE;
10863 dgst_pos0 = 0;
10864 dgst_pos1 = 1;
10865 dgst_pos2 = 2;
10866 dgst_pos3 = 3;
10867 break;
10868
10869 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10870 salt_type = SALT_TYPE_EMBEDDED;
10871 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10872 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10873 kern_type = KERN_TYPE_KRB5TGS;
10874 dgst_size = DGST_SIZE_4_4;
10875 parse_func = krb5tgs_parse_hash;
10876 sort_by_digest = sort_by_digest_4_4;
10877 opti_type = OPTI_TYPE_ZERO_BYTE
10878 | OPTI_TYPE_NOT_ITERATED;
10879 dgst_pos0 = 0;
10880 dgst_pos1 = 1;
10881 dgst_pos2 = 2;
10882 dgst_pos3 = 3;
10883 break;
10884
10885 case 13200: hash_type = HASH_TYPE_AES;
10886 salt_type = SALT_TYPE_EMBEDDED;
10887 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10888 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10889 kern_type = KERN_TYPE_AXCRYPT;
10890 dgst_size = DGST_SIZE_4_4;
10891 parse_func = axcrypt_parse_hash;
10892 sort_by_digest = sort_by_digest_4_4;
10893 opti_type = OPTI_TYPE_ZERO_BYTE;
10894 dgst_pos0 = 0;
10895 dgst_pos1 = 1;
10896 dgst_pos2 = 2;
10897 dgst_pos3 = 3;
10898 break;
10899
10900 case 13300: hash_type = HASH_TYPE_SHA1;
10901 salt_type = SALT_TYPE_NONE;
10902 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10903 opts_type = OPTS_TYPE_PT_GENERATE_BE
10904 | OPTS_TYPE_PT_ADD80
10905 | OPTS_TYPE_PT_ADDBITS15;
10906 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10907 dgst_size = DGST_SIZE_4_5;
10908 parse_func = sha1axcrypt_parse_hash;
10909 sort_by_digest = sort_by_digest_4_5;
10910 opti_type = OPTI_TYPE_ZERO_BYTE
10911 | OPTI_TYPE_PRECOMPUTE_INIT
10912 | OPTI_TYPE_EARLY_SKIP
10913 | OPTI_TYPE_NOT_ITERATED
10914 | OPTI_TYPE_NOT_SALTED;
10915 dgst_pos0 = 0;
10916 dgst_pos1 = 4;
10917 dgst_pos2 = 3;
10918 dgst_pos3 = 2;
10919 break;
10920
10921 case 13400: hash_type = HASH_TYPE_AES;
10922 salt_type = SALT_TYPE_EMBEDDED;
10923 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10924 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10925 kern_type = KERN_TYPE_KEEPASS;
10926 dgst_size = DGST_SIZE_4_4;
10927 parse_func = keepass_parse_hash;
10928 sort_by_digest = sort_by_digest_4_4;
10929 opti_type = OPTI_TYPE_ZERO_BYTE;
10930 dgst_pos0 = 0;
10931 dgst_pos1 = 1;
10932 dgst_pos2 = 2;
10933 dgst_pos3 = 3;
10934 break;
10935
10936 case 13500: hash_type = HASH_TYPE_SHA1;
10937 salt_type = SALT_TYPE_EMBEDDED;
10938 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10939 opts_type = OPTS_TYPE_PT_GENERATE_BE
10940 | OPTS_TYPE_PT_UNICODE
10941 | OPTS_TYPE_PT_ADD80;
10942 kern_type = KERN_TYPE_PSTOKEN;
10943 dgst_size = DGST_SIZE_4_5;
10944 parse_func = pstoken_parse_hash;
10945 sort_by_digest = sort_by_digest_4_5;
10946 opti_type = OPTI_TYPE_ZERO_BYTE
10947 | OPTI_TYPE_PRECOMPUTE_INIT
10948 | OPTI_TYPE_EARLY_SKIP
10949 | OPTI_TYPE_NOT_ITERATED
10950 | OPTI_TYPE_PREPENDED_SALT
10951 | OPTI_TYPE_RAW_HASH;
10952 dgst_pos0 = 3;
10953 dgst_pos1 = 4;
10954 dgst_pos2 = 2;
10955 dgst_pos3 = 1;
10956 break;
10957
10958 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10959 salt_type = SALT_TYPE_EMBEDDED;
10960 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10961 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10962 kern_type = KERN_TYPE_ZIP2;
10963 dgst_size = DGST_SIZE_4_4;
10964 parse_func = zip2_parse_hash;
10965 sort_by_digest = sort_by_digest_4_4;
10966 opti_type = OPTI_TYPE_ZERO_BYTE;
10967 dgst_pos0 = 0;
10968 dgst_pos1 = 1;
10969 dgst_pos2 = 2;
10970 dgst_pos3 = 3;
10971 break;
10972
10973 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10974 salt_type = SALT_TYPE_EMBEDDED;
10975 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10976 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10977 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10978 dgst_size = DGST_SIZE_4_5;
10979 parse_func = veracrypt_parse_hash_655331;
10980 sort_by_digest = sort_by_digest_4_5;
10981 opti_type = OPTI_TYPE_ZERO_BYTE;
10982 dgst_pos0 = 0;
10983 dgst_pos1 = 1;
10984 dgst_pos2 = 2;
10985 dgst_pos3 = 3;
10986 break;
10987
10988 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10989 salt_type = SALT_TYPE_EMBEDDED;
10990 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10991 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10992 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10993 dgst_size = DGST_SIZE_4_5;
10994 parse_func = veracrypt_parse_hash_655331;
10995 sort_by_digest = sort_by_digest_4_5;
10996 opti_type = OPTI_TYPE_ZERO_BYTE;
10997 dgst_pos0 = 0;
10998 dgst_pos1 = 1;
10999 dgst_pos2 = 2;
11000 dgst_pos3 = 3;
11001 break;
11002
11003 case 13713: hash_type = HASH_TYPE_RIPEMD160;
11004 salt_type = SALT_TYPE_EMBEDDED;
11005 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11006 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11007 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11008 dgst_size = DGST_SIZE_4_5;
11009 parse_func = veracrypt_parse_hash_655331;
11010 sort_by_digest = sort_by_digest_4_5;
11011 opti_type = OPTI_TYPE_ZERO_BYTE;
11012 dgst_pos0 = 0;
11013 dgst_pos1 = 1;
11014 dgst_pos2 = 2;
11015 dgst_pos3 = 3;
11016 break;
11017
11018 case 13721: hash_type = HASH_TYPE_SHA512;
11019 salt_type = SALT_TYPE_EMBEDDED;
11020 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11021 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11022 kern_type = KERN_TYPE_TCSHA512_XTS512;
11023 dgst_size = DGST_SIZE_8_8;
11024 parse_func = veracrypt_parse_hash_500000;
11025 sort_by_digest = sort_by_digest_8_8;
11026 opti_type = OPTI_TYPE_ZERO_BYTE
11027 | OPTI_TYPE_USES_BITS_64;
11028 dgst_pos0 = 0;
11029 dgst_pos1 = 1;
11030 dgst_pos2 = 2;
11031 dgst_pos3 = 3;
11032 break;
11033
11034 case 13722: hash_type = HASH_TYPE_SHA512;
11035 salt_type = SALT_TYPE_EMBEDDED;
11036 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11037 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11038 kern_type = KERN_TYPE_TCSHA512_XTS1024;
11039 dgst_size = DGST_SIZE_8_8;
11040 parse_func = veracrypt_parse_hash_500000;
11041 sort_by_digest = sort_by_digest_8_8;
11042 opti_type = OPTI_TYPE_ZERO_BYTE
11043 | OPTI_TYPE_USES_BITS_64;
11044 dgst_pos0 = 0;
11045 dgst_pos1 = 1;
11046 dgst_pos2 = 2;
11047 dgst_pos3 = 3;
11048 break;
11049
11050 case 13723: hash_type = HASH_TYPE_SHA512;
11051 salt_type = SALT_TYPE_EMBEDDED;
11052 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11053 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11054 kern_type = KERN_TYPE_TCSHA512_XTS1536;
11055 dgst_size = DGST_SIZE_8_8;
11056 parse_func = veracrypt_parse_hash_500000;
11057 sort_by_digest = sort_by_digest_8_8;
11058 opti_type = OPTI_TYPE_ZERO_BYTE
11059 | OPTI_TYPE_USES_BITS_64;
11060 dgst_pos0 = 0;
11061 dgst_pos1 = 1;
11062 dgst_pos2 = 2;
11063 dgst_pos3 = 3;
11064 break;
11065
11066 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
11067 salt_type = SALT_TYPE_EMBEDDED;
11068 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11069 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11070 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
11071 dgst_size = DGST_SIZE_4_8;
11072 parse_func = veracrypt_parse_hash_500000;
11073 sort_by_digest = sort_by_digest_4_8;
11074 opti_type = OPTI_TYPE_ZERO_BYTE;
11075 dgst_pos0 = 0;
11076 dgst_pos1 = 1;
11077 dgst_pos2 = 2;
11078 dgst_pos3 = 3;
11079 break;
11080
11081 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
11082 salt_type = SALT_TYPE_EMBEDDED;
11083 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11084 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11085 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
11086 dgst_size = DGST_SIZE_4_8;
11087 parse_func = veracrypt_parse_hash_500000;
11088 sort_by_digest = sort_by_digest_4_8;
11089 opti_type = OPTI_TYPE_ZERO_BYTE;
11090 dgst_pos0 = 0;
11091 dgst_pos1 = 1;
11092 dgst_pos2 = 2;
11093 dgst_pos3 = 3;
11094 break;
11095
11096 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
11097 salt_type = SALT_TYPE_EMBEDDED;
11098 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11099 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11100 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
11101 dgst_size = DGST_SIZE_4_8;
11102 parse_func = veracrypt_parse_hash_500000;
11103 sort_by_digest = sort_by_digest_4_8;
11104 opti_type = OPTI_TYPE_ZERO_BYTE;
11105 dgst_pos0 = 0;
11106 dgst_pos1 = 1;
11107 dgst_pos2 = 2;
11108 dgst_pos3 = 3;
11109 break;
11110
11111 case 13741: hash_type = HASH_TYPE_RIPEMD160;
11112 salt_type = SALT_TYPE_EMBEDDED;
11113 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11114 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11115 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
11116 dgst_size = DGST_SIZE_4_5;
11117 parse_func = veracrypt_parse_hash_327661;
11118 sort_by_digest = sort_by_digest_4_5;
11119 opti_type = OPTI_TYPE_ZERO_BYTE;
11120 dgst_pos0 = 0;
11121 dgst_pos1 = 1;
11122 dgst_pos2 = 2;
11123 dgst_pos3 = 3;
11124 break;
11125
11126 case 13742: hash_type = HASH_TYPE_RIPEMD160;
11127 salt_type = SALT_TYPE_EMBEDDED;
11128 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11129 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11130 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11131 dgst_size = DGST_SIZE_4_5;
11132 parse_func = veracrypt_parse_hash_327661;
11133 sort_by_digest = sort_by_digest_4_5;
11134 opti_type = OPTI_TYPE_ZERO_BYTE;
11135 dgst_pos0 = 0;
11136 dgst_pos1 = 1;
11137 dgst_pos2 = 2;
11138 dgst_pos3 = 3;
11139 break;
11140
11141 case 13743: hash_type = HASH_TYPE_RIPEMD160;
11142 salt_type = SALT_TYPE_EMBEDDED;
11143 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11144 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11145 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11146 dgst_size = DGST_SIZE_4_5;
11147 parse_func = veracrypt_parse_hash_327661;
11148 sort_by_digest = sort_by_digest_4_5;
11149 opti_type = OPTI_TYPE_ZERO_BYTE;
11150 dgst_pos0 = 0;
11151 dgst_pos1 = 1;
11152 dgst_pos2 = 2;
11153 dgst_pos3 = 3;
11154 break;
11155
11156 case 13751: hash_type = HASH_TYPE_SHA256;
11157 salt_type = SALT_TYPE_EMBEDDED;
11158 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11159 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11160 kern_type = KERN_TYPE_VCSHA256_XTS512;
11161 dgst_size = DGST_SIZE_4_8;
11162 parse_func = veracrypt_parse_hash_500000;
11163 sort_by_digest = sort_by_digest_4_8;
11164 opti_type = OPTI_TYPE_ZERO_BYTE;
11165 dgst_pos0 = 0;
11166 dgst_pos1 = 1;
11167 dgst_pos2 = 2;
11168 dgst_pos3 = 3;
11169 break;
11170
11171 case 13752: hash_type = HASH_TYPE_SHA256;
11172 salt_type = SALT_TYPE_EMBEDDED;
11173 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11174 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11175 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11176 dgst_size = DGST_SIZE_4_8;
11177 parse_func = veracrypt_parse_hash_500000;
11178 sort_by_digest = sort_by_digest_4_8;
11179 opti_type = OPTI_TYPE_ZERO_BYTE;
11180 dgst_pos0 = 0;
11181 dgst_pos1 = 1;
11182 dgst_pos2 = 2;
11183 dgst_pos3 = 3;
11184 break;
11185
11186 case 13753: hash_type = HASH_TYPE_SHA256;
11187 salt_type = SALT_TYPE_EMBEDDED;
11188 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11189 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11190 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11191 dgst_size = DGST_SIZE_4_8;
11192 parse_func = veracrypt_parse_hash_500000;
11193 sort_by_digest = sort_by_digest_4_8;
11194 opti_type = OPTI_TYPE_ZERO_BYTE;
11195 dgst_pos0 = 0;
11196 dgst_pos1 = 1;
11197 dgst_pos2 = 2;
11198 dgst_pos3 = 3;
11199 break;
11200
11201 case 13761: hash_type = HASH_TYPE_SHA256;
11202 salt_type = SALT_TYPE_EMBEDDED;
11203 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11204 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11205 kern_type = KERN_TYPE_VCSHA256_XTS512;
11206 dgst_size = DGST_SIZE_4_8;
11207 parse_func = veracrypt_parse_hash_200000;
11208 sort_by_digest = sort_by_digest_4_8;
11209 opti_type = OPTI_TYPE_ZERO_BYTE;
11210 dgst_pos0 = 0;
11211 dgst_pos1 = 1;
11212 dgst_pos2 = 2;
11213 dgst_pos3 = 3;
11214 break;
11215
11216 case 13762: hash_type = HASH_TYPE_SHA256;
11217 salt_type = SALT_TYPE_EMBEDDED;
11218 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11219 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11220 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11221 dgst_size = DGST_SIZE_4_8;
11222 parse_func = veracrypt_parse_hash_200000;
11223 sort_by_digest = sort_by_digest_4_8;
11224 opti_type = OPTI_TYPE_ZERO_BYTE;
11225 dgst_pos0 = 0;
11226 dgst_pos1 = 1;
11227 dgst_pos2 = 2;
11228 dgst_pos3 = 3;
11229 break;
11230
11231 case 13763: hash_type = HASH_TYPE_SHA256;
11232 salt_type = SALT_TYPE_EMBEDDED;
11233 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11234 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11235 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11236 dgst_size = DGST_SIZE_4_8;
11237 parse_func = veracrypt_parse_hash_200000;
11238 sort_by_digest = sort_by_digest_4_8;
11239 opti_type = OPTI_TYPE_ZERO_BYTE;
11240 dgst_pos0 = 0;
11241 dgst_pos1 = 1;
11242 dgst_pos2 = 2;
11243 dgst_pos3 = 3;
11244 break;
11245
11246 case 13800: hash_type = HASH_TYPE_SHA256;
11247 salt_type = SALT_TYPE_EMBEDDED;
11248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11249 opts_type = OPTS_TYPE_PT_GENERATE_BE
11250 | OPTS_TYPE_PT_UNICODE;
11251 kern_type = KERN_TYPE_WIN8PHONE;
11252 dgst_size = DGST_SIZE_4_8;
11253 parse_func = win8phone_parse_hash;
11254 sort_by_digest = sort_by_digest_4_8;
11255 opti_type = OPTI_TYPE_ZERO_BYTE
11256 | OPTI_TYPE_PRECOMPUTE_INIT
11257 | OPTI_TYPE_EARLY_SKIP
11258 | OPTI_TYPE_NOT_ITERATED
11259 | OPTI_TYPE_RAW_HASH;
11260 dgst_pos0 = 3;
11261 dgst_pos1 = 7;
11262 dgst_pos2 = 2;
11263 dgst_pos3 = 6;
11264 break;
11265
11266 default: usage_mini_print (PROGNAME); return (-1);
11267 }
11268
11269 /**
11270 * parser
11271 */
11272
11273 data.parse_func = parse_func;
11274
11275 /**
11276 * misc stuff
11277 */
11278
11279 if (hex_salt)
11280 {
11281 if (salt_type == SALT_TYPE_INTERN)
11282 {
11283 opts_type |= OPTS_TYPE_ST_HEX;
11284 }
11285 else
11286 {
11287 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11288
11289 return (-1);
11290 }
11291 }
11292
11293 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11294 | (salt_type == SALT_TYPE_EXTERN)
11295 | (salt_type == SALT_TYPE_EMBEDDED)
11296 | (salt_type == SALT_TYPE_VIRTUAL));
11297
11298 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11299
11300 data.hash_type = hash_type;
11301 data.attack_mode = attack_mode;
11302 data.attack_kern = attack_kern;
11303 data.attack_exec = attack_exec;
11304 data.kern_type = kern_type;
11305 data.opts_type = opts_type;
11306 data.dgst_size = dgst_size;
11307 data.salt_type = salt_type;
11308 data.isSalted = isSalted;
11309 data.sort_by_digest = sort_by_digest;
11310 data.dgst_pos0 = dgst_pos0;
11311 data.dgst_pos1 = dgst_pos1;
11312 data.dgst_pos2 = dgst_pos2;
11313 data.dgst_pos3 = dgst_pos3;
11314
11315 esalt_size = 0;
11316
11317 switch (hash_mode)
11318 {
11319 case 2500: esalt_size = sizeof (wpa_t); break;
11320 case 5300: esalt_size = sizeof (ikepsk_t); break;
11321 case 5400: esalt_size = sizeof (ikepsk_t); break;
11322 case 5500: esalt_size = sizeof (netntlm_t); break;
11323 case 5600: esalt_size = sizeof (netntlm_t); break;
11324 case 6211: esalt_size = sizeof (tc_t); break;
11325 case 6212: esalt_size = sizeof (tc_t); break;
11326 case 6213: esalt_size = sizeof (tc_t); break;
11327 case 6221: esalt_size = sizeof (tc_t); break;
11328 case 6222: esalt_size = sizeof (tc_t); break;
11329 case 6223: esalt_size = sizeof (tc_t); break;
11330 case 6231: esalt_size = sizeof (tc_t); break;
11331 case 6232: esalt_size = sizeof (tc_t); break;
11332 case 6233: esalt_size = sizeof (tc_t); break;
11333 case 6241: esalt_size = sizeof (tc_t); break;
11334 case 6242: esalt_size = sizeof (tc_t); break;
11335 case 6243: esalt_size = sizeof (tc_t); break;
11336 case 6600: esalt_size = sizeof (agilekey_t); break;
11337 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11338 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11339 case 7300: esalt_size = sizeof (rakp_t); break;
11340 case 7500: esalt_size = sizeof (krb5pa_t); break;
11341 case 8200: esalt_size = sizeof (cloudkey_t); break;
11342 case 8800: esalt_size = sizeof (androidfde_t); break;
11343 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11344 case 9400: esalt_size = sizeof (office2007_t); break;
11345 case 9500: esalt_size = sizeof (office2010_t); break;
11346 case 9600: esalt_size = sizeof (office2013_t); break;
11347 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11348 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11349 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11350 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11351 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11352 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11353 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11354 case 10200: esalt_size = sizeof (cram_md5_t); break;
11355 case 10400: esalt_size = sizeof (pdf_t); break;
11356 case 10410: esalt_size = sizeof (pdf_t); break;
11357 case 10420: esalt_size = sizeof (pdf_t); break;
11358 case 10500: esalt_size = sizeof (pdf_t); break;
11359 case 10600: esalt_size = sizeof (pdf_t); break;
11360 case 10700: esalt_size = sizeof (pdf_t); break;
11361 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11362 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11363 case 11400: esalt_size = sizeof (sip_t); break;
11364 case 11600: esalt_size = sizeof (seven_zip_t); break;
11365 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11366 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11367 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11368 case 13000: esalt_size = sizeof (rar5_t); break;
11369 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11370 case 13400: esalt_size = sizeof (keepass_t); break;
11371 case 13500: esalt_size = sizeof (pstoken_t); break;
11372 case 13600: esalt_size = sizeof (zip2_t); break;
11373 case 13711: esalt_size = sizeof (tc_t); break;
11374 case 13712: esalt_size = sizeof (tc_t); break;
11375 case 13713: esalt_size = sizeof (tc_t); break;
11376 case 13721: esalt_size = sizeof (tc_t); break;
11377 case 13722: esalt_size = sizeof (tc_t); break;
11378 case 13723: esalt_size = sizeof (tc_t); break;
11379 case 13731: esalt_size = sizeof (tc_t); break;
11380 case 13732: esalt_size = sizeof (tc_t); break;
11381 case 13733: esalt_size = sizeof (tc_t); break;
11382 case 13741: esalt_size = sizeof (tc_t); break;
11383 case 13742: esalt_size = sizeof (tc_t); break;
11384 case 13743: esalt_size = sizeof (tc_t); break;
11385 case 13751: esalt_size = sizeof (tc_t); break;
11386 case 13752: esalt_size = sizeof (tc_t); break;
11387 case 13753: esalt_size = sizeof (tc_t); break;
11388 case 13761: esalt_size = sizeof (tc_t); break;
11389 case 13762: esalt_size = sizeof (tc_t); break;
11390 case 13763: esalt_size = sizeof (tc_t); break;
11391 case 13800: esalt_size = sizeof (win8phone_t); break;
11392 }
11393
11394 data.esalt_size = esalt_size;
11395
11396 /**
11397 * choose dictionary parser
11398 */
11399
11400 if (hash_type == HASH_TYPE_LM)
11401 {
11402 get_next_word_func = get_next_word_lm;
11403 }
11404 else if (opts_type & OPTS_TYPE_PT_UPPER)
11405 {
11406 get_next_word_func = get_next_word_uc;
11407 }
11408 else
11409 {
11410 get_next_word_func = get_next_word_std;
11411 }
11412
11413 /**
11414 * dictstat
11415 */
11416
11417 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11418
11419 #ifdef _POSIX
11420 size_t dictstat_nmemb = 0;
11421 #endif
11422
11423 #ifdef _WIN
11424 uint dictstat_nmemb = 0;
11425 #endif
11426
11427 char dictstat[256] = { 0 };
11428
11429 FILE *dictstat_fp = NULL;
11430
11431 if (keyspace == 0)
11432 {
11433 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11434
11435 dictstat_fp = fopen (dictstat, "rb");
11436
11437 if (dictstat_fp)
11438 {
11439 #ifdef _POSIX
11440 struct stat tmpstat;
11441
11442 fstat (fileno (dictstat_fp), &tmpstat);
11443 #endif
11444
11445 #ifdef _WIN
11446 struct stat64 tmpstat;
11447
11448 _fstat64 (fileno (dictstat_fp), &tmpstat);
11449 #endif
11450
11451 if (tmpstat.st_mtime < COMPTIME)
11452 {
11453 /* with v0.15 the format changed so we have to ensure user is using a good version
11454 since there is no version-header in the dictstat file */
11455
11456 fclose (dictstat_fp);
11457
11458 unlink (dictstat);
11459 }
11460 else
11461 {
11462 while (!feof (dictstat_fp))
11463 {
11464 dictstat_t d;
11465
11466 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11467
11468 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11469
11470 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11471 {
11472 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11473
11474 return -1;
11475 }
11476 }
11477
11478 fclose (dictstat_fp);
11479 }
11480 }
11481 }
11482
11483 /**
11484 * potfile
11485 */
11486
11487 char potfile[256] = { 0 };
11488
11489 if (potfile_path == NULL)
11490 {
11491 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11492 }
11493 else
11494 {
11495 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11496 }
11497
11498 data.pot_fp = NULL;
11499
11500 FILE *out_fp = NULL;
11501 FILE *pot_fp = NULL;
11502
11503 if (show == 1 || left == 1)
11504 {
11505 pot_fp = fopen (potfile, "rb");
11506
11507 if (pot_fp == NULL)
11508 {
11509 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11510
11511 return (-1);
11512 }
11513
11514 if (outfile != NULL)
11515 {
11516 if ((out_fp = fopen (outfile, "ab")) == NULL)
11517 {
11518 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11519
11520 fclose (pot_fp);
11521
11522 return (-1);
11523 }
11524 }
11525 else
11526 {
11527 out_fp = stdout;
11528 }
11529 }
11530 else
11531 {
11532 if (potfile_disable == 0)
11533 {
11534 pot_fp = fopen (potfile, "ab");
11535
11536 if (pot_fp == NULL)
11537 {
11538 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11539
11540 return (-1);
11541 }
11542
11543 data.pot_fp = pot_fp;
11544 }
11545 }
11546
11547 pot_t *pot = NULL;
11548
11549 uint pot_cnt = 0;
11550 uint pot_avail = 0;
11551
11552 if (show == 1 || left == 1)
11553 {
11554 SUPPRESS_OUTPUT = 1;
11555
11556 pot_avail = count_lines (pot_fp);
11557
11558 rewind (pot_fp);
11559
11560 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11561
11562 uint pot_hashes_avail = 0;
11563
11564 uint line_num = 0;
11565
11566 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11567
11568 while (!feof (pot_fp))
11569 {
11570 line_num++;
11571
11572 int line_len = fgetl (pot_fp, line_buf);
11573
11574 if (line_len == 0) continue;
11575
11576 char *plain_buf = line_buf + line_len;
11577
11578 pot_t *pot_ptr = &pot[pot_cnt];
11579
11580 hash_t *hashes_buf = &pot_ptr->hash;
11581
11582 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11583 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11584
11585 if (pot_cnt == pot_hashes_avail)
11586 {
11587 uint pos = 0;
11588
11589 for (pos = 0; pos < INCR_POT; pos++)
11590 {
11591 if ((pot_cnt + pos) >= pot_avail) break;
11592
11593 pot_t *tmp_pot = &pot[pot_cnt + pos];
11594
11595 hash_t *tmp_hash = &tmp_pot->hash;
11596
11597 tmp_hash->digest = mymalloc (dgst_size);
11598
11599 if (isSalted)
11600 {
11601 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11602 }
11603
11604 if (esalt_size)
11605 {
11606 tmp_hash->esalt = mymalloc (esalt_size);
11607 }
11608
11609 pot_hashes_avail++;
11610 }
11611 }
11612
11613 int plain_len = 0;
11614
11615 int parser_status;
11616
11617 int iter = MAX_CUT_TRIES;
11618
11619 do
11620 {
11621 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11622 {
11623 if (line_buf[i] == ':')
11624 {
11625 line_len--;
11626
11627 break;
11628 }
11629 }
11630
11631 if (data.hash_mode != 2500)
11632 {
11633 parser_status = parse_func (line_buf, line_len, hashes_buf);
11634 }
11635 else
11636 {
11637 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11638
11639 if (line_len > max_salt_size)
11640 {
11641 parser_status = PARSER_GLOBAL_LENGTH;
11642 }
11643 else
11644 {
11645 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11646
11647 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11648
11649 hashes_buf->salt->salt_len = line_len;
11650
11651 parser_status = PARSER_OK;
11652 }
11653 }
11654
11655 // if NOT parsed without error, we add the ":" to the plain
11656
11657 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11658 {
11659 plain_len++;
11660 plain_buf--;
11661 }
11662
11663 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11664
11665 if (parser_status < PARSER_GLOBAL_ZERO)
11666 {
11667 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11668
11669 continue;
11670 }
11671
11672 if (plain_len >= 255) continue;
11673
11674 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11675
11676 pot_ptr->plain_len = plain_len;
11677
11678 pot_cnt++;
11679 }
11680
11681 myfree (line_buf);
11682
11683 fclose (pot_fp);
11684
11685 SUPPRESS_OUTPUT = 0;
11686
11687 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11688 }
11689
11690 /**
11691 * word len
11692 */
11693
11694 uint pw_min = PW_MIN;
11695 uint pw_max = PW_MAX;
11696
11697 switch (hash_mode)
11698 {
11699 case 125: if (pw_max > 32) pw_max = 32;
11700 break;
11701 case 400: if (pw_max > 40) pw_max = 40;
11702 break;
11703 case 500: if (pw_max > 16) pw_max = 16;
11704 break;
11705 case 1500: if (pw_max > 8) pw_max = 8;
11706 break;
11707 case 1600: if (pw_max > 16) pw_max = 16;
11708 break;
11709 case 1800: if (pw_max > 16) pw_max = 16;
11710 break;
11711 case 2100: if (pw_max > 16) pw_max = 16;
11712 break;
11713 case 2500: if (pw_min < 8) pw_min = 8;
11714 break;
11715 case 3000: if (pw_max > 7) pw_max = 7;
11716 break;
11717 case 5200: if (pw_max > 24) pw_max = 24;
11718 break;
11719 case 5800: if (pw_max > 16) pw_max = 16;
11720 break;
11721 case 6300: if (pw_max > 16) pw_max = 16;
11722 break;
11723 case 7400: if (pw_max > 16) pw_max = 16;
11724 break;
11725 case 7700: if (pw_max > 8) pw_max = 8;
11726 break;
11727 case 7900: if (pw_max > 48) pw_max = 48;
11728 break;
11729 case 8500: if (pw_max > 8) pw_max = 8;
11730 break;
11731 case 8600: if (pw_max > 16) pw_max = 16;
11732 break;
11733 case 9710: pw_min = 5;
11734 pw_max = 5;
11735 break;
11736 case 9810: pw_min = 5;
11737 pw_max = 5;
11738 break;
11739 case 10410: pw_min = 5;
11740 pw_max = 5;
11741 break;
11742 case 10300: if (pw_max < 3) pw_min = 3;
11743 if (pw_max > 40) pw_max = 40;
11744 break;
11745 case 10500: if (pw_max < 3) pw_min = 3;
11746 if (pw_max > 40) pw_max = 40;
11747 break;
11748 case 10700: if (pw_max > 16) pw_max = 16;
11749 break;
11750 case 11300: if (pw_max > 40) pw_max = 40;
11751 break;
11752 case 11600: if (pw_max > 32) pw_max = 32;
11753 break;
11754 case 12500: if (pw_max > 20) pw_max = 20;
11755 break;
11756 case 12800: if (pw_max > 24) pw_max = 24;
11757 break;
11758 }
11759
11760 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11761 {
11762 switch (attack_kern)
11763 {
11764 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11765 break;
11766 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11767 break;
11768 }
11769 }
11770
11771 /**
11772 * charsets : keep them together for more easy maintainnce
11773 */
11774
11775 cs_t mp_sys[6] = { { { 0 }, 0 } };
11776 cs_t mp_usr[4] = { { { 0 }, 0 } };
11777
11778 mp_setup_sys (mp_sys);
11779
11780 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11781 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11782 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11783 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11784
11785 /**
11786 * load hashes, part I: find input mode, count hashes
11787 */
11788
11789 uint hashlist_mode = 0;
11790 uint hashlist_format = HLFMT_HASHCAT;
11791
11792 uint hashes_avail = 0;
11793
11794 if ((benchmark == 0) && (stdout_flag == 0))
11795 {
11796 struct stat f;
11797
11798 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11799
11800 if ((hash_mode == 2500) ||
11801 (hash_mode == 5200) ||
11802 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11803 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11804 (hash_mode == 9000))
11805 {
11806 hashlist_mode = HL_MODE_ARG;
11807
11808 char *hashfile = myargv[optind];
11809
11810 data.hashfile = hashfile;
11811
11812 logfile_top_var_string ("target", hashfile);
11813 }
11814
11815 if (hashlist_mode == HL_MODE_ARG)
11816 {
11817 if (hash_mode == 2500)
11818 {
11819 struct stat st;
11820
11821 if (stat (data.hashfile, &st) == -1)
11822 {
11823 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11824
11825 return (-1);
11826 }
11827
11828 hashes_avail = st.st_size / sizeof (hccap_t);
11829 }
11830 else
11831 {
11832 hashes_avail = 1;
11833 }
11834 }
11835 else if (hashlist_mode == HL_MODE_FILE)
11836 {
11837 char *hashfile = myargv[optind];
11838
11839 data.hashfile = hashfile;
11840
11841 logfile_top_var_string ("target", hashfile);
11842
11843 FILE *fp = NULL;
11844
11845 if ((fp = fopen (hashfile, "rb")) == NULL)
11846 {
11847 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11848
11849 return (-1);
11850 }
11851
11852 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11853
11854 hashes_avail = count_lines (fp);
11855
11856 rewind (fp);
11857
11858 if (hashes_avail == 0)
11859 {
11860 log_error ("ERROR: hashfile is empty or corrupt");
11861
11862 fclose (fp);
11863
11864 return (-1);
11865 }
11866
11867 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11868
11869 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11870 {
11871 log_error ("ERROR: remove not supported in native hashfile-format mode");
11872
11873 fclose (fp);
11874
11875 return (-1);
11876 }
11877
11878 fclose (fp);
11879 }
11880 }
11881 else
11882 {
11883 hashlist_mode = HL_MODE_ARG;
11884
11885 hashes_avail = 1;
11886 }
11887
11888 if (hash_mode == 3000) hashes_avail *= 2;
11889
11890 data.hashlist_mode = hashlist_mode;
11891 data.hashlist_format = hashlist_format;
11892
11893 logfile_top_uint (hashlist_mode);
11894 logfile_top_uint (hashlist_format);
11895
11896 /**
11897 * load hashes, part II: allocate required memory, set pointers
11898 */
11899
11900 hash_t *hashes_buf = NULL;
11901 void *digests_buf = NULL;
11902 salt_t *salts_buf = NULL;
11903 void *esalts_buf = NULL;
11904
11905 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11906
11907 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11908
11909 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11910 {
11911 u32 hash_pos;
11912
11913 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11914 {
11915 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11916
11917 hashes_buf[hash_pos].hash_info = hash_info;
11918
11919 if (username && (remove || show || left))
11920 {
11921 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11922 }
11923
11924 if (benchmark)
11925 {
11926 hash_info->orighash = (char *) mymalloc (256);
11927 }
11928 }
11929 }
11930
11931 if (isSalted)
11932 {
11933 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11934
11935 if (esalt_size)
11936 {
11937 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11938 }
11939 }
11940 else
11941 {
11942 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11943 }
11944
11945 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11946 {
11947 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11948
11949 if (isSalted)
11950 {
11951 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11952
11953 if (esalt_size)
11954 {
11955 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11956 }
11957 }
11958 else
11959 {
11960 hashes_buf[hash_pos].salt = &salts_buf[0];
11961 }
11962 }
11963
11964 /**
11965 * load hashes, part III: parse hashes or generate them if benchmark
11966 */
11967
11968 uint hashes_cnt = 0;
11969
11970 if (benchmark == 0)
11971 {
11972 if (keyspace == 1)
11973 {
11974 // useless to read hash file for keyspace, cheat a little bit w/ optind
11975 }
11976 else if (stdout_flag == 1)
11977 {
11978 // useless to read hash file for stdout, cheat a little bit w/ optind
11979 }
11980 else if (hashes_avail == 0)
11981 {
11982 }
11983 else if (hashlist_mode == HL_MODE_ARG)
11984 {
11985 char *input_buf = myargv[optind];
11986
11987 uint input_len = strlen (input_buf);
11988
11989 logfile_top_var_string ("target", input_buf);
11990
11991 char *hash_buf = NULL;
11992 int hash_len = 0;
11993
11994 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11995
11996 bool hash_fmt_error = 0;
11997
11998 if (hash_len < 1) hash_fmt_error = 1;
11999 if (hash_buf == NULL) hash_fmt_error = 1;
12000
12001 if (hash_fmt_error)
12002 {
12003 log_info ("WARNING: Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12004 }
12005 else
12006 {
12007 if (opts_type & OPTS_TYPE_HASH_COPY)
12008 {
12009 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12010
12011 hash_info_tmp->orighash = mystrdup (hash_buf);
12012 }
12013
12014 if (isSalted)
12015 {
12016 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
12017 }
12018
12019 int parser_status = PARSER_OK;
12020
12021 if (hash_mode == 2500)
12022 {
12023 if (hash_len == 0)
12024 {
12025 log_error ("ERROR: hccap file not specified");
12026
12027 return (-1);
12028 }
12029
12030 hashlist_mode = HL_MODE_FILE;
12031
12032 data.hashlist_mode = hashlist_mode;
12033
12034 FILE *fp = fopen (hash_buf, "rb");
12035
12036 if (fp == NULL)
12037 {
12038 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
12039
12040 return (-1);
12041 }
12042
12043 if (hashes_avail < 1)
12044 {
12045 log_error ("ERROR: hccap file is empty or corrupt");
12046
12047 fclose (fp);
12048
12049 return (-1);
12050 }
12051
12052 uint hccap_size = sizeof (hccap_t);
12053
12054 char *in = (char *) mymalloc (hccap_size);
12055
12056 while (!feof (fp))
12057 {
12058 int n = fread (in, hccap_size, 1, fp);
12059
12060 if (n != 1)
12061 {
12062 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
12063
12064 break;
12065 }
12066
12067 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
12068
12069 if (parser_status != PARSER_OK)
12070 {
12071 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
12072
12073 continue;
12074 }
12075
12076 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
12077
12078 if ((show == 1) || (left == 1))
12079 {
12080 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
12081
12082 char *salt_ptr = (char *) tmp_salt->salt_buf;
12083
12084 int cur_pos = tmp_salt->salt_len;
12085 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12086
12087 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
12088
12089 // do the appending task
12090
12091 snprintf (salt_ptr + cur_pos,
12092 rem_len,
12093 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
12094 wpa->orig_mac1[0],
12095 wpa->orig_mac1[1],
12096 wpa->orig_mac1[2],
12097 wpa->orig_mac1[3],
12098 wpa->orig_mac1[4],
12099 wpa->orig_mac1[5],
12100 wpa->orig_mac2[0],
12101 wpa->orig_mac2[1],
12102 wpa->orig_mac2[2],
12103 wpa->orig_mac2[3],
12104 wpa->orig_mac2[4],
12105 wpa->orig_mac2[5]);
12106
12107 // memset () the remaining part of the salt
12108
12109 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12110 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12111
12112 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12113
12114 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12115 }
12116
12117 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);
12118 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);
12119
12120 hashes_cnt++;
12121 }
12122
12123 fclose (fp);
12124
12125 myfree (in);
12126 }
12127 else if (hash_mode == 3000)
12128 {
12129 if (hash_len == 32)
12130 {
12131 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12132
12133 hash_t *lm_hash_left = NULL;
12134
12135 if (parser_status == PARSER_OK)
12136 {
12137 lm_hash_left = &hashes_buf[hashes_cnt];
12138
12139 hashes_cnt++;
12140 }
12141 else
12142 {
12143 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12144 }
12145
12146 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12147
12148 hash_t *lm_hash_right = NULL;
12149
12150 if (parser_status == PARSER_OK)
12151 {
12152 lm_hash_right = &hashes_buf[hashes_cnt];
12153
12154 hashes_cnt++;
12155 }
12156 else
12157 {
12158 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12159 }
12160
12161 // show / left
12162
12163 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12164 {
12165 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);
12166 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);
12167 }
12168 }
12169 else
12170 {
12171 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12172
12173 if (parser_status == PARSER_OK)
12174 {
12175 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12176 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12177 }
12178
12179 if (parser_status == PARSER_OK)
12180 {
12181 hashes_cnt++;
12182 }
12183 else
12184 {
12185 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12186 }
12187 }
12188 }
12189 else
12190 {
12191 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12192
12193 if (parser_status == PARSER_OK)
12194 {
12195 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12196 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12197 }
12198
12199 if (parser_status == PARSER_OK)
12200 {
12201 hashes_cnt++;
12202 }
12203 else
12204 {
12205 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12206 }
12207 }
12208 }
12209 }
12210 else if (hashlist_mode == HL_MODE_FILE)
12211 {
12212 char *hashfile = data.hashfile;
12213
12214 FILE *fp;
12215
12216 if ((fp = fopen (hashfile, "rb")) == NULL)
12217 {
12218 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12219
12220 return (-1);
12221 }
12222
12223 uint line_num = 0;
12224
12225 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12226
12227 while (!feof (fp))
12228 {
12229 line_num++;
12230
12231 int line_len = fgetl (fp, line_buf);
12232
12233 if (line_len == 0) continue;
12234
12235 char *hash_buf = NULL;
12236 int hash_len = 0;
12237
12238 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12239
12240 bool hash_fmt_error = 0;
12241
12242 if (hash_len < 1) hash_fmt_error = 1;
12243 if (hash_buf == NULL) hash_fmt_error = 1;
12244
12245 if (hash_fmt_error)
12246 {
12247 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12248
12249 continue;
12250 }
12251
12252 if (username)
12253 {
12254 char *user_buf = NULL;
12255 int user_len = 0;
12256
12257 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12258
12259 if (remove || show)
12260 {
12261 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12262
12263 *user = (user_t *) mymalloc (sizeof (user_t));
12264
12265 user_t *user_ptr = *user;
12266
12267 if (user_buf != NULL)
12268 {
12269 user_ptr->user_name = mystrdup (user_buf);
12270 }
12271 else
12272 {
12273 user_ptr->user_name = mystrdup ("");
12274 }
12275
12276 user_ptr->user_len = user_len;
12277 }
12278 }
12279
12280 if (opts_type & OPTS_TYPE_HASH_COPY)
12281 {
12282 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12283
12284 hash_info_tmp->orighash = mystrdup (hash_buf);
12285 }
12286
12287 if (isSalted)
12288 {
12289 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12290 }
12291
12292 if (hash_mode == 3000)
12293 {
12294 if (hash_len == 32)
12295 {
12296 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12297
12298 if (parser_status < PARSER_GLOBAL_ZERO)
12299 {
12300 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12301
12302 continue;
12303 }
12304
12305 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12306
12307 hashes_cnt++;
12308
12309 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12310
12311 if (parser_status < PARSER_GLOBAL_ZERO)
12312 {
12313 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12314
12315 continue;
12316 }
12317
12318 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12319
12320 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);
12321
12322 hashes_cnt++;
12323
12324 // show / left
12325
12326 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);
12327 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);
12328 }
12329 else
12330 {
12331 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12332
12333 if (parser_status < PARSER_GLOBAL_ZERO)
12334 {
12335 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12336
12337 continue;
12338 }
12339
12340 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);
12341
12342 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12343 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12344
12345 hashes_cnt++;
12346 }
12347 }
12348 else
12349 {
12350 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12351
12352 if (parser_status < PARSER_GLOBAL_ZERO)
12353 {
12354 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12355
12356 continue;
12357 }
12358
12359 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);
12360
12361 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12362 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12363
12364 hashes_cnt++;
12365 }
12366 }
12367
12368 myfree (line_buf);
12369
12370 fclose (fp);
12371
12372 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12373
12374 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12375 }
12376 }
12377 else
12378 {
12379 if (isSalted)
12380 {
12381 hashes_buf[0].salt->salt_len = 8;
12382
12383 // special salt handling
12384
12385 switch (hash_mode)
12386 {
12387 case 1500: hashes_buf[0].salt->salt_len = 2;
12388 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12389 break;
12390 case 1731: hashes_buf[0].salt->salt_len = 4;
12391 break;
12392 case 2410: hashes_buf[0].salt->salt_len = 4;
12393 break;
12394 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12395 break;
12396 case 3100: hashes_buf[0].salt->salt_len = 1;
12397 break;
12398 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12399 break;
12400 case 5800: hashes_buf[0].salt->salt_len = 16;
12401 break;
12402 case 6800: hashes_buf[0].salt->salt_len = 32;
12403 break;
12404 case 8400: hashes_buf[0].salt->salt_len = 40;
12405 break;
12406 case 8800: hashes_buf[0].salt->salt_len = 16;
12407 break;
12408 case 8900: hashes_buf[0].salt->salt_len = 16;
12409 hashes_buf[0].salt->scrypt_N = 1024;
12410 hashes_buf[0].salt->scrypt_r = 1;
12411 hashes_buf[0].salt->scrypt_p = 1;
12412 break;
12413 case 9100: hashes_buf[0].salt->salt_len = 16;
12414 break;
12415 case 9300: hashes_buf[0].salt->salt_len = 14;
12416 hashes_buf[0].salt->scrypt_N = 16384;
12417 hashes_buf[0].salt->scrypt_r = 1;
12418 hashes_buf[0].salt->scrypt_p = 1;
12419 break;
12420 case 9400: hashes_buf[0].salt->salt_len = 16;
12421 break;
12422 case 9500: hashes_buf[0].salt->salt_len = 16;
12423 break;
12424 case 9600: hashes_buf[0].salt->salt_len = 16;
12425 break;
12426 case 9700: hashes_buf[0].salt->salt_len = 16;
12427 break;
12428 case 9710: hashes_buf[0].salt->salt_len = 16;
12429 break;
12430 case 9720: hashes_buf[0].salt->salt_len = 16;
12431 break;
12432 case 9800: hashes_buf[0].salt->salt_len = 16;
12433 break;
12434 case 9810: hashes_buf[0].salt->salt_len = 16;
12435 break;
12436 case 9820: hashes_buf[0].salt->salt_len = 16;
12437 break;
12438 case 10300: hashes_buf[0].salt->salt_len = 12;
12439 break;
12440 case 11500: hashes_buf[0].salt->salt_len = 4;
12441 break;
12442 case 11600: hashes_buf[0].salt->salt_len = 4;
12443 break;
12444 case 12400: hashes_buf[0].salt->salt_len = 4;
12445 break;
12446 case 12500: hashes_buf[0].salt->salt_len = 8;
12447 break;
12448 case 12600: hashes_buf[0].salt->salt_len = 64;
12449 break;
12450 }
12451
12452 // special esalt handling
12453
12454 switch (hash_mode)
12455 {
12456 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12457 break;
12458 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12459 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12460 break;
12461 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12462 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12463 break;
12464 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12465 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12466 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12467 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12468 break;
12469 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12470 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12471 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12472 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12473 break;
12474 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12475 break;
12476 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12477 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12478 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12479 break;
12480 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12481 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12482 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12483 break;
12484 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12485 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12486 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12487 break;
12488 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12489 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12490 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12491 break;
12492 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12493 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12494 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12495 break;
12496 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12497 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12498 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12499 break;
12500 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12501 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12502 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12503 break;
12504 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12505 break;
12506 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12507 break;
12508 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12509 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12510 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12511 break;
12512 }
12513 }
12514
12515 // set hashfile
12516
12517 switch (hash_mode)
12518 {
12519 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12520 break;
12521 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12522 break;
12523 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12524 break;
12525 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12526 break;
12527 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12528 break;
12529 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12530 break;
12531 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12532 break;
12533 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12534 break;
12535 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12536 break;
12537 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12538 break;
12539 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12540 break;
12541 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12542 break;
12543 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12544 break;
12545 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12546 break;
12547 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12548 break;
12549 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12550 break;
12551 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12552 break;
12553 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12554 break;
12555 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12556 break;
12557 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12558 break;
12559 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12560 break;
12561 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12562 break;
12563 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12564 break;
12565 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12566 break;
12567 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12568 break;
12569 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12570 break;
12571 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12572 break;
12573 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12574 break;
12575 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12576 break;
12577 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12578 break;
12579 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12580 break;
12581 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12582 break;
12583 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12584 break;
12585 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12586 break;
12587 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12588 break;
12589 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12590 break;
12591 }
12592
12593 // set default iterations
12594
12595 switch (hash_mode)
12596 {
12597 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12598 break;
12599 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12600 break;
12601 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12602 break;
12603 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12604 break;
12605 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12606 break;
12607 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12608 break;
12609 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12610 break;
12611 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12612 break;
12613 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12614 break;
12615 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12616 break;
12617 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12618 break;
12619 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12620 break;
12621 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12622 break;
12623 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12624 break;
12625 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12626 break;
12627 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12628 break;
12629 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12630 break;
12631 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12632 break;
12633 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12634 break;
12635 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12636 break;
12637 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12638 break;
12639 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12640 break;
12641 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12642 break;
12643 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12644 break;
12645 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12646 break;
12647 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12648 break;
12649 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12650 break;
12651 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12652 break;
12653 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12654 break;
12655 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12656 break;
12657 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12658 break;
12659 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12660 break;
12661 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12662 break;
12663 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12664 break;
12665 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12666 break;
12667 case 8900: hashes_buf[0].salt->salt_iter = 1;
12668 break;
12669 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12670 break;
12671 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12672 break;
12673 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12674 break;
12675 case 9300: hashes_buf[0].salt->salt_iter = 1;
12676 break;
12677 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12678 break;
12679 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12680 break;
12681 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12682 break;
12683 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12684 break;
12685 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12686 break;
12687 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12688 break;
12689 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12690 break;
12691 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12692 break;
12693 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12694 break;
12695 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12696 break;
12697 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12698 break;
12699 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12700 break;
12701 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12702 break;
12703 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12704 break;
12705 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12706 break;
12707 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12708 break;
12709 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12710 break;
12711 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12712 break;
12713 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12714 break;
12715 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12716 break;
12717 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12718 break;
12719 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12720 break;
12721 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12722 break;
12723 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12724 break;
12725 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12726 break;
12727 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12728 break;
12729 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12730 break;
12731 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12732 break;
12733 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12734 break;
12735 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12736 break;
12737 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12738 break;
12739 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12740 break;
12741 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12742 break;
12743 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12744 break;
12745 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12746 break;
12747 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12748 break;
12749 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12750 break;
12751 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12752 break;
12753 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12754 break;
12755 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12756 break;
12757 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12758 break;
12759 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12760 break;
12761 }
12762
12763 hashes_cnt = 1;
12764 }
12765
12766 if (show == 1 || left == 1)
12767 {
12768 for (uint i = 0; i < pot_cnt; i++)
12769 {
12770 pot_t *pot_ptr = &pot[i];
12771
12772 hash_t *hashes_buf = &pot_ptr->hash;
12773
12774 local_free (hashes_buf->digest);
12775
12776 if (isSalted)
12777 {
12778 local_free (hashes_buf->salt);
12779 }
12780 }
12781
12782 local_free (pot);
12783
12784 if (data.quiet == 0) log_info_nn ("");
12785
12786 return (0);
12787 }
12788
12789 if ((keyspace == 0) && (stdout_flag == 0))
12790 {
12791 if (hashes_cnt == 0)
12792 {
12793 log_error ("ERROR: No hashes loaded");
12794
12795 return (-1);
12796 }
12797 }
12798
12799 /**
12800 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12801 */
12802
12803 if (data.outfile != NULL)
12804 {
12805 if (data.hashfile != NULL)
12806 {
12807 #ifdef _POSIX
12808 struct stat tmpstat_outfile;
12809 struct stat tmpstat_hashfile;
12810 #endif
12811
12812 #ifdef _WIN
12813 struct stat64 tmpstat_outfile;
12814 struct stat64 tmpstat_hashfile;
12815 #endif
12816
12817 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12818
12819 if (tmp_outfile_fp)
12820 {
12821 #ifdef _POSIX
12822 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12823 #endif
12824
12825 #ifdef _WIN
12826 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12827 #endif
12828
12829 fclose (tmp_outfile_fp);
12830 }
12831
12832 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12833
12834 if (tmp_hashfile_fp)
12835 {
12836 #ifdef _POSIX
12837 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12838 #endif
12839
12840 #ifdef _WIN
12841 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12842 #endif
12843
12844 fclose (tmp_hashfile_fp);
12845 }
12846
12847 if (tmp_outfile_fp && tmp_outfile_fp)
12848 {
12849 tmpstat_outfile.st_mode = 0;
12850 tmpstat_outfile.st_nlink = 0;
12851 tmpstat_outfile.st_uid = 0;
12852 tmpstat_outfile.st_gid = 0;
12853 tmpstat_outfile.st_rdev = 0;
12854 tmpstat_outfile.st_atime = 0;
12855
12856 tmpstat_hashfile.st_mode = 0;
12857 tmpstat_hashfile.st_nlink = 0;
12858 tmpstat_hashfile.st_uid = 0;
12859 tmpstat_hashfile.st_gid = 0;
12860 tmpstat_hashfile.st_rdev = 0;
12861 tmpstat_hashfile.st_atime = 0;
12862
12863 #ifdef _POSIX
12864 tmpstat_outfile.st_blksize = 0;
12865 tmpstat_outfile.st_blocks = 0;
12866
12867 tmpstat_hashfile.st_blksize = 0;
12868 tmpstat_hashfile.st_blocks = 0;
12869 #endif
12870
12871 #ifdef _POSIX
12872 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12873 {
12874 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12875
12876 return (-1);
12877 }
12878 #endif
12879
12880 #ifdef _WIN
12881 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12882 {
12883 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12884
12885 return (-1);
12886 }
12887 #endif
12888 }
12889 }
12890 }
12891
12892 /**
12893 * Remove duplicates
12894 */
12895
12896 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12897
12898 if (isSalted)
12899 {
12900 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12901 }
12902 else
12903 {
12904 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12905 }
12906
12907 uint hashes_cnt_orig = hashes_cnt;
12908
12909 hashes_cnt = 1;
12910
12911 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12912 {
12913 if (isSalted)
12914 {
12915 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12916 {
12917 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12918 }
12919 }
12920 else
12921 {
12922 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12923 }
12924
12925 if (hashes_pos > hashes_cnt)
12926 {
12927 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12928 }
12929
12930 hashes_cnt++;
12931 }
12932
12933 /**
12934 * Potfile removes
12935 */
12936
12937 uint potfile_remove_cracks = 0;
12938
12939 if (potfile_disable == 0)
12940 {
12941 hash_t hash_buf;
12942
12943 hash_buf.digest = mymalloc (dgst_size);
12944 hash_buf.salt = NULL;
12945 hash_buf.esalt = NULL;
12946 hash_buf.hash_info = NULL;
12947 hash_buf.cracked = 0;
12948
12949 if (isSalted)
12950 {
12951 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12952 }
12953
12954 if (esalt_size)
12955 {
12956 hash_buf.esalt = mymalloc (esalt_size);
12957 }
12958
12959 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12960
12961 // no solution for these special hash types (for instane because they use hashfile in output etc)
12962 if ((hash_mode != 5200) &&
12963 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12964 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12965 (hash_mode != 9000))
12966 {
12967 FILE *fp = fopen (potfile, "rb");
12968
12969 if (fp != NULL)
12970 {
12971 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12972
12973 // to be safe work with a copy (because of line_len loop, i etc)
12974 // moved up here because it's easier to handle continue case
12975 // it's just 64kb
12976
12977 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12978
12979 while (!feof (fp))
12980 {
12981 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12982
12983 if (ptr == NULL) break;
12984
12985 int line_len = strlen (line_buf);
12986
12987 if (line_len == 0) continue;
12988
12989 int iter = MAX_CUT_TRIES;
12990
12991 for (int i = line_len - 1; i && iter; i--, line_len--)
12992 {
12993 if (line_buf[i] != ':') continue;
12994
12995 if (isSalted)
12996 {
12997 memset (hash_buf.salt, 0, sizeof (salt_t));
12998 }
12999
13000 hash_t *found = NULL;
13001
13002 if (hash_mode == 6800)
13003 {
13004 if (i < 64) // 64 = 16 * uint in salt_buf[]
13005 {
13006 // manipulate salt_buf
13007 memcpy (hash_buf.salt->salt_buf, line_buf, i);
13008
13009 hash_buf.salt->salt_len = i;
13010
13011 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
13012 }
13013 }
13014 else if (hash_mode == 2500)
13015 {
13016 if (i < 64) // 64 = 16 * uint in salt_buf[]
13017 {
13018 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
13019 // manipulate salt_buf
13020
13021 memcpy (line_buf_cpy, line_buf, i);
13022
13023 char *mac2_pos = strrchr (line_buf_cpy, ':');
13024
13025 if (mac2_pos == NULL) continue;
13026
13027 mac2_pos[0] = 0;
13028 mac2_pos++;
13029
13030 if (strlen (mac2_pos) != 12) continue;
13031
13032 char *mac1_pos = strrchr (line_buf_cpy, ':');
13033
13034 if (mac1_pos == NULL) continue;
13035
13036 mac1_pos[0] = 0;
13037 mac1_pos++;
13038
13039 if (strlen (mac1_pos) != 12) continue;
13040
13041 uint essid_length = mac1_pos - line_buf_cpy - 1;
13042
13043 // here we need the ESSID
13044 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
13045
13046 hash_buf.salt->salt_len = essid_length;
13047
13048 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
13049
13050 if (found)
13051 {
13052 wpa_t *wpa = (wpa_t *) found->esalt;
13053
13054 // compare hex string(s) vs binary MAC address(es)
13055
13056 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13057 {
13058 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
13059 {
13060 found = NULL;
13061
13062 break;
13063 }
13064 }
13065
13066 // early skip ;)
13067 if (!found) continue;
13068
13069 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13070 {
13071 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
13072 {
13073 found = NULL;
13074
13075 break;
13076 }
13077 }
13078 }
13079 }
13080 }
13081 else
13082 {
13083 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
13084
13085 if (parser_status == PARSER_OK)
13086 {
13087 if (isSalted)
13088 {
13089 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13090 }
13091 else
13092 {
13093 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13094 }
13095 }
13096 }
13097
13098 if (found == NULL) continue;
13099
13100 if (!found->cracked) potfile_remove_cracks++;
13101
13102 found->cracked = 1;
13103
13104 if (found) break;
13105
13106 iter--;
13107 }
13108 }
13109
13110 myfree (line_buf_cpy);
13111
13112 myfree (line_buf);
13113
13114 fclose (fp);
13115 }
13116 }
13117
13118 if (esalt_size)
13119 {
13120 local_free (hash_buf.esalt);
13121 }
13122
13123 if (isSalted)
13124 {
13125 local_free (hash_buf.salt);
13126 }
13127
13128 local_free (hash_buf.digest);
13129 }
13130
13131 /**
13132 * Now generate all the buffers required for later
13133 */
13134
13135 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13136
13137 salt_t *salts_buf_new = NULL;
13138 void *esalts_buf_new = NULL;
13139
13140 if (isSalted)
13141 {
13142 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13143
13144 if (esalt_size)
13145 {
13146 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13147 }
13148 }
13149 else
13150 {
13151 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13152 }
13153
13154 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13155
13156 uint digests_cnt = hashes_cnt;
13157 uint digests_done = 0;
13158
13159 size_t size_digests = digests_cnt * dgst_size;
13160 size_t size_shown = digests_cnt * sizeof (uint);
13161
13162 uint *digests_shown = (uint *) mymalloc (size_shown);
13163 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13164
13165 uint salts_cnt = 0;
13166 uint salts_done = 0;
13167
13168 hashinfo_t **hash_info = NULL;
13169
13170 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13171 {
13172 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13173
13174 if (username && (remove || show))
13175 {
13176 uint user_pos;
13177
13178 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13179 {
13180 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13181
13182 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13183 }
13184 }
13185 }
13186
13187 uint *salts_shown = (uint *) mymalloc (size_shown);
13188
13189 salt_t *salt_buf;
13190
13191 {
13192 // copied from inner loop
13193
13194 salt_buf = &salts_buf_new[salts_cnt];
13195
13196 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13197
13198 if (esalt_size)
13199 {
13200 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13201 }
13202
13203 salt_buf->digests_cnt = 0;
13204 salt_buf->digests_done = 0;
13205 salt_buf->digests_offset = 0;
13206
13207 salts_cnt++;
13208 }
13209
13210 if (hashes_buf[0].cracked == 1)
13211 {
13212 digests_shown[0] = 1;
13213
13214 digests_done++;
13215
13216 salt_buf->digests_done++;
13217 }
13218
13219 salt_buf->digests_cnt++;
13220
13221 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13222
13223 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13224 {
13225 hash_info[0] = hashes_buf[0].hash_info;
13226 }
13227
13228 // copy from inner loop
13229
13230 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13231 {
13232 if (isSalted)
13233 {
13234 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13235 {
13236 salt_buf = &salts_buf_new[salts_cnt];
13237
13238 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13239
13240 if (esalt_size)
13241 {
13242 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13243 }
13244
13245 salt_buf->digests_cnt = 0;
13246 salt_buf->digests_done = 0;
13247 salt_buf->digests_offset = hashes_pos;
13248
13249 salts_cnt++;
13250 }
13251 }
13252
13253 if (hashes_buf[hashes_pos].cracked == 1)
13254 {
13255 digests_shown[hashes_pos] = 1;
13256
13257 digests_done++;
13258
13259 salt_buf->digests_done++;
13260 }
13261
13262 salt_buf->digests_cnt++;
13263
13264 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13265
13266 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13267 {
13268 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13269 }
13270 }
13271
13272 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13273 {
13274 salt_t *salt_buf = &salts_buf_new[salt_pos];
13275
13276 if (salt_buf->digests_done == salt_buf->digests_cnt)
13277 {
13278 salts_shown[salt_pos] = 1;
13279
13280 salts_done++;
13281 }
13282
13283 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13284 }
13285
13286 local_free (digests_buf);
13287 local_free (salts_buf);
13288 local_free (esalts_buf);
13289
13290 digests_buf = digests_buf_new;
13291 salts_buf = salts_buf_new;
13292 esalts_buf = esalts_buf_new;
13293
13294 local_free (hashes_buf);
13295
13296 /**
13297 * special modification not set from parser
13298 */
13299
13300 switch (hash_mode)
13301 {
13302 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13303 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13304 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13305 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13306 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13307 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13308 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13309 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13310 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13311 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13312 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13313 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13314 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13315 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13316 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13317 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13318 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13319 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13320 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13321 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13322 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13323 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13324 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13325 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13326 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13327 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13328 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13329 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13330 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13331 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13332 }
13333
13334 if (truecrypt_keyfiles)
13335 {
13336 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13337
13338 char *keyfiles = strdup (truecrypt_keyfiles);
13339
13340 char *keyfile = strtok (keyfiles, ",");
13341
13342 do
13343 {
13344 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13345
13346 } while ((keyfile = strtok (NULL, ",")) != NULL);
13347
13348 free (keyfiles);
13349 }
13350
13351 if (veracrypt_keyfiles)
13352 {
13353 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13354
13355 char *keyfiles = strdup (veracrypt_keyfiles);
13356
13357 char *keyfile = strtok (keyfiles, ",");
13358
13359 do
13360 {
13361 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13362
13363 } while ((keyfile = strtok (NULL, ",")) != NULL);
13364
13365 free (keyfiles);
13366 }
13367
13368 data.digests_cnt = digests_cnt;
13369 data.digests_done = digests_done;
13370 data.digests_buf = digests_buf;
13371 data.digests_shown = digests_shown;
13372 data.digests_shown_tmp = digests_shown_tmp;
13373
13374 data.salts_cnt = salts_cnt;
13375 data.salts_done = salts_done;
13376 data.salts_buf = salts_buf;
13377 data.salts_shown = salts_shown;
13378
13379 data.esalts_buf = esalts_buf;
13380 data.hash_info = hash_info;
13381
13382 /**
13383 * Automatic Optimizers
13384 */
13385
13386 if (salts_cnt == 1)
13387 opti_type |= OPTI_TYPE_SINGLE_SALT;
13388
13389 if (digests_cnt == 1)
13390 opti_type |= OPTI_TYPE_SINGLE_HASH;
13391
13392 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13393 opti_type |= OPTI_TYPE_NOT_ITERATED;
13394
13395 if (attack_mode == ATTACK_MODE_BF)
13396 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13397
13398 data.opti_type = opti_type;
13399
13400 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13401 {
13402 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13403 {
13404 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13405 {
13406 if (opts_type & OPTS_TYPE_ST_ADD80)
13407 {
13408 opts_type &= ~OPTS_TYPE_ST_ADD80;
13409 opts_type |= OPTS_TYPE_PT_ADD80;
13410 }
13411
13412 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13413 {
13414 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13415 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13416 }
13417
13418 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13419 {
13420 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13421 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13422 }
13423 }
13424 }
13425 }
13426
13427 /**
13428 * Some algorithm, like descrypt, can benefit from JIT compilation
13429 */
13430
13431 int force_jit_compilation = -1;
13432
13433 if (hash_mode == 8900)
13434 {
13435 force_jit_compilation = 8900;
13436 }
13437 else if (hash_mode == 9300)
13438 {
13439 force_jit_compilation = 8900;
13440 }
13441 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13442 {
13443 force_jit_compilation = 1500;
13444 }
13445
13446 /**
13447 * generate bitmap tables
13448 */
13449
13450 const uint bitmap_shift1 = 5;
13451 const uint bitmap_shift2 = 13;
13452
13453 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13454
13455 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13456 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13457 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13458 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13459 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13460 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13461 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13462 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13463
13464 uint bitmap_bits;
13465 uint bitmap_nums;
13466 uint bitmap_mask;
13467 uint bitmap_size;
13468
13469 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13470 {
13471 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13472
13473 bitmap_nums = 1 << bitmap_bits;
13474
13475 bitmap_mask = bitmap_nums - 1;
13476
13477 bitmap_size = bitmap_nums * sizeof (uint);
13478
13479 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13480
13481 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;
13482 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;
13483
13484 break;
13485 }
13486
13487 bitmap_nums = 1 << bitmap_bits;
13488
13489 bitmap_mask = bitmap_nums - 1;
13490
13491 bitmap_size = bitmap_nums * sizeof (uint);
13492
13493 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);
13494 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);
13495
13496 /**
13497 * prepare quick rule
13498 */
13499
13500 data.rule_buf_l = rule_buf_l;
13501 data.rule_buf_r = rule_buf_r;
13502
13503 int rule_len_l = (int) strlen (rule_buf_l);
13504 int rule_len_r = (int) strlen (rule_buf_r);
13505
13506 data.rule_len_l = rule_len_l;
13507 data.rule_len_r = rule_len_r;
13508
13509 /**
13510 * load rules
13511 */
13512
13513 uint *all_kernel_rules_cnt = NULL;
13514
13515 kernel_rule_t **all_kernel_rules_buf = NULL;
13516
13517 if (rp_files_cnt)
13518 {
13519 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13520
13521 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13522 }
13523
13524 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13525
13526 int rule_len = 0;
13527
13528 for (uint i = 0; i < rp_files_cnt; i++)
13529 {
13530 uint kernel_rules_avail = 0;
13531
13532 uint kernel_rules_cnt = 0;
13533
13534 kernel_rule_t *kernel_rules_buf = NULL;
13535
13536 char *rp_file = rp_files[i];
13537
13538 char in[BLOCK_SIZE] = { 0 };
13539 char out[BLOCK_SIZE] = { 0 };
13540
13541 FILE *fp = NULL;
13542
13543 uint rule_line = 0;
13544
13545 if ((fp = fopen (rp_file, "rb")) == NULL)
13546 {
13547 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13548
13549 return (-1);
13550 }
13551
13552 while (!feof (fp))
13553 {
13554 memset (rule_buf, 0, HCBUFSIZ);
13555
13556 rule_len = fgetl (fp, rule_buf);
13557
13558 rule_line++;
13559
13560 if (rule_len == 0) continue;
13561
13562 if (rule_buf[0] == '#') continue;
13563
13564 if (kernel_rules_avail == kernel_rules_cnt)
13565 {
13566 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13567
13568 kernel_rules_avail += INCR_RULES;
13569 }
13570
13571 memset (in, 0, BLOCK_SIZE);
13572 memset (out, 0, BLOCK_SIZE);
13573
13574 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13575
13576 if (result == -1)
13577 {
13578 log_info ("WARNING: Skipping invalid or unsupported rule in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13579
13580 continue;
13581 }
13582
13583 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13584 {
13585 log_info ("WARNING: Cannot convert rule for use on OpenCL device in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13586
13587 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13588
13589 continue;
13590 }
13591
13592 /* its so slow
13593 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13594 {
13595 log_info ("Duplicate rule for use on OpenCL device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13596
13597 continue;
13598 }
13599 */
13600
13601 kernel_rules_cnt++;
13602 }
13603
13604 fclose (fp);
13605
13606 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13607
13608 all_kernel_rules_buf[i] = kernel_rules_buf;
13609 }
13610
13611 /**
13612 * merge rules or automatic rule generator
13613 */
13614
13615 uint kernel_rules_cnt = 0;
13616
13617 kernel_rule_t *kernel_rules_buf = NULL;
13618
13619 if (attack_mode == ATTACK_MODE_STRAIGHT)
13620 {
13621 if (rp_files_cnt)
13622 {
13623 kernel_rules_cnt = 1;
13624
13625 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13626
13627 repeats[0] = kernel_rules_cnt;
13628
13629 for (uint i = 0; i < rp_files_cnt; i++)
13630 {
13631 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13632
13633 repeats[i + 1] = kernel_rules_cnt;
13634 }
13635
13636 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13637
13638 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13639
13640 for (uint i = 0; i < kernel_rules_cnt; i++)
13641 {
13642 uint out_pos = 0;
13643
13644 kernel_rule_t *out = &kernel_rules_buf[i];
13645
13646 for (uint j = 0; j < rp_files_cnt; j++)
13647 {
13648 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13649 uint in_pos;
13650
13651 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13652
13653 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13654 {
13655 if (out_pos == RULES_MAX - 1)
13656 {
13657 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13658
13659 break;
13660 }
13661
13662 out->cmds[out_pos] = in->cmds[in_pos];
13663 }
13664 }
13665 }
13666
13667 local_free (repeats);
13668 }
13669 else if (rp_gen)
13670 {
13671 uint kernel_rules_avail = 0;
13672
13673 while (kernel_rules_cnt < rp_gen)
13674 {
13675 if (kernel_rules_avail == kernel_rules_cnt)
13676 {
13677 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13678
13679 kernel_rules_avail += INCR_RULES;
13680 }
13681
13682 memset (rule_buf, 0, HCBUFSIZ);
13683
13684 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13685
13686 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13687
13688 kernel_rules_cnt++;
13689 }
13690 }
13691 }
13692
13693 myfree (rule_buf);
13694
13695 /**
13696 * generate NOP rules
13697 */
13698
13699 if ((rp_files_cnt == 0) && (rp_gen == 0))
13700 {
13701 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13702
13703 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13704
13705 kernel_rules_cnt++;
13706 }
13707
13708 data.kernel_rules_cnt = kernel_rules_cnt;
13709 data.kernel_rules_buf = kernel_rules_buf;
13710
13711 if (kernel_rules_cnt == 0)
13712 {
13713 log_error ("ERROR: No valid rules left");
13714
13715 return (-1);
13716 }
13717
13718 /**
13719 * OpenCL platforms: detect
13720 */
13721
13722 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13723 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13724
13725 cl_uint platforms_cnt = 0;
13726 cl_uint platform_devices_cnt = 0;
13727
13728 if (keyspace == 0)
13729 {
13730 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13731
13732 if (platforms_cnt == 0)
13733 {
13734 log_info ("");
13735 log_info ("ATTENTION! No OpenCL compatible platform found");
13736 log_info ("");
13737 log_info ("You're probably missing the OpenCL runtime installation");
13738 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13739 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13740 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13741 log_info ("");
13742
13743 return (-1);
13744 }
13745
13746 if (opencl_platforms_filter != (uint) -1)
13747 {
13748 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13749
13750 if (opencl_platforms_filter > platform_cnt_mask)
13751 {
13752 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13753
13754 return (-1);
13755 }
13756 }
13757 }
13758
13759 if (opencl_device_types == NULL)
13760 {
13761 /**
13762 * OpenCL device types:
13763 * 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.
13764 */
13765
13766 cl_device_type device_types_all = 0;
13767
13768 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13769 {
13770 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13771
13772 cl_platform_id platform = platforms[platform_id];
13773
13774 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13775
13776 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13777 {
13778 cl_device_id device = platform_devices[platform_devices_id];
13779
13780 cl_device_type device_type;
13781
13782 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13783
13784 device_types_all |= device_type;
13785 }
13786 }
13787
13788 // In such a case, automatically enable CPU device type support, since it's disabled by default.
13789
13790 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13791 {
13792 device_types_filter |= CL_DEVICE_TYPE_CPU;
13793 }
13794
13795 // In another case, when the user uses --stdout, using CPU devices is much faster to setup
13796 // If we have a CPU device, force it to be used
13797
13798 if (stdout_flag == 1)
13799 {
13800 if (device_types_all & CL_DEVICE_TYPE_CPU)
13801 {
13802 device_types_filter = CL_DEVICE_TYPE_CPU;
13803 }
13804 }
13805 }
13806
13807 /**
13808 * OpenCL devices: simply push all devices from all platforms into the same device array
13809 */
13810
13811 int need_adl = 0;
13812 int need_nvapi = 0;
13813 int need_nvml = 0;
13814 int need_xnvctrl = 0;
13815
13816 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13817
13818 data.devices_param = devices_param;
13819
13820 uint devices_cnt = 0;
13821
13822 uint devices_active = 0;
13823
13824 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13825 {
13826 cl_platform_id platform = platforms[platform_id];
13827
13828 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13829
13830 char platform_vendor[INFOSZ] = { 0 };
13831
13832 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13833
13834 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13835 // this causes trouble with vendor id based macros
13836 // we'll assign generic to those without special optimization available
13837
13838 cl_uint platform_vendor_id = 0;
13839
13840 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13841 {
13842 platform_vendor_id = VENDOR_ID_AMD;
13843 }
13844 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13845 {
13846 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13847 }
13848 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13849 {
13850 platform_vendor_id = VENDOR_ID_APPLE;
13851 }
13852 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13853 {
13854 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13855 }
13856 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13857 {
13858 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13859 }
13860 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13861 {
13862 platform_vendor_id = VENDOR_ID_MESA;
13863 }
13864 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13865 {
13866 platform_vendor_id = VENDOR_ID_NV;
13867 }
13868 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13869 {
13870 platform_vendor_id = VENDOR_ID_POCL;
13871 }
13872 else
13873 {
13874 platform_vendor_id = VENDOR_ID_GENERIC;
13875 }
13876
13877 const uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
13878
13879 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13880 {
13881 if (machine_readable == 0)
13882 {
13883 if (platform_skipped == 0)
13884 {
13885 const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
13886
13887 char line[256] = { 0 };
13888
13889 for (int i = 0; i < len; i++) line[i] = '=';
13890
13891 log_info (line);
13892 }
13893 else
13894 {
13895 log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
13896 log_info ("");
13897 }
13898 }
13899 }
13900
13901 if (platform_skipped == 1) continue;
13902
13903 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13904 {
13905 size_t param_value_size = 0;
13906
13907 const uint device_id = devices_cnt;
13908
13909 hc_device_param_t *device_param = &data.devices_param[device_id];
13910
13911 device_param->platform_vendor_id = platform_vendor_id;
13912
13913 device_param->device = platform_devices[platform_devices_id];
13914
13915 device_param->device_id = device_id;
13916
13917 device_param->platform_devices_id = platform_devices_id;
13918
13919 // device_type
13920
13921 cl_device_type device_type;
13922
13923 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13924
13925 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13926
13927 device_param->device_type = device_type;
13928
13929 // device_name
13930
13931 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13932
13933 char *device_name = (char *) mymalloc (param_value_size);
13934
13935 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13936
13937 device_param->device_name = device_name;
13938
13939 // device_vendor
13940
13941 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13942
13943 char *device_vendor = (char *) mymalloc (param_value_size);
13944
13945 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13946
13947 device_param->device_vendor = device_vendor;
13948
13949 cl_uint device_vendor_id = 0;
13950
13951 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13952 {
13953 device_vendor_id = VENDOR_ID_AMD;
13954 }
13955 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13956 {
13957 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13958 }
13959 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13960 {
13961 device_vendor_id = VENDOR_ID_APPLE;
13962 }
13963 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13964 {
13965 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13966 }
13967 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13968 {
13969 device_vendor_id = VENDOR_ID_INTEL_SDK;
13970 }
13971 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13972 {
13973 device_vendor_id = VENDOR_ID_MESA;
13974 }
13975 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13976 {
13977 device_vendor_id = VENDOR_ID_NV;
13978 }
13979 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13980 {
13981 device_vendor_id = VENDOR_ID_POCL;
13982 }
13983 else
13984 {
13985 device_vendor_id = VENDOR_ID_GENERIC;
13986 }
13987
13988 device_param->device_vendor_id = device_vendor_id;
13989
13990 // tuning db
13991
13992 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13993
13994 // device_version
13995
13996 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13997
13998 char *device_version = (char *) mymalloc (param_value_size);
13999
14000 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
14001
14002 device_param->device_version = device_version;
14003
14004 // device_opencl_version
14005
14006 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
14007
14008 char *device_opencl_version = (char *) mymalloc (param_value_size);
14009
14010 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
14011
14012 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
14013
14014 myfree (device_opencl_version);
14015
14016 // vector_width
14017
14018 cl_uint vector_width;
14019
14020 if (opencl_vector_width_chgd == 0)
14021 {
14022 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
14023 {
14024 if (opti_type & OPTI_TYPE_USES_BITS_64)
14025 {
14026 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
14027 }
14028 else
14029 {
14030 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
14031 }
14032 }
14033 else
14034 {
14035 vector_width = (cl_uint) tuningdb_entry->vector_width;
14036 }
14037 }
14038 else
14039 {
14040 vector_width = opencl_vector_width;
14041 }
14042
14043 if (vector_width > 16) vector_width = 16;
14044
14045 device_param->vector_width = vector_width;
14046
14047 // max_compute_units
14048
14049 cl_uint device_processors;
14050
14051 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
14052
14053 device_param->device_processors = device_processors;
14054
14055 // device_maxmem_alloc
14056 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
14057
14058 cl_ulong device_maxmem_alloc;
14059
14060 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
14061
14062 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
14063
14064 // device_global_mem
14065
14066 cl_ulong device_global_mem;
14067
14068 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
14069
14070 device_param->device_global_mem = device_global_mem;
14071
14072 // max_work_group_size
14073
14074 size_t device_maxworkgroup_size;
14075
14076 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
14077
14078 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
14079
14080 // max_clock_frequency
14081
14082 cl_uint device_maxclock_frequency;
14083
14084 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
14085
14086 device_param->device_maxclock_frequency = device_maxclock_frequency;
14087
14088 // device_endian_little
14089
14090 cl_bool device_endian_little;
14091
14092 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
14093
14094 if (device_endian_little == CL_FALSE)
14095 {
14096 log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
14097
14098 device_param->skipped = 1;
14099 }
14100
14101 // device_available
14102
14103 cl_bool device_available;
14104
14105 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
14106
14107 if (device_available == CL_FALSE)
14108 {
14109 log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
14110
14111 device_param->skipped = 1;
14112 }
14113
14114 // device_compiler_available
14115
14116 cl_bool device_compiler_available;
14117
14118 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14119
14120 if (device_compiler_available == CL_FALSE)
14121 {
14122 log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
14123
14124 device_param->skipped = 1;
14125 }
14126
14127 // device_execution_capabilities
14128
14129 cl_device_exec_capabilities device_execution_capabilities;
14130
14131 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14132
14133 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14134 {
14135 log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
14136
14137 device_param->skipped = 1;
14138 }
14139
14140 // device_extensions
14141
14142 size_t device_extensions_size;
14143
14144 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14145
14146 char *device_extensions = mymalloc (device_extensions_size + 1);
14147
14148 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14149
14150 if (strstr (device_extensions, "base_atomics") == 0)
14151 {
14152 log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
14153
14154 device_param->skipped = 1;
14155 }
14156
14157 if (strstr (device_extensions, "byte_addressable_store") == 0)
14158 {
14159 log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
14160
14161 device_param->skipped = 1;
14162 }
14163
14164 myfree (device_extensions);
14165
14166 // device_local_mem_size
14167
14168 cl_ulong device_local_mem_size;
14169
14170 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14171
14172 if (device_local_mem_size < 32768)
14173 {
14174 log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
14175
14176 device_param->skipped = 1;
14177 }
14178
14179 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14180 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14181 // This results in both utilizing it for 50%
14182 // However, Intel has much better SIMD control over their own hardware
14183 // It makes sense to give them full control over their own hardware
14184
14185 if (device_type & CL_DEVICE_TYPE_CPU)
14186 {
14187 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14188 {
14189 if (data.force == 0)
14190 {
14191 if (algorithm_pos == 0)
14192 {
14193 log_info ("- Device #%u: WARNING: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1);
14194 log_info (" You can use --force to override this but do not post error reports if you do so");
14195 }
14196
14197 device_param->skipped = 1;
14198 }
14199 }
14200 }
14201
14202 // skipped
14203
14204 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14205 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14206
14207 // driver_version
14208
14209 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14210
14211 char *driver_version = (char *) mymalloc (param_value_size);
14212
14213 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14214
14215 device_param->driver_version = driver_version;
14216
14217 // device_name_chksum
14218
14219 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14220
14221 #if __x86_64__
14222 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);
14223 #else
14224 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);
14225 #endif
14226
14227 uint device_name_digest[4] = { 0 };
14228
14229 md5_64 ((uint *) device_name_chksum, device_name_digest);
14230
14231 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14232
14233 device_param->device_name_chksum = device_name_chksum;
14234
14235 // vendor specific
14236
14237 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14238 {
14239 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14240 {
14241 need_adl = 1;
14242 }
14243
14244 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14245 {
14246 need_nvml = 1;
14247
14248 #ifdef LINUX
14249 need_xnvctrl = 1;
14250 #endif
14251
14252 #ifdef WIN
14253 need_nvapi = 1;
14254 #endif
14255 }
14256 }
14257
14258 if (device_type & CL_DEVICE_TYPE_GPU)
14259 {
14260 if (device_vendor_id == VENDOR_ID_NV)
14261 {
14262 cl_uint kernel_exec_timeout = 0;
14263
14264 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14265
14266 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14267
14268 device_param->kernel_exec_timeout = kernel_exec_timeout;
14269
14270 cl_uint sm_minor = 0;
14271 cl_uint sm_major = 0;
14272
14273 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14274 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14275
14276 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14277 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14278
14279 device_param->sm_minor = sm_minor;
14280 device_param->sm_major = sm_major;
14281
14282 // CPU burning loop damper
14283 // Value is given as number between 0-100
14284 // By default 100%
14285
14286 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14287
14288 if (nvidia_spin_damp_chgd == 0)
14289 {
14290 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14291 {
14292 /**
14293 * the workaround is not a friend of rule based attacks
14294 * the words from the wordlist combined with fast and slow rules cause
14295 * fluctuations which cause inaccurate wait time estimations
14296 * using a reduced damping percentage almost compensates this
14297 */
14298
14299 device_param->nvidia_spin_damp = 64;
14300 }
14301 }
14302
14303 device_param->nvidia_spin_damp /= 100;
14304 }
14305 }
14306
14307 // display results
14308
14309 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14310 {
14311 if (machine_readable == 0)
14312 {
14313 if (device_param->skipped == 0)
14314 {
14315 log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14316 device_id + 1,
14317 device_name,
14318 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14319 (unsigned int) (device_global_mem / 1024 / 1024),
14320 (unsigned int) device_processors);
14321 }
14322 else
14323 {
14324 log_info ("- Device #%u: %s, skipped",
14325 device_id + 1,
14326 device_name);
14327 }
14328 }
14329 }
14330
14331 // common driver check
14332
14333 if (device_param->skipped == 0)
14334 {
14335 if (device_type & CL_DEVICE_TYPE_GPU)
14336 {
14337 if (platform_vendor_id == VENDOR_ID_AMD)
14338 {
14339 int catalyst_check = (force == 1) ? 0 : 1;
14340
14341 int catalyst_warn = 0;
14342
14343 int catalyst_broken = 0;
14344
14345 if (catalyst_check == 1)
14346 {
14347 catalyst_warn = 1;
14348
14349 // v14.9 and higher
14350 if (atoi (device_param->driver_version) >= 1573)
14351 {
14352 catalyst_warn = 0;
14353 }
14354
14355 catalyst_check = 0;
14356 }
14357
14358 if (catalyst_broken == 1)
14359 {
14360 log_info ("");
14361 log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
14362 log_info ("It passes over cracked hashes and will not report them as cracked");
14363 log_info ("You are STRONGLY encouraged not to use it");
14364 log_info ("You can use --force to override this but do not post error reports if you do so");
14365 log_info ("");
14366
14367 return (-1);
14368 }
14369
14370 if (catalyst_warn == 1)
14371 {
14372 log_info ("");
14373 log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
14374 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
14375 log_info ("See hashcat's homepage for official supported catalyst drivers");
14376 #ifdef _WIN
14377 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14378 #endif
14379 log_info ("You can use --force to override this but do not post error reports if you do so");
14380 log_info ("");
14381
14382 return (-1);
14383 }
14384 }
14385 else if (platform_vendor_id == VENDOR_ID_NV)
14386 {
14387 if (device_param->kernel_exec_timeout != 0)
14388 {
14389 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);
14390 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14391 }
14392 }
14393 }
14394
14395 /* turns out pocl still creates segfaults (because of llvm)
14396 if (device_type & CL_DEVICE_TYPE_CPU)
14397 {
14398 if (platform_vendor_id == VENDOR_ID_AMD)
14399 {
14400 if (force == 0)
14401 {
14402 log_info ("");
14403 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14404 log_info ("You are STRONGLY encouraged not to use it");
14405 log_info ("You can use --force to override this but do not post error reports if you do so");
14406 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14407 log_info ("");
14408
14409 return (-1);
14410 }
14411 }
14412 }
14413 */
14414
14415 /**
14416 * kernel accel and loops tuning db adjustment
14417 */
14418
14419 device_param->kernel_accel_min = 1;
14420 device_param->kernel_accel_max = 1024;
14421
14422 device_param->kernel_loops_min = 1;
14423 device_param->kernel_loops_max = 1024;
14424
14425 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14426
14427 if (tuningdb_entry)
14428 {
14429 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14430 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14431
14432 if (_kernel_accel)
14433 {
14434 device_param->kernel_accel_min = _kernel_accel;
14435 device_param->kernel_accel_max = _kernel_accel;
14436 }
14437
14438 if (_kernel_loops)
14439 {
14440 if (workload_profile == 1)
14441 {
14442 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14443 }
14444 else if (workload_profile == 2)
14445 {
14446 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14447 }
14448
14449 device_param->kernel_loops_min = _kernel_loops;
14450 device_param->kernel_loops_max = _kernel_loops;
14451 }
14452 }
14453
14454 // commandline parameters overwrite tuningdb entries
14455
14456 if (kernel_accel)
14457 {
14458 device_param->kernel_accel_min = kernel_accel;
14459 device_param->kernel_accel_max = kernel_accel;
14460 }
14461
14462 if (kernel_loops)
14463 {
14464 device_param->kernel_loops_min = kernel_loops;
14465 device_param->kernel_loops_max = kernel_loops;
14466 }
14467
14468 /**
14469 * activate device
14470 */
14471
14472 devices_active++;
14473 }
14474
14475 // next please
14476
14477 devices_cnt++;
14478 }
14479
14480 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14481 {
14482 if (machine_readable == 0)
14483 {
14484 log_info ("");
14485 }
14486 }
14487 }
14488
14489 if (keyspace == 0 && devices_active == 0)
14490 {
14491 log_error ("ERROR: No devices found/left");
14492
14493 return (-1);
14494 }
14495
14496 // 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)
14497
14498 if (devices_filter != (uint) -1)
14499 {
14500 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14501
14502 if (devices_filter > devices_cnt_mask)
14503 {
14504 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14505
14506 return (-1);
14507 }
14508 }
14509
14510 data.devices_cnt = devices_cnt;
14511
14512 data.devices_active = devices_active;
14513
14514 /**
14515 * HM devices: init
14516 */
14517
14518 #ifdef HAVE_HWMON
14519 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14520 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14521 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14522 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX] = { { 0 } };
14523
14524 if (gpu_temp_disable == 0)
14525 {
14526 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14527 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14528 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14529 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14530
14531 data.hm_adl = NULL;
14532 data.hm_nvapi = NULL;
14533 data.hm_nvml = NULL;
14534 data.hm_xnvctrl = NULL;
14535
14536 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14537 {
14538 data.hm_nvml = nvml;
14539 }
14540
14541 if (data.hm_nvml)
14542 {
14543 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14544 {
14545 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14546
14547 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14548
14549 int tmp_out = 0;
14550
14551 for (int i = 0; i < tmp_in; i++)
14552 {
14553 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14554 }
14555
14556 for (int i = 0; i < tmp_out; i++)
14557 {
14558 unsigned int speed;
14559
14560 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14561
14562 // doesn't seem to create any advantages
14563 //hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14564 //hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14565 }
14566 }
14567 }
14568
14569 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14570 {
14571 data.hm_nvapi = nvapi;
14572 }
14573
14574 if (data.hm_nvapi)
14575 {
14576 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14577 {
14578 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14579
14580 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14581
14582 int tmp_out = 0;
14583
14584 for (int i = 0; i < tmp_in; i++)
14585 {
14586 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14587 }
14588 }
14589 }
14590
14591 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14592 {
14593 data.hm_xnvctrl = xnvctrl;
14594 }
14595
14596 if (data.hm_xnvctrl)
14597 {
14598 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14599 {
14600 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14601 {
14602 hc_device_param_t *device_param = &data.devices_param[device_id];
14603
14604 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14605
14606 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14607
14608 int speed = 0;
14609
14610 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14611 }
14612 }
14613 }
14614
14615 if ((need_adl == 1) && (adl_init (adl) == 0))
14616 {
14617 data.hm_adl = adl;
14618 }
14619
14620 if (data.hm_adl)
14621 {
14622 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14623 {
14624 // total number of adapters
14625
14626 int hm_adapters_num;
14627
14628 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14629
14630 // adapter info
14631
14632 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14633
14634 if (lpAdapterInfo == NULL) return (-1);
14635
14636 // get a list (of ids of) valid/usable adapters
14637
14638 int num_adl_adapters = 0;
14639
14640 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14641
14642 if (num_adl_adapters > 0)
14643 {
14644 hc_thread_mutex_lock (mux_adl);
14645
14646 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14647
14648 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14649
14650 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14651 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14652
14653 hc_thread_mutex_unlock (mux_adl);
14654 }
14655
14656 myfree (valid_adl_device_list);
14657 myfree (lpAdapterInfo);
14658 }
14659 }
14660
14661 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14662 {
14663 gpu_temp_disable = 1;
14664 }
14665 }
14666
14667 /**
14668 * OpenCL devices: allocate buffer for device specific information
14669 */
14670
14671 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14672
14673 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14674
14675 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14676
14677 /**
14678 * User-defined GPU temp handling
14679 */
14680
14681 if (gpu_temp_disable == 1)
14682 {
14683 gpu_temp_abort = 0;
14684 gpu_temp_retain = 0;
14685 }
14686
14687 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14688 {
14689 if (gpu_temp_abort < gpu_temp_retain)
14690 {
14691 log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14692
14693 return (-1);
14694 }
14695 }
14696
14697 data.gpu_temp_disable = gpu_temp_disable;
14698 data.gpu_temp_abort = gpu_temp_abort;
14699 data.gpu_temp_retain = gpu_temp_retain;
14700 #endif
14701
14702 /**
14703 * enable custom signal handler(s)
14704 */
14705
14706 if (benchmark == 0)
14707 {
14708 hc_signal (sigHandler_default);
14709 }
14710 else
14711 {
14712 hc_signal (sigHandler_benchmark);
14713 }
14714
14715 /**
14716 * inform the user
14717 */
14718
14719 if (data.quiet == 0)
14720 {
14721 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14722
14723 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);
14724
14725 if (attack_mode == ATTACK_MODE_STRAIGHT)
14726 {
14727 log_info ("Rules: %u", kernel_rules_cnt);
14728 }
14729
14730 if (opti_type)
14731 {
14732 log_info ("Applicable Optimizers:");
14733
14734 for (uint i = 0; i < 32; i++)
14735 {
14736 const uint opti_bit = 1u << i;
14737
14738 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14739 }
14740 }
14741
14742 /**
14743 * Watchdog and Temperature balance
14744 */
14745
14746 #ifdef HAVE_HWMON
14747 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14748 {
14749 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14750 }
14751
14752 if (gpu_temp_abort == 0)
14753 {
14754 log_info ("Watchdog: Temperature abort trigger disabled");
14755 }
14756 else
14757 {
14758 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14759 }
14760
14761 if (gpu_temp_retain == 0)
14762 {
14763 log_info ("Watchdog: Temperature retain trigger disabled");
14764 }
14765 else
14766 {
14767 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14768 }
14769
14770 if (data.quiet == 0) log_info ("");
14771 #endif
14772 }
14773
14774 #ifdef HAVE_HWMON
14775
14776 /**
14777 * HM devices: copy
14778 */
14779
14780 if (gpu_temp_disable == 0)
14781 {
14782 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14783 {
14784 hc_device_param_t *device_param = &data.devices_param[device_id];
14785
14786 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14787
14788 if (device_param->skipped) continue;
14789
14790 const uint platform_devices_id = device_param->platform_devices_id;
14791
14792 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14793 {
14794 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14795 data.hm_device[device_id].nvapi = 0;
14796 data.hm_device[device_id].nvml = 0;
14797 data.hm_device[device_id].xnvctrl = 0;
14798 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14799 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14800 data.hm_device[device_id].fan_set_supported = 0;
14801 }
14802
14803 if (device_param->device_vendor_id == VENDOR_ID_NV)
14804 {
14805 data.hm_device[device_id].adl = 0;
14806 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14807 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14808 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14809 data.hm_device[device_id].od_version = 0;
14810 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14811 data.hm_device[device_id].fan_set_supported = 0;
14812 }
14813 }
14814 }
14815
14816 /**
14817 * powertune on user request
14818 */
14819
14820 if (powertune_enable == 1)
14821 {
14822 hc_thread_mutex_lock (mux_adl);
14823
14824 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14825 {
14826 hc_device_param_t *device_param = &data.devices_param[device_id];
14827
14828 if (device_param->skipped) continue;
14829
14830 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14831 {
14832 /**
14833 * Temporary fix:
14834 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14835 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14836 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14837 * Driver / ADL bug?
14838 */
14839
14840 if (data.hm_device[device_id].od_version == 6)
14841 {
14842 int ADL_rc;
14843
14844 // check powertune capabilities first, if not available then skip device
14845
14846 int powertune_supported = 0;
14847
14848 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14849 {
14850 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14851
14852 return (-1);
14853 }
14854
14855 // first backup current value, we will restore it later
14856
14857 if (powertune_supported != 0)
14858 {
14859 // powercontrol settings
14860
14861 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14862
14863 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14864 {
14865 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14866 }
14867
14868 if (ADL_rc != ADL_OK)
14869 {
14870 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14871
14872 return (-1);
14873 }
14874
14875 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14876 {
14877 log_error ("ERROR: Failed to set new ADL PowerControl values");
14878
14879 return (-1);
14880 }
14881
14882 // clocks
14883
14884 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14885
14886 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14887
14888 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14889 {
14890 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14891
14892 return (-1);
14893 }
14894
14895 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14896
14897 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14898
14899 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14900 {
14901 log_error ("ERROR: Failed to get ADL device capabilities");
14902
14903 return (-1);
14904 }
14905
14906 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14907 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14908
14909 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14910 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14911
14912 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14913 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14914
14915 // warning if profile has too low max values
14916
14917 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14918 {
14919 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14920 }
14921
14922 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14923 {
14924 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14925 }
14926
14927 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14928
14929 performance_state->iNumberOfPerformanceLevels = 2;
14930
14931 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14932 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14933 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14934 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14935
14936 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14937 {
14938 log_info ("ERROR: Failed to set ADL performance state");
14939
14940 return (-1);
14941 }
14942
14943 local_free (performance_state);
14944 }
14945
14946 // set powertune value only
14947
14948 if (powertune_supported != 0)
14949 {
14950 // powertune set
14951 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14952
14953 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14954 {
14955 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14956
14957 return (-1);
14958 }
14959
14960 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14961 {
14962 log_error ("ERROR: Failed to set new ADL PowerControl values");
14963
14964 return (-1);
14965 }
14966 }
14967 }
14968 }
14969
14970 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14971 {
14972 // first backup current value, we will restore it later
14973
14974 unsigned int limit;
14975
14976 int powertune_supported = 0;
14977
14978 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14979 {
14980 powertune_supported = 1;
14981 }
14982
14983 // if backup worked, activate the maximum allowed
14984
14985 if (powertune_supported != 0)
14986 {
14987 unsigned int minLimit;
14988 unsigned int maxLimit;
14989
14990 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14991 {
14992 if (maxLimit > 0)
14993 {
14994 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14995 {
14996 // now we can be sure we need to reset later
14997
14998 nvml_power_limit[device_id] = limit;
14999 }
15000 }
15001 }
15002 }
15003 }
15004 }
15005
15006 hc_thread_mutex_unlock (mux_adl);
15007 }
15008
15009 #endif // HAVE_HWMON
15010
15011 #ifdef DEBUG
15012 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
15013 #endif
15014
15015 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
15016
15017 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15018 {
15019 /**
15020 * host buffer
15021 */
15022
15023 hc_device_param_t *device_param = &data.devices_param[device_id];
15024
15025 if (device_param->skipped) continue;
15026
15027 /**
15028 * device properties
15029 */
15030
15031 const char *device_name_chksum = device_param->device_name_chksum;
15032 const u32 device_processors = device_param->device_processors;
15033
15034 /**
15035 * create context for each device
15036 */
15037
15038 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
15039
15040 /**
15041 * create command-queue
15042 */
15043
15044 // not supported with NV
15045 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
15046
15047 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
15048
15049 /**
15050 * kernel threads: some algorithms need a fixed kernel-threads count
15051 * because of shared memory usage or bitslice
15052 * there needs to be some upper limit, otherwise there's too much overhead
15053 */
15054
15055 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
15056
15057 if (hash_mode == 8900) kernel_threads = 64; // Scrypt
15058 if (hash_mode == 9300) kernel_threads = 64; // Scrypt
15059
15060 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
15061 {
15062 kernel_threads = KERNEL_THREADS_MAX_CPU;
15063 }
15064
15065 if (hash_mode == 1500) kernel_threads = 64; // DES
15066 if (hash_mode == 3000) kernel_threads = 64; // DES
15067 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
15068 if (hash_mode == 7500) kernel_threads = 64; // RC4
15069 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
15070 if (hash_mode == 9700) kernel_threads = 64; // RC4
15071 if (hash_mode == 9710) kernel_threads = 64; // RC4
15072 if (hash_mode == 9800) kernel_threads = 64; // RC4
15073 if (hash_mode == 9810) kernel_threads = 64; // RC4
15074 if (hash_mode == 10400) kernel_threads = 64; // RC4
15075 if (hash_mode == 10410) kernel_threads = 64; // RC4
15076 if (hash_mode == 10500) kernel_threads = 64; // RC4
15077 if (hash_mode == 13100) kernel_threads = 64; // RC4
15078
15079 device_param->kernel_threads = kernel_threads;
15080
15081 device_param->hardware_power = device_processors * kernel_threads;
15082
15083 /**
15084 * create input buffers on device : calculate size of fixed memory buffers
15085 */
15086
15087 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
15088 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15089
15090 device_param->size_root_css = size_root_css;
15091 device_param->size_markov_css = size_markov_css;
15092
15093 size_t size_results = sizeof (uint);
15094
15095 device_param->size_results = size_results;
15096
15097 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
15098 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
15099
15100 size_t size_plains = digests_cnt * sizeof (plain_t);
15101 size_t size_salts = salts_cnt * sizeof (salt_t);
15102 size_t size_esalts = salts_cnt * esalt_size;
15103
15104 device_param->size_plains = size_plains;
15105 device_param->size_digests = size_digests;
15106 device_param->size_shown = size_shown;
15107 device_param->size_salts = size_salts;
15108
15109 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15110 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
15111 size_t size_tm = 32 * sizeof (bs_word_t);
15112
15113 // scryptV stuff
15114
15115 size_t size_scrypt = 4;
15116
15117 if ((hash_mode == 8900) || (hash_mode == 9300))
15118 {
15119 // we need to check that all hashes have the same scrypt settings
15120
15121 const u32 scrypt_N = data.salts_buf[0].scrypt_N;
15122 const u32 scrypt_r = data.salts_buf[0].scrypt_r;
15123 const u32 scrypt_p = data.salts_buf[0].scrypt_p;
15124
15125 for (uint i = 1; i < salts_cnt; i++)
15126 {
15127 if ((data.salts_buf[i].scrypt_N != scrypt_N)
15128 || (data.salts_buf[i].scrypt_r != scrypt_r)
15129 || (data.salts_buf[i].scrypt_p != scrypt_p))
15130 {
15131 log_error ("ERROR: Mixed scrypt settings not supported");
15132
15133 return -1;
15134 }
15135 }
15136
15137 uint tmto_start = 0;
15138 uint tmto_stop = 10;
15139
15140 if (scrypt_tmto)
15141 {
15142 tmto_start = scrypt_tmto;
15143 }
15144 else
15145 {
15146 // in case the user did not specify the tmto manually
15147 // use some values known to run best (tested on 290x for AMD and GTX1080 for NV)
15148
15149 if (hash_mode == 8900)
15150 {
15151 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15152 {
15153 tmto_start = 3;
15154 }
15155 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15156 {
15157 tmto_start = 2;
15158 }
15159 }
15160 else if (hash_mode == 9300)
15161 {
15162 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15163 {
15164 tmto_start = 2;
15165 }
15166 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15167 {
15168 tmto_start = 4;
15169 }
15170 }
15171 }
15172
15173 data.scrypt_tmp_size = (128 * scrypt_r * scrypt_p);
15174
15175 device_param->kernel_accel_min = 1;
15176 device_param->kernel_accel_max = 8;
15177
15178 uint tmto;
15179
15180 for (tmto = tmto_start; tmto < tmto_stop; tmto++)
15181 {
15182 size_scrypt = (128 * scrypt_r) * scrypt_N;
15183
15184 size_scrypt /= 1 << tmto;
15185
15186 size_scrypt *= device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel_max;
15187
15188 if ((size_scrypt / 4) > device_param->device_maxmem_alloc)
15189 {
15190 if (quiet == 0) log_info ("WARNING: Not enough single-block device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15191
15192 continue;
15193 }
15194
15195 if (size_scrypt > device_param->device_global_mem)
15196 {
15197 if (quiet == 0) log_info ("WARNING: Not enough total device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15198
15199 continue;
15200 }
15201
15202 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15203 {
15204 data.scrypt_tmto_final = tmto;
15205 }
15206
15207 break;
15208 }
15209
15210 if (tmto == tmto_stop)
15211 {
15212 log_error ("ERROR: Can't allocate enough device memory");
15213
15214 return -1;
15215 }
15216
15217 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %llu\n", data.scrypt_tmto_final, (unsigned long long int) size_scrypt);
15218 }
15219
15220 size_t size_scrypt4 = size_scrypt / 4;
15221
15222 /**
15223 * some algorithms need a fixed kernel-loops count
15224 */
15225
15226 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15227 {
15228 const u32 kernel_loops_fixed = 1024;
15229
15230 device_param->kernel_loops_min = kernel_loops_fixed;
15231 device_param->kernel_loops_max = kernel_loops_fixed;
15232 }
15233
15234 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15235 {
15236 const u32 kernel_loops_fixed = 1024;
15237
15238 device_param->kernel_loops_min = kernel_loops_fixed;
15239 device_param->kernel_loops_max = kernel_loops_fixed;
15240 }
15241
15242 if (hash_mode == 8900)
15243 {
15244 const u32 kernel_loops_fixed = 1;
15245
15246 device_param->kernel_loops_min = kernel_loops_fixed;
15247 device_param->kernel_loops_max = kernel_loops_fixed;
15248 }
15249
15250 if (hash_mode == 9300)
15251 {
15252 const u32 kernel_loops_fixed = 1;
15253
15254 device_param->kernel_loops_min = kernel_loops_fixed;
15255 device_param->kernel_loops_max = kernel_loops_fixed;
15256 }
15257
15258 if (hash_mode == 12500)
15259 {
15260 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15261
15262 device_param->kernel_loops_min = kernel_loops_fixed;
15263 device_param->kernel_loops_max = kernel_loops_fixed;
15264 }
15265
15266 /**
15267 * some algorithms have a maximum kernel-loops count
15268 */
15269
15270 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15271 {
15272 u32 innerloop_cnt = 0;
15273
15274 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15275 {
15276 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15277 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15278 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15279 }
15280 else
15281 {
15282 innerloop_cnt = data.salts_buf[0].salt_iter;
15283 }
15284
15285 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15286 (innerloop_cnt <= device_param->kernel_loops_max))
15287 {
15288 device_param->kernel_loops_max = innerloop_cnt;
15289 }
15290 }
15291
15292 u32 kernel_accel_min = device_param->kernel_accel_min;
15293 u32 kernel_accel_max = device_param->kernel_accel_max;
15294
15295 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15296
15297 size_t size_pws = 4;
15298 size_t size_tmps = 4;
15299 size_t size_hooks = 4;
15300
15301 while (kernel_accel_max >= kernel_accel_min)
15302 {
15303 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15304
15305 // size_pws
15306
15307 size_pws = kernel_power_max * sizeof (pw_t);
15308
15309 // size_tmps
15310
15311 switch (hash_mode)
15312 {
15313 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15314 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15315 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15316 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15317 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15318 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15319 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15320 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15321 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15322 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15323 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15324 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15325 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15326 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15327 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15328 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15329 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15330 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15331 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15332 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15333 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15334 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15335 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15336 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15337 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15338 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15339 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15340 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15341 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15342 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15343 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15344 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15345 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15346 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15347 case 8900: size_tmps = kernel_power_max * data.scrypt_tmp_size; break;
15348 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15349 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15350 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15351 case 9300: size_tmps = kernel_power_max * data.scrypt_tmp_size; break;
15352 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15353 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15354 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15355 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15356 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15357 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15358 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15359 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15360 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15361 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15362 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15363 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15364 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15365 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15366 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15367 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15368 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15369 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15370 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15371 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15372 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15373 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15374 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15375 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15376 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15377 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15378 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15379 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15380 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15381 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15382 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15383 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15384 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15385 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15386 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15387 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15388 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15389 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15390 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15391 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15392 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15393 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15394 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15395 };
15396
15397 // size_hooks
15398
15399 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15400 {
15401 switch (hash_mode)
15402 {
15403 }
15404 }
15405
15406 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15407 // if not, decrease amplifier and try again
15408
15409 int memory_limit_hit = 0;
15410
15411 if (size_pws > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15412 if (size_tmps > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15413 if (size_hooks > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15414
15415 const u64 size_total
15416 = bitmap_size
15417 + bitmap_size
15418 + bitmap_size
15419 + bitmap_size
15420 + bitmap_size
15421 + bitmap_size
15422 + bitmap_size
15423 + bitmap_size
15424 + size_bfs
15425 + size_combs
15426 + size_digests
15427 + size_esalts
15428 + size_hooks
15429 + size_markov_css
15430 + size_plains
15431 + size_pws
15432 + size_pws // not a bug
15433 + size_results
15434 + size_root_css
15435 + size_rules
15436 + size_rules_c
15437 + size_salts
15438 + size_scrypt4
15439 + size_scrypt4
15440 + size_scrypt4
15441 + size_scrypt4
15442 + size_shown
15443 + size_tm
15444 + size_tmps;
15445
15446 if (size_total > device_param->device_global_mem) memory_limit_hit = 1;
15447
15448 if (memory_limit_hit == 1)
15449 {
15450 kernel_accel_max--;
15451
15452 continue;
15453 }
15454
15455 break;
15456 }
15457
15458 if (kernel_accel_max < kernel_accel_min)
15459 {
15460 log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle this attack", device_id + 1);
15461
15462 return -1;
15463 }
15464
15465 device_param->kernel_accel_min = kernel_accel_min;
15466 device_param->kernel_accel_max = kernel_accel_max;
15467
15468 /*
15469 if (kernel_accel_max < kernel_accel)
15470 {
15471 if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15472
15473 device_param->kernel_accel = kernel_accel_max;
15474 }
15475 */
15476
15477 device_param->size_bfs = size_bfs;
15478 device_param->size_combs = size_combs;
15479 device_param->size_rules = size_rules;
15480 device_param->size_rules_c = size_rules_c;
15481 device_param->size_pws = size_pws;
15482 device_param->size_tmps = size_tmps;
15483 device_param->size_hooks = size_hooks;
15484
15485 /**
15486 * default building options
15487 */
15488
15489 char cpath[1024] = { 0 };
15490
15491 char build_opts[1024] = { 0 };
15492
15493 #if _WIN
15494
15495 snprintf (cpath, sizeof (cpath) - 1, "%s\\OpenCL\\", shared_dir);
15496
15497 char *cpath_real = mymalloc (MAX_PATH);
15498
15499 if (GetFullPathName (cpath, MAX_PATH, cpath_real, NULL) == 0)
15500 {
15501 log_error ("ERROR: %s: %s", cpath, "GetFullPathName()");
15502
15503 return -1;
15504 }
15505
15506 naive_replace (cpath_real, '\\', '/');
15507
15508 // not escaping here, windows has quotes
15509
15510 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real);
15511
15512 #else
15513
15514 snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir);
15515
15516 char *cpath_real = mymalloc (PATH_MAX);
15517
15518 if (realpath (cpath, cpath_real) == NULL)
15519 {
15520 log_error ("ERROR: %s: %s", cpath, strerror (errno));
15521
15522 return -1;
15523 }
15524
15525 naive_escape (cpath_real, PATH_MAX, ' ', '\\');
15526
15527 snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_real);
15528
15529 #endif
15530
15531 // include check
15532 // this test needs to be done manually because of osx opencl runtime
15533 // if there's a problem with permission, its not reporting back and erroring out silently
15534
15535 #define files_cnt 15
15536
15537 const char *files_names[files_cnt] =
15538 {
15539 "inc_cipher_aes256.cl",
15540 "inc_cipher_serpent256.cl",
15541 "inc_cipher_twofish256.cl",
15542 "inc_common.cl",
15543 "inc_comp_multi_bs.cl",
15544 "inc_comp_multi.cl",
15545 "inc_comp_single_bs.cl",
15546 "inc_comp_single.cl",
15547 "inc_hash_constants.h",
15548 "inc_hash_functions.cl",
15549 "inc_rp.cl",
15550 "inc_rp.h",
15551 "inc_simd.cl",
15552 "inc_types.cl",
15553 "inc_vendor.cl",
15554 };
15555
15556 for (int i = 0; i < files_cnt; i++)
15557 {
15558 char path[1024] = { 0 };
15559
15560 snprintf (path, sizeof (path) - 1, "%s/%s", cpath_real, files_names[i]);
15561
15562 FILE *fd = fopen (path, "r");
15563
15564 if (fd == NULL)
15565 {
15566 log_error ("ERROR: %s: fopen(): %s", path, strerror (errno));
15567
15568 return -1;
15569 }
15570
15571 char buf[1];
15572
15573 size_t n = fread (buf, 1, 1, fd);
15574
15575 if (n != 1)
15576 {
15577 log_error ("ERROR: %s: fread(): %s", path, strerror (errno));
15578
15579 return -1;
15580 }
15581
15582 fclose (fd);
15583 }
15584
15585 myfree (cpath_real);
15586
15587 // we don't have sm_* on vendors not NV but it doesn't matter
15588
15589 char build_opts_new[1024] = { 0 };
15590
15591 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -D VENDOR_ID=%u -D CUDA_ARCH=%d -D VECT_SIZE=%u -D DEVICE_TYPE=%u -D DGST_R0=%u -D DGST_R1=%u -D DGST_R2=%u -D DGST_R3=%u -D DGST_ELEM=%u -D KERN_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, data.dgst_pos0, data.dgst_pos1, data.dgst_pos2, data.dgst_pos3, data.dgst_size / 4, kern_type);
15592
15593 strncpy (build_opts, build_opts_new, sizeof (build_opts));
15594
15595 #ifdef DEBUG
15596 log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15597 #endif
15598
15599 /**
15600 * main kernel
15601 */
15602
15603 {
15604 /**
15605 * kernel source filename
15606 */
15607
15608 char source_file[256] = { 0 };
15609
15610 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15611
15612 struct stat sst;
15613
15614 if (stat (source_file, &sst) == -1)
15615 {
15616 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15617
15618 return -1;
15619 }
15620
15621 /**
15622 * kernel cached filename
15623 */
15624
15625 char cached_file[256] = { 0 };
15626
15627 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15628
15629 int cached = 1;
15630
15631 struct stat cst;
15632
15633 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15634 {
15635 cached = 0;
15636 }
15637
15638 /**
15639 * kernel compile or load
15640 */
15641
15642 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15643
15644 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15645
15646 if (force_jit_compilation == -1)
15647 {
15648 if (cached == 0)
15649 {
15650 if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
15651
15652 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15653
15654 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15655
15656 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15657
15658 #ifdef DEBUG
15659 size_t build_log_size = 0;
15660
15661 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15662
15663 if (build_log_size > 1)
15664 {
15665 char *build_log = (char *) malloc (build_log_size + 1);
15666
15667 memset (build_log, 0, build_log_size + 1);
15668
15669 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15670
15671 puts (build_log);
15672
15673 free (build_log);
15674 }
15675 #endif
15676
15677 if (rc != 0)
15678 {
15679 device_param->skipped = true;
15680
15681 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15682
15683 continue;
15684 }
15685
15686 size_t binary_size;
15687
15688 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15689
15690 u8 *binary = (u8 *) mymalloc (binary_size);
15691
15692 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15693
15694 writeProgramBin (cached_file, binary, binary_size);
15695
15696 local_free (binary);
15697 }
15698 else
15699 {
15700 #ifdef DEBUG
15701 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15702 #endif
15703
15704 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15705
15706 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15707
15708 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15709 }
15710 }
15711 else
15712 {
15713 #ifdef DEBUG
15714 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15715 #endif
15716
15717 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15718
15719 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15720
15721 char build_opts_update[1024] = { 0 };
15722
15723 if (force_jit_compilation == 1500)
15724 {
15725 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%u", build_opts, data.salts_buf[0].salt_buf[0]);
15726 }
15727 else if (force_jit_compilation == 8900)
15728 {
15729 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DSCRYPT_N=%u -DSCRYPT_R=%u -DSCRYPT_P=%u -DSCRYPT_TMTO=%u -DSCRYPT_TMP_ELEM=%u", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, 1 << data.scrypt_tmto_final, data.scrypt_tmp_size / 16);
15730 }
15731 else
15732 {
15733 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15734 }
15735
15736 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15737
15738 #ifdef DEBUG
15739 size_t build_log_size = 0;
15740
15741 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15742
15743 if (build_log_size > 1)
15744 {
15745 char *build_log = (char *) malloc (build_log_size + 1);
15746
15747 memset (build_log, 0, build_log_size + 1);
15748
15749 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15750
15751 puts (build_log);
15752
15753 free (build_log);
15754 }
15755 #endif
15756
15757 if (rc != 0)
15758 {
15759 device_param->skipped = true;
15760
15761 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15762 }
15763 }
15764
15765 local_free (kernel_lengths);
15766 local_free (kernel_sources[0]);
15767 local_free (kernel_sources);
15768 }
15769
15770 /**
15771 * word generator kernel
15772 */
15773
15774 if (attack_mode != ATTACK_MODE_STRAIGHT)
15775 {
15776 /**
15777 * kernel mp source filename
15778 */
15779
15780 char source_file[256] = { 0 };
15781
15782 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15783
15784 struct stat sst;
15785
15786 if (stat (source_file, &sst) == -1)
15787 {
15788 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15789
15790 return -1;
15791 }
15792
15793 /**
15794 * kernel mp cached filename
15795 */
15796
15797 char cached_file[256] = { 0 };
15798
15799 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15800
15801 int cached = 1;
15802
15803 struct stat cst;
15804
15805 if (stat (cached_file, &cst) == -1)
15806 {
15807 cached = 0;
15808 }
15809
15810 /**
15811 * kernel compile or load
15812 */
15813
15814 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15815
15816 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15817
15818 if (cached == 0)
15819 {
15820 if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
15821 if (quiet == 0) log_info ("");
15822
15823 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15824
15825 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15826
15827 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15828
15829 if (rc != 0)
15830 {
15831 device_param->skipped = true;
15832
15833 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15834
15835 continue;
15836 }
15837
15838 size_t binary_size;
15839
15840 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15841
15842 u8 *binary = (u8 *) mymalloc (binary_size);
15843
15844 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15845
15846 writeProgramBin (cached_file, binary, binary_size);
15847
15848 local_free (binary);
15849 }
15850 else
15851 {
15852 #ifdef DEBUG
15853 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15854 #endif
15855
15856 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15857
15858 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15859
15860 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15861 }
15862
15863 local_free (kernel_lengths);
15864 local_free (kernel_sources[0]);
15865 local_free (kernel_sources);
15866 }
15867
15868 /**
15869 * amplifier kernel
15870 */
15871
15872 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15873 {
15874
15875 }
15876 else
15877 {
15878 /**
15879 * kernel amp source filename
15880 */
15881
15882 char source_file[256] = { 0 };
15883
15884 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15885
15886 struct stat sst;
15887
15888 if (stat (source_file, &sst) == -1)
15889 {
15890 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15891
15892 return -1;
15893 }
15894
15895 /**
15896 * kernel amp cached filename
15897 */
15898
15899 char cached_file[256] = { 0 };
15900
15901 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15902
15903 int cached = 1;
15904
15905 struct stat cst;
15906
15907 if (stat (cached_file, &cst) == -1)
15908 {
15909 cached = 0;
15910 }
15911
15912 /**
15913 * kernel compile or load
15914 */
15915
15916 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15917
15918 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15919
15920 if (cached == 0)
15921 {
15922 if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
15923 if (quiet == 0) log_info ("");
15924
15925 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15926
15927 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15928
15929 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15930
15931 if (rc != 0)
15932 {
15933 device_param->skipped = true;
15934
15935 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15936
15937 continue;
15938 }
15939
15940 size_t binary_size;
15941
15942 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15943
15944 u8 *binary = (u8 *) mymalloc (binary_size);
15945
15946 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15947
15948 writeProgramBin (cached_file, binary, binary_size);
15949
15950 local_free (binary);
15951 }
15952 else
15953 {
15954 #ifdef DEBUG
15955 if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15956 #endif
15957
15958 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15959
15960 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15961
15962 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15963 }
15964
15965 local_free (kernel_lengths);
15966 local_free (kernel_sources[0]);
15967 local_free (kernel_sources);
15968 }
15969
15970 // some algorithm collide too fast, make that impossible
15971
15972 if (benchmark == 1)
15973 {
15974 ((uint *) digests_buf)[0] = -1;
15975 ((uint *) digests_buf)[1] = -1;
15976 ((uint *) digests_buf)[2] = -1;
15977 ((uint *) digests_buf)[3] = -1;
15978 }
15979
15980 /**
15981 * global buffers
15982 */
15983
15984 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15985 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15986 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15987 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15988 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15989 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15990 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15991 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15992 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15993 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15994 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15995 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15996 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15997 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15998 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15999 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
16000 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
16001 device_param->d_scryptV0_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
16002 device_param->d_scryptV1_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
16003 device_param->d_scryptV2_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
16004 device_param->d_scryptV3_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
16005
16006 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);
16007 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);
16008 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);
16009 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);
16010 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);
16011 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);
16012 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);
16013 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);
16014 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
16015 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
16016 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
16017
16018 /**
16019 * special buffers
16020 */
16021
16022 if (attack_kern == ATTACK_KERN_STRAIGHT)
16023 {
16024 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
16025 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
16026
16027 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
16028 }
16029 else if (attack_kern == ATTACK_KERN_COMBI)
16030 {
16031 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
16032 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
16033 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
16034 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
16035 }
16036 else if (attack_kern == ATTACK_KERN_BF)
16037 {
16038 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
16039 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
16040 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
16041 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
16042 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
16043 }
16044
16045 if (size_esalts)
16046 {
16047 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
16048
16049 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
16050 }
16051
16052 /**
16053 * main host data
16054 */
16055
16056 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
16057
16058 device_param->pws_buf = pws_buf;
16059
16060 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
16061
16062 device_param->combs_buf = combs_buf;
16063
16064 void *hooks_buf = mymalloc (size_hooks);
16065
16066 device_param->hooks_buf = hooks_buf;
16067
16068 /**
16069 * kernel args
16070 */
16071
16072 device_param->kernel_params_buf32[24] = bitmap_mask;
16073 device_param->kernel_params_buf32[25] = bitmap_shift1;
16074 device_param->kernel_params_buf32[26] = bitmap_shift2;
16075 device_param->kernel_params_buf32[27] = 0; // salt_pos
16076 device_param->kernel_params_buf32[28] = 0; // loop_pos
16077 device_param->kernel_params_buf32[29] = 0; // loop_cnt
16078 device_param->kernel_params_buf32[30] = 0; // kernel_rules_cnt
16079 device_param->kernel_params_buf32[31] = 0; // digests_cnt
16080 device_param->kernel_params_buf32[32] = 0; // digests_offset
16081 device_param->kernel_params_buf32[33] = 0; // combs_mode
16082 device_param->kernel_params_buf32[34] = 0; // gid_max
16083
16084 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16085 ? &device_param->d_pws_buf
16086 : &device_param->d_pws_amp_buf;
16087 device_param->kernel_params[ 1] = &device_param->d_rules_c;
16088 device_param->kernel_params[ 2] = &device_param->d_combs_c;
16089 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
16090 device_param->kernel_params[ 4] = &device_param->d_tmps;
16091 device_param->kernel_params[ 5] = &device_param->d_hooks;
16092 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
16093 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
16094 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
16095 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
16096 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
16097 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
16098 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
16099 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
16100 device_param->kernel_params[14] = &device_param->d_plain_bufs;
16101 device_param->kernel_params[15] = &device_param->d_digests_buf;
16102 device_param->kernel_params[16] = &device_param->d_digests_shown;
16103 device_param->kernel_params[17] = &device_param->d_salt_bufs;
16104 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
16105 device_param->kernel_params[19] = &device_param->d_result;
16106 device_param->kernel_params[20] = &device_param->d_scryptV0_buf;
16107 device_param->kernel_params[21] = &device_param->d_scryptV1_buf;
16108 device_param->kernel_params[22] = &device_param->d_scryptV2_buf;
16109 device_param->kernel_params[23] = &device_param->d_scryptV3_buf;
16110 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
16111 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
16112 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
16113 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
16114 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
16115 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
16116 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
16117 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
16118 device_param->kernel_params[32] = &device_param->kernel_params_buf32[32];
16119 device_param->kernel_params[33] = &device_param->kernel_params_buf32[33];
16120 device_param->kernel_params[34] = &device_param->kernel_params_buf32[34];
16121
16122 device_param->kernel_params_mp_buf64[3] = 0;
16123 device_param->kernel_params_mp_buf32[4] = 0;
16124 device_param->kernel_params_mp_buf32[5] = 0;
16125 device_param->kernel_params_mp_buf32[6] = 0;
16126 device_param->kernel_params_mp_buf32[7] = 0;
16127 device_param->kernel_params_mp_buf32[8] = 0;
16128
16129 device_param->kernel_params_mp[0] = NULL;
16130 device_param->kernel_params_mp[1] = NULL;
16131 device_param->kernel_params_mp[2] = NULL;
16132 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
16133 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
16134 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
16135 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
16136 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
16137 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
16138
16139 device_param->kernel_params_mp_l_buf64[3] = 0;
16140 device_param->kernel_params_mp_l_buf32[4] = 0;
16141 device_param->kernel_params_mp_l_buf32[5] = 0;
16142 device_param->kernel_params_mp_l_buf32[6] = 0;
16143 device_param->kernel_params_mp_l_buf32[7] = 0;
16144 device_param->kernel_params_mp_l_buf32[8] = 0;
16145 device_param->kernel_params_mp_l_buf32[9] = 0;
16146
16147 device_param->kernel_params_mp_l[0] = NULL;
16148 device_param->kernel_params_mp_l[1] = NULL;
16149 device_param->kernel_params_mp_l[2] = NULL;
16150 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
16151 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
16152 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
16153 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
16154 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
16155 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
16156 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
16157
16158 device_param->kernel_params_mp_r_buf64[3] = 0;
16159 device_param->kernel_params_mp_r_buf32[4] = 0;
16160 device_param->kernel_params_mp_r_buf32[5] = 0;
16161 device_param->kernel_params_mp_r_buf32[6] = 0;
16162 device_param->kernel_params_mp_r_buf32[7] = 0;
16163 device_param->kernel_params_mp_r_buf32[8] = 0;
16164
16165 device_param->kernel_params_mp_r[0] = NULL;
16166 device_param->kernel_params_mp_r[1] = NULL;
16167 device_param->kernel_params_mp_r[2] = NULL;
16168 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
16169 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
16170 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
16171 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
16172 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
16173 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
16174
16175 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
16176 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
16177
16178 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
16179 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
16180 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
16181 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
16182 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
16183 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
16184 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
16185
16186 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
16187 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
16188
16189 device_param->kernel_params_memset_buf32[1] = 0; // value
16190 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
16191
16192 device_param->kernel_params_memset[0] = NULL;
16193 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
16194 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
16195
16196 /**
16197 * kernel name
16198 */
16199
16200 size_t kernel_wgs_tmp;
16201
16202 char kernel_name[64] = { 0 };
16203
16204 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16205 {
16206 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16207 {
16208 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
16209
16210 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16211
16212 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
16213
16214 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16215
16216 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
16217
16218 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16219 }
16220 else
16221 {
16222 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
16223
16224 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16225
16226 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
16227
16228 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16229
16230 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
16231
16232 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16233 }
16234
16235 if (data.attack_mode == ATTACK_MODE_BF)
16236 {
16237 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16238 {
16239 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
16240
16241 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16242
16243 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);
16244 }
16245 }
16246 }
16247 else
16248 {
16249 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
16250
16251 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16252
16253 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
16254
16255 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16256
16257 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
16258
16259 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16260
16261 if (opts_type & OPTS_TYPE_HOOK12)
16262 {
16263 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16264
16265 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16266
16267 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);
16268 }
16269
16270 if (opts_type & OPTS_TYPE_HOOK23)
16271 {
16272 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16273
16274 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16275
16276 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);
16277 }
16278 }
16279
16280 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);
16281 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);
16282 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);
16283
16284 for (uint i = 0; i <= 23; i++)
16285 {
16286 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16287 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16288 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16289
16290 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16291 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16292 }
16293
16294 for (uint i = 24; i <= 34; i++)
16295 {
16296 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16297 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16298 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16299
16300 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16301 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16302 }
16303
16304 // GPU memset
16305
16306 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16307
16308 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);
16309
16310 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
16311 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16312 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16313
16314 // MP start
16315
16316 if (attack_mode == ATTACK_MODE_BF)
16317 {
16318 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16319 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16320
16321 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);
16322 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);
16323
16324 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16325 {
16326 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16327 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16328 }
16329 }
16330 else if (attack_mode == ATTACK_MODE_HYBRID1)
16331 {
16332 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16333
16334 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);
16335 }
16336 else if (attack_mode == ATTACK_MODE_HYBRID2)
16337 {
16338 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16339
16340 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);
16341 }
16342
16343 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16344 {
16345 // nothing to do
16346 }
16347 else
16348 {
16349 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16350
16351 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);
16352 }
16353
16354 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16355 {
16356 // nothing to do
16357 }
16358 else
16359 {
16360 for (uint i = 0; i < 5; i++)
16361 {
16362 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16363 }
16364
16365 for (uint i = 5; i < 7; i++)
16366 {
16367 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16368 }
16369 }
16370
16371 // maybe this has been updated by clGetKernelWorkGroupInfo()
16372 // value can only be decreased, so we don't need to reallocate buffers
16373
16374 device_param->kernel_threads = kernel_threads;
16375
16376 // zero some data buffers
16377
16378 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16379 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16380 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16381 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16382 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16383 run_kernel_bzero (device_param, device_param->d_result, size_results);
16384
16385 /**
16386 * special buffers
16387 */
16388
16389 if (attack_kern == ATTACK_KERN_STRAIGHT)
16390 {
16391 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16392 }
16393 else if (attack_kern == ATTACK_KERN_COMBI)
16394 {
16395 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16396 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16397 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16398 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16399 }
16400 else if (attack_kern == ATTACK_KERN_BF)
16401 {
16402 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16403 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16404 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16405 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16406 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16407 }
16408
16409 #if defined(HAVE_HWMON)
16410
16411 /**
16412 * Store initial fanspeed if gpu_temp_retain is enabled
16413 */
16414
16415 if (gpu_temp_disable == 0)
16416 {
16417 if (gpu_temp_retain != 0)
16418 {
16419 hc_thread_mutex_lock (mux_adl);
16420
16421 if (data.hm_device[device_id].fan_get_supported == 1)
16422 {
16423 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16424 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16425
16426 // we also set it to tell the OS we take control over the fan and it's automatic controller
16427 // if it was set to automatic. we do not control user-defined fanspeeds.
16428
16429 if (fanpolicy == 1)
16430 {
16431 data.hm_device[device_id].fan_set_supported = 1;
16432
16433 int rc = -1;
16434
16435 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16436 {
16437 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16438 }
16439 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16440 {
16441 #ifdef LINUX
16442 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
16443 #endif
16444
16445 #ifdef WIN
16446 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
16447 #endif
16448 }
16449
16450 if (rc == 0)
16451 {
16452 data.hm_device[device_id].fan_set_supported = 1;
16453 }
16454 else
16455 {
16456 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16457
16458 data.hm_device[device_id].fan_set_supported = 0;
16459 }
16460 }
16461 else
16462 {
16463 data.hm_device[device_id].fan_set_supported = 0;
16464 }
16465 }
16466
16467 hc_thread_mutex_unlock (mux_adl);
16468 }
16469 }
16470
16471 #endif // HAVE_HWMON
16472 }
16473
16474 if (data.quiet == 0) log_info_nn ("");
16475
16476 /**
16477 * In benchmark-mode, inform user which algorithm is checked
16478 */
16479
16480 if (benchmark == 1)
16481 {
16482 if (machine_readable == 0)
16483 {
16484 quiet = 0;
16485
16486 data.quiet = quiet;
16487
16488 char *hash_type = strhashtype (data.hash_mode); // not a bug
16489
16490 log_info ("Hashtype: %s", hash_type);
16491 log_info ("");
16492 }
16493 }
16494
16495 /**
16496 * keep track of the progress
16497 */
16498
16499 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16500 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16501 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16502
16503 /**
16504 * open filehandles
16505 */
16506
16507 #if _WIN
16508 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16509 {
16510 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16511
16512 return (-1);
16513 }
16514
16515 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16516 {
16517 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16518
16519 return (-1);
16520 }
16521
16522 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16523 {
16524 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16525
16526 return (-1);
16527 }
16528 #endif
16529
16530 /**
16531 * dictionary pad
16532 */
16533
16534 segment_size *= (1024 * 1024);
16535
16536 data.segment_size = segment_size;
16537
16538 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16539
16540 wl_data->buf = (char *) mymalloc (segment_size);
16541 wl_data->avail = segment_size;
16542 wl_data->incr = segment_size;
16543 wl_data->cnt = 0;
16544 wl_data->pos = 0;
16545
16546 cs_t *css_buf = NULL;
16547 uint css_cnt = 0;
16548 uint dictcnt = 0;
16549 uint maskcnt = 1;
16550 char **masks = NULL;
16551 char **dictfiles = NULL;
16552
16553 uint mask_from_file = 0;
16554
16555 if (attack_mode == ATTACK_MODE_STRAIGHT)
16556 {
16557 if (wordlist_mode == WL_MODE_FILE)
16558 {
16559 int wls_left = myargc - (optind + 1);
16560
16561 for (int i = 0; i < wls_left; i++)
16562 {
16563 char *l0_filename = myargv[optind + 1 + i];
16564
16565 struct stat l0_stat;
16566
16567 if (stat (l0_filename, &l0_stat) == -1)
16568 {
16569 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16570
16571 return (-1);
16572 }
16573
16574 uint is_dir = S_ISDIR (l0_stat.st_mode);
16575
16576 if (is_dir == 0)
16577 {
16578 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16579
16580 dictcnt++;
16581
16582 dictfiles[dictcnt - 1] = l0_filename;
16583 }
16584 else
16585 {
16586 // do not allow --keyspace w/ a directory
16587
16588 if (keyspace == 1)
16589 {
16590 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16591
16592 return (-1);
16593 }
16594
16595 char **dictionary_files = NULL;
16596
16597 dictionary_files = scan_directory (l0_filename);
16598
16599 if (dictionary_files != NULL)
16600 {
16601 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16602
16603 for (int d = 0; dictionary_files[d] != NULL; d++)
16604 {
16605 char *l1_filename = dictionary_files[d];
16606
16607 struct stat l1_stat;
16608
16609 if (stat (l1_filename, &l1_stat) == -1)
16610 {
16611 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16612
16613 return (-1);
16614 }
16615
16616 if (S_ISREG (l1_stat.st_mode))
16617 {
16618 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16619
16620 dictcnt++;
16621
16622 dictfiles[dictcnt - 1] = strdup (l1_filename);
16623 }
16624 }
16625 }
16626
16627 local_free (dictionary_files);
16628 }
16629 }
16630
16631 if (dictcnt < 1)
16632 {
16633 log_error ("ERROR: No usable dictionary file found.");
16634
16635 return (-1);
16636 }
16637 }
16638 else if (wordlist_mode == WL_MODE_STDIN)
16639 {
16640 dictcnt = 1;
16641 }
16642 }
16643 else if (attack_mode == ATTACK_MODE_COMBI)
16644 {
16645 // display
16646
16647 char *dictfile1 = myargv[optind + 1 + 0];
16648 char *dictfile2 = myargv[optind + 1 + 1];
16649
16650 // find the bigger dictionary and use as base
16651
16652 FILE *fp1 = NULL;
16653 FILE *fp2 = NULL;
16654
16655 struct stat tmp_stat;
16656
16657 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16658 {
16659 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16660
16661 return (-1);
16662 }
16663
16664 if (stat (dictfile1, &tmp_stat) == -1)
16665 {
16666 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16667
16668 fclose (fp1);
16669
16670 return (-1);
16671 }
16672
16673 if (S_ISDIR (tmp_stat.st_mode))
16674 {
16675 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16676
16677 fclose (fp1);
16678
16679 return (-1);
16680 }
16681
16682 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16683 {
16684 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16685
16686 fclose (fp1);
16687
16688 return (-1);
16689 }
16690
16691 if (stat (dictfile2, &tmp_stat) == -1)
16692 {
16693 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16694
16695 fclose (fp1);
16696 fclose (fp2);
16697
16698 return (-1);
16699 }
16700
16701 if (S_ISDIR (tmp_stat.st_mode))
16702 {
16703 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16704
16705 fclose (fp1);
16706 fclose (fp2);
16707
16708 return (-1);
16709 }
16710
16711 data.combs_cnt = 1;
16712
16713 data.quiet = 1;
16714
16715 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16716
16717 data.quiet = quiet;
16718
16719 if (words1_cnt == 0)
16720 {
16721 log_error ("ERROR: %s: empty file", dictfile1);
16722
16723 fclose (fp1);
16724 fclose (fp2);
16725
16726 return (-1);
16727 }
16728
16729 data.combs_cnt = 1;
16730
16731 data.quiet = 1;
16732
16733 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16734
16735 data.quiet = quiet;
16736
16737 if (words2_cnt == 0)
16738 {
16739 log_error ("ERROR: %s: empty file", dictfile2);
16740
16741 fclose (fp1);
16742 fclose (fp2);
16743
16744 return (-1);
16745 }
16746
16747 fclose (fp1);
16748 fclose (fp2);
16749
16750 data.dictfile = dictfile1;
16751 data.dictfile2 = dictfile2;
16752
16753 if (words1_cnt >= words2_cnt)
16754 {
16755 data.combs_cnt = words2_cnt;
16756 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16757
16758 dictfiles = &data.dictfile;
16759
16760 dictcnt = 1;
16761 }
16762 else
16763 {
16764 data.combs_cnt = words1_cnt;
16765 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16766
16767 dictfiles = &data.dictfile2;
16768
16769 dictcnt = 1;
16770
16771 // we also have to switch wordlist related rules!
16772
16773 char *tmpc = data.rule_buf_l;
16774
16775 data.rule_buf_l = data.rule_buf_r;
16776 data.rule_buf_r = tmpc;
16777
16778 int tmpi = data.rule_len_l;
16779
16780 data.rule_len_l = data.rule_len_r;
16781 data.rule_len_r = tmpi;
16782 }
16783 }
16784 else if (attack_mode == ATTACK_MODE_BF)
16785 {
16786 char *mask = NULL;
16787
16788 maskcnt = 0;
16789
16790 if (benchmark == 0)
16791 {
16792 mask = myargv[optind + 1];
16793
16794 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16795
16796 if ((optind + 2) <= myargc)
16797 {
16798 struct stat file_stat;
16799
16800 if (stat (mask, &file_stat) == -1)
16801 {
16802 maskcnt = 1;
16803
16804 masks[maskcnt - 1] = mystrdup (mask);
16805 }
16806 else
16807 {
16808 int wls_left = myargc - (optind + 1);
16809
16810 uint masks_avail = INCR_MASKS;
16811
16812 for (int i = 0; i < wls_left; i++)
16813 {
16814 if (i != 0)
16815 {
16816 mask = myargv[optind + 1 + i];
16817
16818 if (stat (mask, &file_stat) == -1)
16819 {
16820 log_error ("ERROR: %s: %s", mask, strerror (errno));
16821
16822 return (-1);
16823 }
16824 }
16825
16826 uint is_file = S_ISREG (file_stat.st_mode);
16827
16828 if (is_file == 1)
16829 {
16830 FILE *mask_fp;
16831
16832 if ((mask_fp = fopen (mask, "r")) == NULL)
16833 {
16834 log_error ("ERROR: %s: %s", mask, strerror (errno));
16835
16836 return (-1);
16837 }
16838
16839 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16840
16841 while (!feof (mask_fp))
16842 {
16843 memset (line_buf, 0, HCBUFSIZ);
16844
16845 int line_len = fgetl (mask_fp, line_buf);
16846
16847 if (line_len == 0) continue;
16848
16849 if (line_buf[0] == '#') continue;
16850
16851 if (masks_avail == maskcnt)
16852 {
16853 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16854
16855 masks_avail += INCR_MASKS;
16856 }
16857
16858 masks[maskcnt] = mystrdup (line_buf);
16859
16860 maskcnt++;
16861 }
16862
16863 myfree (line_buf);
16864
16865 fclose (mask_fp);
16866 }
16867 else
16868 {
16869 log_error ("ERROR: %s: unsupported file-type", mask);
16870
16871 return (-1);
16872 }
16873 }
16874
16875 mask_from_file = 1;
16876 }
16877 }
16878 else
16879 {
16880 custom_charset_1 = (char *) "?l?d?u";
16881 custom_charset_2 = (char *) "?l?d";
16882 custom_charset_3 = (char *) "?l?d*!$@_";
16883
16884 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16885 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16886 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16887
16888 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16889
16890 wordlist_mode = WL_MODE_MASK;
16891
16892 data.wordlist_mode = wordlist_mode;
16893
16894 increment = 1;
16895
16896 maskcnt = 1;
16897 }
16898 }
16899 else
16900 {
16901 /**
16902 * generate full masks and charsets
16903 */
16904
16905 masks = (char **) mymalloc (sizeof (char *));
16906
16907 switch (hash_mode)
16908 {
16909 case 1731: pw_min = 5;
16910 pw_max = 5;
16911 mask = mystrdup ("?b?b?b?b?b");
16912 break;
16913 case 12500: pw_min = 5;
16914 pw_max = 5;
16915 mask = mystrdup ("?b?b?b?b?b");
16916 break;
16917 default: pw_min = 7;
16918 pw_max = 7;
16919 mask = mystrdup ("?b?b?b?b?b?b?b");
16920 break;
16921 }
16922
16923 maskcnt = 1;
16924
16925 masks[maskcnt - 1] = mystrdup (mask);
16926
16927 wordlist_mode = WL_MODE_MASK;
16928
16929 data.wordlist_mode = wordlist_mode;
16930
16931 increment = 1;
16932 }
16933
16934 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16935
16936 if (increment)
16937 {
16938 if (increment_min > pw_min) pw_min = increment_min;
16939
16940 if (increment_max < pw_max) pw_max = increment_max;
16941 }
16942 }
16943 else if (attack_mode == ATTACK_MODE_HYBRID1)
16944 {
16945 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16946
16947 // display
16948
16949 char *mask = myargv[myargc - 1];
16950
16951 maskcnt = 0;
16952
16953 masks = (char **) mymalloc (1 * sizeof (char *));
16954
16955 // mod
16956
16957 struct stat file_stat;
16958
16959 if (stat (mask, &file_stat) == -1)
16960 {
16961 maskcnt = 1;
16962
16963 masks[maskcnt - 1] = mystrdup (mask);
16964 }
16965 else
16966 {
16967 uint is_file = S_ISREG (file_stat.st_mode);
16968
16969 if (is_file == 1)
16970 {
16971 FILE *mask_fp;
16972
16973 if ((mask_fp = fopen (mask, "r")) == NULL)
16974 {
16975 log_error ("ERROR: %s: %s", mask, strerror (errno));
16976
16977 return (-1);
16978 }
16979
16980 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16981
16982 uint masks_avail = 1;
16983
16984 while (!feof (mask_fp))
16985 {
16986 memset (line_buf, 0, HCBUFSIZ);
16987
16988 int line_len = fgetl (mask_fp, line_buf);
16989
16990 if (line_len == 0) continue;
16991
16992 if (line_buf[0] == '#') continue;
16993
16994 if (masks_avail == maskcnt)
16995 {
16996 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16997
16998 masks_avail += INCR_MASKS;
16999 }
17000
17001 masks[maskcnt] = mystrdup (line_buf);
17002
17003 maskcnt++;
17004 }
17005
17006 myfree (line_buf);
17007
17008 fclose (mask_fp);
17009
17010 mask_from_file = 1;
17011 }
17012 else
17013 {
17014 maskcnt = 1;
17015
17016 masks[maskcnt - 1] = mystrdup (mask);
17017 }
17018 }
17019
17020 // base
17021
17022 int wls_left = myargc - (optind + 2);
17023
17024 for (int i = 0; i < wls_left; i++)
17025 {
17026 char *filename = myargv[optind + 1 + i];
17027
17028 struct stat file_stat;
17029
17030 if (stat (filename, &file_stat) == -1)
17031 {
17032 log_error ("ERROR: %s: %s", filename, strerror (errno));
17033
17034 return (-1);
17035 }
17036
17037 uint is_dir = S_ISDIR (file_stat.st_mode);
17038
17039 if (is_dir == 0)
17040 {
17041 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17042
17043 dictcnt++;
17044
17045 dictfiles[dictcnt - 1] = filename;
17046 }
17047 else
17048 {
17049 // do not allow --keyspace w/ a directory
17050
17051 if (keyspace == 1)
17052 {
17053 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17054
17055 return (-1);
17056 }
17057
17058 char **dictionary_files = NULL;
17059
17060 dictionary_files = scan_directory (filename);
17061
17062 if (dictionary_files != NULL)
17063 {
17064 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17065
17066 for (int d = 0; dictionary_files[d] != NULL; d++)
17067 {
17068 char *l1_filename = dictionary_files[d];
17069
17070 struct stat l1_stat;
17071
17072 if (stat (l1_filename, &l1_stat) == -1)
17073 {
17074 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17075
17076 return (-1);
17077 }
17078
17079 if (S_ISREG (l1_stat.st_mode))
17080 {
17081 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17082
17083 dictcnt++;
17084
17085 dictfiles[dictcnt - 1] = strdup (l1_filename);
17086 }
17087 }
17088 }
17089
17090 local_free (dictionary_files);
17091 }
17092 }
17093
17094 if (dictcnt < 1)
17095 {
17096 log_error ("ERROR: No usable dictionary file found.");
17097
17098 return (-1);
17099 }
17100
17101 if (increment)
17102 {
17103 maskcnt = 0;
17104
17105 uint mask_min = increment_min; // we can't reject smaller masks here
17106 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17107
17108 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17109 {
17110 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17111
17112 if (cur_mask == NULL) break;
17113
17114 masks[maskcnt] = cur_mask;
17115
17116 maskcnt++;
17117
17118 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17119 }
17120 }
17121 }
17122 else if (attack_mode == ATTACK_MODE_HYBRID2)
17123 {
17124 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
17125
17126 // display
17127
17128 char *mask = myargv[optind + 1 + 0];
17129
17130 maskcnt = 0;
17131
17132 masks = (char **) mymalloc (1 * sizeof (char *));
17133
17134 // mod
17135
17136 struct stat file_stat;
17137
17138 if (stat (mask, &file_stat) == -1)
17139 {
17140 maskcnt = 1;
17141
17142 masks[maskcnt - 1] = mystrdup (mask);
17143 }
17144 else
17145 {
17146 uint is_file = S_ISREG (file_stat.st_mode);
17147
17148 if (is_file == 1)
17149 {
17150 FILE *mask_fp;
17151
17152 if ((mask_fp = fopen (mask, "r")) == NULL)
17153 {
17154 log_error ("ERROR: %s: %s", mask, strerror (errno));
17155
17156 return (-1);
17157 }
17158
17159 char *line_buf = (char *) mymalloc (HCBUFSIZ);
17160
17161 uint masks_avail = 1;
17162
17163 while (!feof (mask_fp))
17164 {
17165 memset (line_buf, 0, HCBUFSIZ);
17166
17167 int line_len = fgetl (mask_fp, line_buf);
17168
17169 if (line_len == 0) continue;
17170
17171 if (line_buf[0] == '#') continue;
17172
17173 if (masks_avail == maskcnt)
17174 {
17175 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17176
17177 masks_avail += INCR_MASKS;
17178 }
17179
17180 masks[maskcnt] = mystrdup (line_buf);
17181
17182 maskcnt++;
17183 }
17184
17185 myfree (line_buf);
17186
17187 fclose (mask_fp);
17188
17189 mask_from_file = 1;
17190 }
17191 else
17192 {
17193 maskcnt = 1;
17194
17195 masks[maskcnt - 1] = mystrdup (mask);
17196 }
17197 }
17198
17199 // base
17200
17201 int wls_left = myargc - (optind + 2);
17202
17203 for (int i = 0; i < wls_left; i++)
17204 {
17205 char *filename = myargv[optind + 2 + i];
17206
17207 struct stat file_stat;
17208
17209 if (stat (filename, &file_stat) == -1)
17210 {
17211 log_error ("ERROR: %s: %s", filename, strerror (errno));
17212
17213 return (-1);
17214 }
17215
17216 uint is_dir = S_ISDIR (file_stat.st_mode);
17217
17218 if (is_dir == 0)
17219 {
17220 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17221
17222 dictcnt++;
17223
17224 dictfiles[dictcnt - 1] = filename;
17225 }
17226 else
17227 {
17228 // do not allow --keyspace w/ a directory
17229
17230 if (keyspace == 1)
17231 {
17232 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17233
17234 return (-1);
17235 }
17236
17237 char **dictionary_files = NULL;
17238
17239 dictionary_files = scan_directory (filename);
17240
17241 if (dictionary_files != NULL)
17242 {
17243 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17244
17245 for (int d = 0; dictionary_files[d] != NULL; d++)
17246 {
17247 char *l1_filename = dictionary_files[d];
17248
17249 struct stat l1_stat;
17250
17251 if (stat (l1_filename, &l1_stat) == -1)
17252 {
17253 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17254
17255 return (-1);
17256 }
17257
17258 if (S_ISREG (l1_stat.st_mode))
17259 {
17260 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17261
17262 dictcnt++;
17263
17264 dictfiles[dictcnt - 1] = strdup (l1_filename);
17265 }
17266 }
17267 }
17268
17269 local_free (dictionary_files);
17270 }
17271 }
17272
17273 if (dictcnt < 1)
17274 {
17275 log_error ("ERROR: No usable dictionary file found.");
17276
17277 return (-1);
17278 }
17279
17280 if (increment)
17281 {
17282 maskcnt = 0;
17283
17284 uint mask_min = increment_min; // we can't reject smaller masks here
17285 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17286
17287 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17288 {
17289 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17290
17291 if (cur_mask == NULL) break;
17292
17293 masks[maskcnt] = cur_mask;
17294
17295 maskcnt++;
17296
17297 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17298 }
17299 }
17300 }
17301
17302 data.pw_min = pw_min;
17303 data.pw_max = pw_max;
17304
17305 /**
17306 * weak hash check
17307 */
17308
17309 if (weak_hash_threshold >= salts_cnt)
17310 {
17311 hc_device_param_t *device_param = NULL;
17312
17313 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17314 {
17315 device_param = &data.devices_param[device_id];
17316
17317 if (device_param->skipped) continue;
17318
17319 break;
17320 }
17321
17322 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17323
17324 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17325 {
17326 weak_hash_check (device_param, salt_pos);
17327 }
17328
17329 // Display hack, guarantee that there is at least one \r before real start
17330
17331 //if (data.quiet == 0) log_info ("");
17332 }
17333
17334 /**
17335 * status and monitor threads
17336 */
17337
17338 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17339 {
17340 data.devices_status = STATUS_STARTING;
17341 }
17342
17343 uint inner_threads_cnt = 0;
17344
17345 hc_thread_t *inner_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17346
17347 data.shutdown_inner = 0;
17348
17349 /**
17350 * Outfile remove
17351 */
17352
17353 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
17354 {
17355 hc_thread_create (inner_threads[inner_threads_cnt], thread_monitor, NULL);
17356
17357 inner_threads_cnt++;
17358
17359 if (outfile_check_timer != 0)
17360 {
17361 if (data.outfile_check_directory != NULL)
17362 {
17363 if ((hash_mode != 5200) &&
17364 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17365 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17366 (hash_mode != 9000))
17367 {
17368 hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, NULL);
17369
17370 inner_threads_cnt++;
17371 }
17372 else
17373 {
17374 outfile_check_timer = 0;
17375 }
17376 }
17377 else
17378 {
17379 outfile_check_timer = 0;
17380 }
17381 }
17382 }
17383
17384 /**
17385 * Inform the user if we got some hashes remove because of the pot file remove feature
17386 */
17387
17388 if (data.quiet == 0)
17389 {
17390 if (potfile_remove_cracks > 0)
17391 {
17392 if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
17393 else log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
17394 }
17395 }
17396
17397 data.outfile_check_timer = outfile_check_timer;
17398
17399 /**
17400 * main loop
17401 */
17402
17403 char **induction_dictionaries = NULL;
17404
17405 int induction_dictionaries_cnt = 0;
17406
17407 hcstat_table_t *root_table_buf = NULL;
17408 hcstat_table_t *markov_table_buf = NULL;
17409
17410 uint initial_restore_done = 0;
17411
17412 data.maskcnt = maskcnt;
17413
17414 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17415 {
17416 if (data.devices_status == STATUS_CRACKED) continue;
17417 if (data.devices_status == STATUS_ABORTED) continue;
17418 if (data.devices_status == STATUS_QUIT) continue;
17419
17420 if (maskpos > rd->maskpos)
17421 {
17422 rd->dictpos = 0;
17423 }
17424
17425 rd->maskpos = maskpos;
17426 data.maskpos = maskpos;
17427
17428 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17429 {
17430 char *mask = masks[maskpos];
17431
17432 if (mask_from_file == 1)
17433 {
17434 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17435
17436 char *str_ptr;
17437 uint str_pos;
17438
17439 uint mask_offset = 0;
17440
17441 uint separator_cnt;
17442
17443 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17444 {
17445 str_ptr = strstr (mask + mask_offset, ",");
17446
17447 if (str_ptr == NULL) break;
17448
17449 str_pos = str_ptr - mask;
17450
17451 // escaped separator, i.e. "\,"
17452
17453 if (str_pos > 0)
17454 {
17455 if (mask[str_pos - 1] == '\\')
17456 {
17457 separator_cnt --;
17458
17459 mask_offset = str_pos + 1;
17460
17461 continue;
17462 }
17463 }
17464
17465 // reset the offset
17466
17467 mask_offset = 0;
17468
17469 mask[str_pos] = '\0';
17470
17471 switch (separator_cnt)
17472 {
17473 case 0:
17474 mp_reset_usr (mp_usr, 0);
17475
17476 custom_charset_1 = mask;
17477 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17478 break;
17479
17480 case 1:
17481 mp_reset_usr (mp_usr, 1);
17482
17483 custom_charset_2 = mask;
17484 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17485 break;
17486
17487 case 2:
17488 mp_reset_usr (mp_usr, 2);
17489
17490 custom_charset_3 = mask;
17491 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17492 break;
17493
17494 case 3:
17495 mp_reset_usr (mp_usr, 3);
17496
17497 custom_charset_4 = mask;
17498 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17499 break;
17500 }
17501
17502 mask = mask + str_pos + 1;
17503 }
17504
17505 /**
17506 * What follows is a very special case where "\," is within the mask field of a line in a .hcmask file only because otherwise (without the "\")
17507 * it would be interpreted as a custom charset definition.
17508 *
17509 * We need to replace all "\," with just "," within the mask (but allow the special case "\\," which means "\" followed by ",")
17510 * Note: "\\" is not needed to replace all "\" within the mask! The meaning of "\\" within a line containing the string "\\," is just to allow "\" followed by ","
17511 */
17512
17513 uint mask_len_cur = strlen (mask);
17514
17515 uint mask_out_pos = 0;
17516 char mask_prev = 0;
17517
17518 for (uint mask_iter = 0; mask_iter < mask_len_cur; mask_iter++, mask_out_pos++)
17519 {
17520 if (mask[mask_iter] == ',')
17521 {
17522 if (mask_prev == '\\')
17523 {
17524 mask_out_pos -= 1; // this means: skip the previous "\"
17525 }
17526 }
17527
17528 mask_prev = mask[mask_iter];
17529
17530 mask[mask_out_pos] = mask[mask_iter];
17531 }
17532
17533 mask[mask_out_pos] = '\0';
17534 }
17535
17536 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17537 {
17538 if (maskpos > 0)
17539 {
17540 local_free (css_buf);
17541 local_free (data.root_css_buf);
17542 local_free (data.markov_css_buf);
17543
17544 local_free (masks[maskpos - 1]);
17545 }
17546
17547 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17548
17549 data.mask = mask;
17550 data.css_cnt = css_cnt;
17551 data.css_buf = css_buf;
17552
17553 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17554
17555 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17556
17557 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17558 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17559
17560 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17561
17562 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17563
17564 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17565 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17566
17567 data.root_css_buf = root_css_buf;
17568 data.markov_css_buf = markov_css_buf;
17569
17570 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17571
17572 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17573
17574 local_free (root_table_buf);
17575 local_free (markov_table_buf);
17576
17577 // args
17578
17579 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17580 {
17581 hc_device_param_t *device_param = &data.devices_param[device_id];
17582
17583 if (device_param->skipped) continue;
17584
17585 device_param->kernel_params_mp[0] = &device_param->d_combs;
17586 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17587 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17588
17589 device_param->kernel_params_mp_buf64[3] = 0;
17590 device_param->kernel_params_mp_buf32[4] = css_cnt;
17591 device_param->kernel_params_mp_buf32[5] = 0;
17592 device_param->kernel_params_mp_buf32[6] = 0;
17593 device_param->kernel_params_mp_buf32[7] = 0;
17594
17595 if (attack_mode == ATTACK_MODE_HYBRID1)
17596 {
17597 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17598 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17599 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17600 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17601 }
17602 else if (attack_mode == ATTACK_MODE_HYBRID2)
17603 {
17604 device_param->kernel_params_mp_buf32[5] = 0;
17605 device_param->kernel_params_mp_buf32[6] = 0;
17606 device_param->kernel_params_mp_buf32[7] = 0;
17607 }
17608
17609 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]);
17610 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]);
17611 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]);
17612
17613 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);
17614 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);
17615 }
17616 }
17617 else if (attack_mode == ATTACK_MODE_BF)
17618 {
17619 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17620
17621 if (increment)
17622 {
17623 for (uint i = 0; i < dictcnt; i++)
17624 {
17625 local_free (dictfiles[i]);
17626 }
17627
17628 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17629 {
17630 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17631
17632 if (l1_filename == NULL) break;
17633
17634 dictcnt++;
17635
17636 dictfiles[dictcnt - 1] = l1_filename;
17637 }
17638 }
17639 else
17640 {
17641 dictcnt++;
17642
17643 dictfiles[dictcnt - 1] = mask;
17644 }
17645
17646 if (dictcnt == 0)
17647 {
17648 log_error ("ERROR: Mask is too small");
17649
17650 return (-1);
17651 }
17652 }
17653 }
17654
17655 free (induction_dictionaries);
17656
17657 // induction_dictionaries_cnt = 0; // implied
17658
17659 if (attack_mode != ATTACK_MODE_BF)
17660 {
17661 if (keyspace == 0)
17662 {
17663 induction_dictionaries = scan_directory (induction_directory);
17664
17665 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17666 }
17667 }
17668
17669 if (induction_dictionaries_cnt)
17670 {
17671 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17672 }
17673
17674 /**
17675 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17676 */
17677 if (keyspace == 1)
17678 {
17679 if ((maskcnt > 1) || (dictcnt > 1))
17680 {
17681 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17682
17683 return (-1);
17684 }
17685 }
17686
17687 for (uint dictpos = rd->dictpos; dictpos < dictcnt; dictpos++)
17688 {
17689 if (data.devices_status == STATUS_CRACKED) continue;
17690 if (data.devices_status == STATUS_ABORTED) continue;
17691 if (data.devices_status == STATUS_QUIT) continue;
17692
17693 rd->dictpos = dictpos;
17694
17695 char *subid = logfile_generate_subid ();
17696
17697 data.subid = subid;
17698
17699 logfile_sub_msg ("START");
17700
17701 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17702 {
17703 data.devices_status = STATUS_INIT;
17704 }
17705
17706 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17707 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17708 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17709
17710 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17711
17712 data.cpt_pos = 0;
17713
17714 data.cpt_start = time (NULL);
17715
17716 data.cpt_total = 0;
17717
17718 if (data.restore == 0)
17719 {
17720 rd->words_cur = skip;
17721
17722 skip = 0;
17723
17724 data.skip = 0;
17725 }
17726
17727 data.ms_paused = 0;
17728
17729 data.kernel_power_final = 0;
17730
17731 data.words_cur = rd->words_cur;
17732
17733 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17734 {
17735 hc_device_param_t *device_param = &data.devices_param[device_id];
17736
17737 if (device_param->skipped) continue;
17738
17739 device_param->speed_pos = 0;
17740
17741 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17742 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17743
17744 device_param->exec_pos = 0;
17745
17746 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17747
17748 device_param->outerloop_pos = 0;
17749 device_param->outerloop_left = 0;
17750 device_param->innerloop_pos = 0;
17751 device_param->innerloop_left = 0;
17752
17753 // some more resets:
17754
17755 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17756
17757 device_param->pws_cnt = 0;
17758
17759 device_param->words_off = 0;
17760 device_param->words_done = 0;
17761 }
17762
17763 // figure out some workload
17764
17765 if (attack_mode == ATTACK_MODE_STRAIGHT)
17766 {
17767 if (data.wordlist_mode == WL_MODE_FILE)
17768 {
17769 char *dictfile = NULL;
17770
17771 if (induction_dictionaries_cnt)
17772 {
17773 dictfile = induction_dictionaries[0];
17774 }
17775 else
17776 {
17777 dictfile = dictfiles[dictpos];
17778 }
17779
17780 data.dictfile = dictfile;
17781
17782 logfile_sub_string (dictfile);
17783
17784 for (uint i = 0; i < rp_files_cnt; i++)
17785 {
17786 logfile_sub_var_string ("rulefile", rp_files[i]);
17787 }
17788
17789 FILE *fd2 = fopen (dictfile, "rb");
17790
17791 if (fd2 == NULL)
17792 {
17793 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17794
17795 return (-1);
17796 }
17797
17798 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17799
17800 fclose (fd2);
17801
17802 if (data.words_cnt == 0)
17803 {
17804 logfile_sub_msg ("STOP");
17805
17806 continue;
17807 }
17808 }
17809 }
17810 else if (attack_mode == ATTACK_MODE_COMBI)
17811 {
17812 char *dictfile = data.dictfile;
17813 char *dictfile2 = data.dictfile2;
17814
17815 logfile_sub_string (dictfile);
17816 logfile_sub_string (dictfile2);
17817
17818 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17819 {
17820 FILE *fd2 = fopen (dictfile, "rb");
17821
17822 if (fd2 == NULL)
17823 {
17824 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17825
17826 return (-1);
17827 }
17828
17829 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17830
17831 fclose (fd2);
17832 }
17833 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17834 {
17835 FILE *fd2 = fopen (dictfile2, "rb");
17836
17837 if (fd2 == NULL)
17838 {
17839 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17840
17841 return (-1);
17842 }
17843
17844 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17845
17846 fclose (fd2);
17847 }
17848
17849 if (data.words_cnt == 0)
17850 {
17851 logfile_sub_msg ("STOP");
17852
17853 continue;
17854 }
17855 }
17856 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17857 {
17858 char *dictfile = NULL;
17859
17860 if (induction_dictionaries_cnt)
17861 {
17862 dictfile = induction_dictionaries[0];
17863 }
17864 else
17865 {
17866 dictfile = dictfiles[dictpos];
17867 }
17868
17869 data.dictfile = dictfile;
17870
17871 char *mask = data.mask;
17872
17873 logfile_sub_string (dictfile);
17874 logfile_sub_string (mask);
17875
17876 FILE *fd2 = fopen (dictfile, "rb");
17877
17878 if (fd2 == NULL)
17879 {
17880 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17881
17882 return (-1);
17883 }
17884
17885 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17886
17887 fclose (fd2);
17888
17889 if (data.words_cnt == 0)
17890 {
17891 logfile_sub_msg ("STOP");
17892
17893 continue;
17894 }
17895 }
17896 else if (attack_mode == ATTACK_MODE_BF)
17897 {
17898 local_free (css_buf);
17899 local_free (data.root_css_buf);
17900 local_free (data.markov_css_buf);
17901
17902 char *mask = dictfiles[dictpos];
17903
17904 logfile_sub_string (mask);
17905
17906 // base
17907
17908 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17909
17910 if (opts_type & OPTS_TYPE_PT_UNICODE)
17911 {
17912 uint css_cnt_unicode = css_cnt * 2;
17913
17914 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17915
17916 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17917 {
17918 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17919
17920 css_buf_unicode[j + 1].cs_buf[0] = 0;
17921 css_buf_unicode[j + 1].cs_len = 1;
17922 }
17923
17924 free (css_buf);
17925
17926 css_buf = css_buf_unicode;
17927 css_cnt = css_cnt_unicode;
17928 }
17929
17930 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17931
17932 uint mask_min = pw_min;
17933 uint mask_max = pw_max;
17934
17935 if (opts_type & OPTS_TYPE_PT_UNICODE)
17936 {
17937 mask_min *= 2;
17938 mask_max *= 2;
17939 }
17940
17941 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17942 {
17943 if (css_cnt < mask_min)
17944 {
17945 log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
17946 }
17947
17948 if (css_cnt > mask_max)
17949 {
17950 log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
17951 }
17952
17953 // skip to next mask
17954
17955 logfile_sub_msg ("STOP");
17956
17957 continue;
17958 }
17959
17960 uint save_css_cnt = css_cnt;
17961
17962 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17963 {
17964 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17965 {
17966 uint salt_len = (uint) data.salts_buf[0].salt_len;
17967 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17968
17969 uint css_cnt_salt = css_cnt + salt_len;
17970
17971 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17972
17973 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17974
17975 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17976 {
17977 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17978 css_buf_salt[j].cs_len = 1;
17979 }
17980
17981 free (css_buf);
17982
17983 css_buf = css_buf_salt;
17984 css_cnt = css_cnt_salt;
17985 }
17986 }
17987
17988 data.mask = mask;
17989 data.css_cnt = css_cnt;
17990 data.css_buf = css_buf;
17991
17992 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17993
17994 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17995
17996 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17997
17998 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17999 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
18000
18001 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
18002
18003 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
18004
18005 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
18006 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
18007
18008 data.root_css_buf = root_css_buf;
18009 data.markov_css_buf = markov_css_buf;
18010
18011 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
18012
18013 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
18014
18015 local_free (root_table_buf);
18016 local_free (markov_table_buf);
18017
18018 // copy + args
18019
18020 uint css_cnt_l = css_cnt;
18021 uint css_cnt_r;
18022
18023 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
18024 {
18025 if (save_css_cnt < 6)
18026 {
18027 css_cnt_r = 1;
18028 }
18029 else if (save_css_cnt == 6)
18030 {
18031 css_cnt_r = 2;
18032 }
18033 else
18034 {
18035 if (opts_type & OPTS_TYPE_PT_UNICODE)
18036 {
18037 if (save_css_cnt == 8 || save_css_cnt == 10)
18038 {
18039 css_cnt_r = 2;
18040 }
18041 else
18042 {
18043 css_cnt_r = 4;
18044 }
18045 }
18046 else
18047 {
18048 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
18049 {
18050 css_cnt_r = 3;
18051 }
18052 else
18053 {
18054 css_cnt_r = 4;
18055 }
18056 }
18057 }
18058 }
18059 else
18060 {
18061 css_cnt_r = 1;
18062
18063 /* unfinished code?
18064 int sum = css_buf[css_cnt_r - 1].cs_len;
18065
18066 for (uint i = 1; i < 4 && i < css_cnt; i++)
18067 {
18068 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
18069
18070 css_cnt_r++;
18071
18072 sum *= css_buf[css_cnt_r - 1].cs_len;
18073 }
18074 */
18075 }
18076
18077 css_cnt_l -= css_cnt_r;
18078
18079 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
18080
18081 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18082 {
18083 hc_device_param_t *device_param = &data.devices_param[device_id];
18084
18085 if (device_param->skipped) continue;
18086
18087 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
18088 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
18089 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
18090
18091 device_param->kernel_params_mp_l_buf64[3] = 0;
18092 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
18093 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
18094 device_param->kernel_params_mp_l_buf32[6] = 0;
18095 device_param->kernel_params_mp_l_buf32[7] = 0;
18096 device_param->kernel_params_mp_l_buf32[8] = 0;
18097
18098 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
18099 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
18100 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
18101 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
18102
18103 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
18104 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
18105 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
18106
18107 device_param->kernel_params_mp_r_buf64[3] = 0;
18108 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
18109 device_param->kernel_params_mp_r_buf32[5] = 0;
18110 device_param->kernel_params_mp_r_buf32[6] = 0;
18111 device_param->kernel_params_mp_r_buf32[7] = 0;
18112
18113 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]);
18114 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]);
18115 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]);
18116
18117 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]);
18118 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]);
18119 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]);
18120
18121 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);
18122 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);
18123 }
18124 }
18125
18126 u64 words_base = data.words_cnt;
18127
18128 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18129 {
18130 if (data.kernel_rules_cnt)
18131 {
18132 words_base /= data.kernel_rules_cnt;
18133 }
18134 }
18135 else if (data.attack_kern == ATTACK_KERN_COMBI)
18136 {
18137 if (data.combs_cnt)
18138 {
18139 words_base /= data.combs_cnt;
18140 }
18141 }
18142 else if (data.attack_kern == ATTACK_KERN_BF)
18143 {
18144 if (data.bfs_cnt)
18145 {
18146 words_base /= data.bfs_cnt;
18147 }
18148 }
18149
18150 data.words_base = words_base;
18151
18152 if (keyspace == 1)
18153 {
18154 log_info ("%llu", (unsigned long long int) words_base);
18155
18156 return (0);
18157 }
18158
18159 if (data.words_cur > data.words_base)
18160 {
18161 log_error ("ERROR: Restore value greater keyspace");
18162
18163 return (-1);
18164 }
18165
18166 if (data.words_cur)
18167 {
18168 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18169 {
18170 for (uint i = 0; i < data.salts_cnt; i++)
18171 {
18172 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
18173 }
18174 }
18175 else if (data.attack_kern == ATTACK_KERN_COMBI)
18176 {
18177 for (uint i = 0; i < data.salts_cnt; i++)
18178 {
18179 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
18180 }
18181 }
18182 else if (data.attack_kern == ATTACK_KERN_BF)
18183 {
18184 for (uint i = 0; i < data.salts_cnt; i++)
18185 {
18186 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
18187 }
18188 }
18189 }
18190
18191 /*
18192 * Update loopback file
18193 */
18194
18195 if (loopback == 1)
18196 {
18197 time_t now;
18198
18199 time (&now);
18200
18201 uint random_num = get_random_num (0, 9999);
18202
18203 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
18204
18205 data.loopback_file = loopback_file;
18206 }
18207
18208 /*
18209 * Update dictionary statistic
18210 */
18211
18212 if (keyspace == 0)
18213 {
18214 dictstat_fp = fopen (dictstat, "wb");
18215
18216 if (dictstat_fp)
18217 {
18218 lock_file (dictstat_fp);
18219
18220 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
18221
18222 fclose (dictstat_fp);
18223 }
18224 }
18225
18226 /**
18227 * create autotune threads
18228 */
18229
18230 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
18231
18232 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18233 {
18234 data.devices_status = STATUS_AUTOTUNE;
18235 }
18236
18237 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18238 {
18239 hc_device_param_t *device_param = &devices_param[device_id];
18240
18241 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
18242 }
18243
18244 hc_thread_wait (data.devices_cnt, c_threads);
18245
18246 /*
18247 * Inform user about possible slow speeds
18248 */
18249
18250 uint hardware_power_all = 0;
18251
18252 uint kernel_power_all = 0;
18253
18254 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18255 {
18256 hc_device_param_t *device_param = &devices_param[device_id];
18257
18258 hardware_power_all += device_param->hardware_power;
18259
18260 kernel_power_all += device_param->kernel_power;
18261 }
18262
18263 data.hardware_power_all = hardware_power_all; // hardware_power_all is the same as kernel_power_all but without the influence of kernel_accel on the devices
18264
18265 data.kernel_power_all = kernel_power_all;
18266
18267 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18268 {
18269 if (data.words_base < kernel_power_all)
18270 {
18271 if (quiet == 0)
18272 {
18273 clear_prompt ();
18274
18275 log_info ("ATTENTION!");
18276 log_info (" The wordlist or mask you are using is too small.");
18277 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18278 log_info (" The cracking speed will drop.");
18279 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18280 log_info ("");
18281 }
18282 }
18283 }
18284
18285 /**
18286 * create cracker threads
18287 */
18288
18289 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18290 {
18291 data.devices_status = STATUS_RUNNING;
18292 }
18293
18294 if (initial_restore_done == 0)
18295 {
18296 if (data.restore_disable == 0) cycle_restore ();
18297
18298 initial_restore_done = 1;
18299 }
18300
18301 hc_timer_set (&data.timer_running);
18302
18303 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18304 {
18305 if ((quiet == 0) && (status == 0) && (benchmark == 0))
18306 {
18307 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18308 if (quiet == 0) fflush (stdout);
18309 }
18310 }
18311 else if (wordlist_mode == WL_MODE_STDIN)
18312 {
18313 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18314 if (data.quiet == 0) log_info ("");
18315 }
18316
18317 time_t runtime_start;
18318
18319 time (&runtime_start);
18320
18321 data.runtime_start = runtime_start;
18322
18323 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18324 {
18325 hc_device_param_t *device_param = &devices_param[device_id];
18326
18327 if (wordlist_mode == WL_MODE_STDIN)
18328 {
18329 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18330 }
18331 else
18332 {
18333 hc_thread_create (c_threads[device_id], thread_calc, device_param);
18334 }
18335 }
18336
18337 hc_thread_wait (data.devices_cnt, c_threads);
18338
18339 local_free (c_threads);
18340
18341 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18342 {
18343 data.devices_status = STATUS_EXHAUSTED;
18344 }
18345
18346 logfile_sub_var_uint ("status-after-work", data.devices_status);
18347
18348 data.restore = 0;
18349
18350 if (induction_dictionaries_cnt)
18351 {
18352 unlink (induction_dictionaries[0]);
18353 }
18354
18355 free (induction_dictionaries);
18356
18357 if (attack_mode != ATTACK_MODE_BF)
18358 {
18359 induction_dictionaries = scan_directory (induction_directory);
18360
18361 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18362 }
18363
18364 if (benchmark == 1)
18365 {
18366 status_benchmark ();
18367
18368 if (machine_readable == 0)
18369 {
18370 log_info ("");
18371 }
18372 }
18373 else
18374 {
18375 if (quiet == 0)
18376 {
18377 clear_prompt ();
18378
18379 log_info ("");
18380
18381 status_display ();
18382
18383 log_info ("");
18384 }
18385 else
18386 {
18387 if (status == 1)
18388 {
18389 status_display ();
18390 }
18391 }
18392 }
18393
18394 if (induction_dictionaries_cnt)
18395 {
18396 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18397
18398 // yeah, this next statement is a little hack to make sure that --loopback runs correctly (because with it we guarantee that the loop iterates one more time)
18399
18400 dictpos--;
18401 }
18402
18403 time_t runtime_stop;
18404
18405 time (&runtime_stop);
18406
18407 data.runtime_stop = runtime_stop;
18408
18409 logfile_sub_uint (runtime_start);
18410 logfile_sub_uint (runtime_stop);
18411
18412 logfile_sub_msg ("STOP");
18413
18414 global_free (subid);
18415
18416 // from this point we handle bypass as running
18417
18418 if (data.devices_status == STATUS_BYPASS)
18419 {
18420 data.devices_status = STATUS_RUNNING;
18421 }
18422
18423 // and overwrite benchmark aborts as well
18424
18425 if (data.benchmark == 1)
18426 {
18427 if (data.devices_status == STATUS_ABORTED)
18428 {
18429 data.devices_status = STATUS_RUNNING;
18430 }
18431 }
18432
18433 // finalize task
18434
18435 if (data.devices_status == STATUS_CRACKED) break;
18436 if (data.devices_status == STATUS_ABORTED) break;
18437 if (data.devices_status == STATUS_QUIT) break;
18438 }
18439
18440 if (data.devices_status == STATUS_CRACKED) break;
18441 if (data.devices_status == STATUS_ABORTED) break;
18442 if (data.devices_status == STATUS_QUIT) break;
18443 }
18444
18445 // 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
18446 if (attack_mode == ATTACK_MODE_STRAIGHT)
18447 {
18448 if (data.wordlist_mode == WL_MODE_FILE)
18449 {
18450 if (data.dictfile == NULL)
18451 {
18452 if (dictfiles != NULL)
18453 {
18454 data.dictfile = dictfiles[0];
18455
18456 hc_timer_set (&data.timer_running);
18457 }
18458 }
18459 }
18460 }
18461 // NOTE: combi is okay because it is already set beforehand
18462 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18463 {
18464 if (data.dictfile == NULL)
18465 {
18466 if (dictfiles != NULL)
18467 {
18468 hc_timer_set (&data.timer_running);
18469
18470 data.dictfile = dictfiles[0];
18471 }
18472 }
18473 }
18474 else if (attack_mode == ATTACK_MODE_BF)
18475 {
18476 if (data.mask == NULL)
18477 {
18478 hc_timer_set (&data.timer_running);
18479
18480 data.mask = masks[0];
18481 }
18482 }
18483
18484 // if cracked / aborted remove last induction dictionary
18485
18486 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18487 {
18488 struct stat induct_stat;
18489
18490 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18491 {
18492 unlink (induction_dictionaries[file_pos]);
18493 }
18494 }
18495
18496 // wait for inner threads
18497
18498 data.shutdown_inner = 1;
18499
18500 for (uint thread_idx = 0; thread_idx < inner_threads_cnt; thread_idx++)
18501 {
18502 hc_thread_wait (1, &inner_threads[thread_idx]);
18503 }
18504
18505 local_free (inner_threads);
18506
18507 // we dont need restore file anymore
18508 if (data.restore_disable == 0)
18509 {
18510 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18511 {
18512 unlink (eff_restore_file);
18513 unlink (new_restore_file);
18514 }
18515 else
18516 {
18517 cycle_restore ();
18518 }
18519 }
18520
18521 // finally save left hashes
18522
18523 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18524 {
18525 save_hash ();
18526 }
18527
18528 /**
18529 * Clean up
18530 */
18531
18532 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18533 {
18534 hc_device_param_t *device_param = &data.devices_param[device_id];
18535
18536 if (device_param->skipped) continue;
18537
18538 local_free (device_param->combs_buf);
18539 local_free (device_param->hooks_buf);
18540 local_free (device_param->device_name);
18541 local_free (device_param->device_name_chksum);
18542 local_free (device_param->device_version);
18543 local_free (device_param->driver_version);
18544
18545 if (device_param->pws_buf) myfree (device_param->pws_buf);
18546 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18547 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18548 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18549 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18550 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18551 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18552 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18553 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18554 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18555 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18556 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18557 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18558 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18559 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18560 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18561 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18562 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18563 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18564 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18565 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18566 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18567 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18568 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18569 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18570 if (device_param->d_scryptV0_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV0_buf);
18571 if (device_param->d_scryptV1_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV1_buf);
18572 if (device_param->d_scryptV2_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV2_buf);
18573 if (device_param->d_scryptV3_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV3_buf);
18574 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18575 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18576 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18577
18578 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18579 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18580 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18581 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18582 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18583 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18584 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18585 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18586 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18587 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18588 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18589
18590 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18591 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18592 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18593
18594 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18595 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18596 }
18597
18598 // reset default fan speed
18599
18600 #ifdef HAVE_HWMON
18601 if (gpu_temp_disable == 0)
18602 {
18603 if (gpu_temp_retain != 0)
18604 {
18605 hc_thread_mutex_lock (mux_adl);
18606
18607 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18608 {
18609 hc_device_param_t *device_param = &data.devices_param[device_id];
18610
18611 if (device_param->skipped) continue;
18612
18613 if (data.hm_device[device_id].fan_set_supported == 1)
18614 {
18615 int rc = -1;
18616
18617 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18618 {
18619 rc = hm_set_fanspeed_with_device_id_adl (device_id, 100, 0);
18620 }
18621 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18622 {
18623 #ifdef LINUX
18624 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
18625 #endif
18626
18627 #ifdef WIN
18628 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, 100, 0);
18629 #endif
18630 }
18631
18632 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18633 }
18634 }
18635
18636 hc_thread_mutex_unlock (mux_adl);
18637 }
18638 }
18639
18640 // reset power tuning
18641
18642 if (powertune_enable == 1)
18643 {
18644 hc_thread_mutex_lock (mux_adl);
18645
18646 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18647 {
18648 hc_device_param_t *device_param = &data.devices_param[device_id];
18649
18650 if (device_param->skipped) continue;
18651
18652 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18653 {
18654 if (data.hm_device[device_id].od_version == 6)
18655 {
18656 // check powertune capabilities first, if not available then skip device
18657
18658 int powertune_supported = 0;
18659
18660 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18661 {
18662 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18663
18664 return (-1);
18665 }
18666
18667 if (powertune_supported != 0)
18668 {
18669 // powercontrol settings
18670
18671 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18672 {
18673 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18674
18675 return (-1);
18676 }
18677
18678 // clocks
18679
18680 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18681
18682 performance_state->iNumberOfPerformanceLevels = 2;
18683
18684 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18685 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18686 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18687 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18688
18689 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18690 {
18691 log_info ("ERROR: Failed to restore ADL performance state");
18692
18693 return (-1);
18694 }
18695
18696 local_free (performance_state);
18697 }
18698 }
18699 }
18700
18701 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18702 {
18703 unsigned int limit = nvml_power_limit[device_id];
18704
18705 if (limit > 0)
18706 {
18707 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18708 }
18709 }
18710 }
18711
18712 hc_thread_mutex_unlock (mux_adl);
18713 }
18714
18715 if (gpu_temp_disable == 0)
18716 {
18717 if (data.hm_nvml)
18718 {
18719 hm_NVML_nvmlShutdown (data.hm_nvml);
18720
18721 nvml_close (data.hm_nvml);
18722
18723 data.hm_nvml = NULL;
18724 }
18725
18726 if (data.hm_nvapi)
18727 {
18728 hm_NvAPI_Unload (data.hm_nvapi);
18729
18730 nvapi_close (data.hm_nvapi);
18731
18732 data.hm_nvapi = NULL;
18733 }
18734
18735 if (data.hm_xnvctrl)
18736 {
18737 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18738
18739 xnvctrl_close (data.hm_xnvctrl);
18740
18741 data.hm_xnvctrl = NULL;
18742 }
18743
18744 if (data.hm_adl)
18745 {
18746 hm_ADL_Main_Control_Destroy (data.hm_adl);
18747
18748 adl_close (data.hm_adl);
18749
18750 data.hm_adl = NULL;
18751 }
18752 }
18753 #endif // HAVE_HWMON
18754
18755 // free memory
18756
18757 local_free (masks);
18758
18759 local_free (dictstat_base);
18760
18761 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18762 {
18763 pot_t *pot_ptr = &pot[pot_pos];
18764
18765 hash_t *hash = &pot_ptr->hash;
18766
18767 local_free (hash->digest);
18768
18769 if (isSalted)
18770 {
18771 local_free (hash->salt);
18772 }
18773 }
18774
18775 local_free (pot);
18776
18777 local_free (all_kernel_rules_cnt);
18778 local_free (all_kernel_rules_buf);
18779
18780 local_free (wl_data->buf);
18781 local_free (wl_data);
18782
18783 local_free (bitmap_s1_a);
18784 local_free (bitmap_s1_b);
18785 local_free (bitmap_s1_c);
18786 local_free (bitmap_s1_d);
18787 local_free (bitmap_s2_a);
18788 local_free (bitmap_s2_b);
18789 local_free (bitmap_s2_c);
18790 local_free (bitmap_s2_d);
18791
18792 #ifdef HAVE_HWMON
18793 local_free (od_clock_mem_status);
18794 local_free (od_power_control_status);
18795 local_free (nvml_power_limit);
18796 #endif
18797
18798 global_free (devices_param);
18799
18800 global_free (kernel_rules_buf);
18801
18802 global_free (root_css_buf);
18803 global_free (markov_css_buf);
18804
18805 global_free (digests_buf);
18806 global_free (digests_shown);
18807 global_free (digests_shown_tmp);
18808
18809 global_free (salts_buf);
18810 global_free (salts_shown);
18811
18812 global_free (esalts_buf);
18813
18814 global_free (words_progress_done);
18815 global_free (words_progress_rejected);
18816 global_free (words_progress_restored);
18817
18818 if (pot_fp) fclose (pot_fp);
18819
18820 if (data.devices_status == STATUS_QUIT) break;
18821 }
18822
18823 // wait for outer threads
18824
18825 data.shutdown_outer = 1;
18826
18827 for (uint thread_idx = 0; thread_idx < outer_threads_cnt; thread_idx++)
18828 {
18829 hc_thread_wait (1, &outer_threads[thread_idx]);
18830 }
18831
18832 local_free (outer_threads);
18833
18834 // destroy others mutex
18835
18836 hc_thread_mutex_delete (mux_dispatcher);
18837 hc_thread_mutex_delete (mux_counter);
18838 hc_thread_mutex_delete (mux_display);
18839 hc_thread_mutex_delete (mux_adl);
18840
18841 // free memory
18842
18843 local_free (eff_restore_file);
18844 local_free (new_restore_file);
18845
18846 local_free (rd);
18847
18848 // tuning db
18849
18850 tuning_db_destroy (tuning_db);
18851
18852 // loopback
18853
18854 local_free (loopback_file);
18855
18856 if (loopback == 1) unlink (loopback_file);
18857
18858 // induction directory
18859
18860 if (induction_dir == NULL)
18861 {
18862 if (attack_mode != ATTACK_MODE_BF)
18863 {
18864 if (rmdir (induction_directory) == -1)
18865 {
18866 if (errno == ENOENT)
18867 {
18868 // good, we can ignore
18869 }
18870 else if (errno == ENOTEMPTY)
18871 {
18872 // good, we can ignore
18873 }
18874 else
18875 {
18876 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18877
18878 return (-1);
18879 }
18880 }
18881
18882 local_free (induction_directory);
18883 }
18884 }
18885
18886 // outfile-check directory
18887
18888 if (outfile_check_dir == NULL)
18889 {
18890 if (rmdir (outfile_check_directory) == -1)
18891 {
18892 if (errno == ENOENT)
18893 {
18894 // good, we can ignore
18895 }
18896 else if (errno == ENOTEMPTY)
18897 {
18898 // good, we can ignore
18899 }
18900 else
18901 {
18902 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18903
18904 return (-1);
18905 }
18906 }
18907
18908 local_free (outfile_check_directory);
18909 }
18910
18911 time_t proc_stop;
18912
18913 time (&proc_stop);
18914
18915 logfile_top_uint (proc_start);
18916 logfile_top_uint (proc_stop);
18917
18918 logfile_top_msg ("STOP");
18919
18920 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18921 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18922
18923 if (data.ocl) ocl_close (data.ocl);
18924
18925 if (data.devices_status == STATUS_ABORTED) return 2;
18926 if (data.devices_status == STATUS_QUIT) return 2;
18927 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18928 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18929 if (data.devices_status == STATUS_CRACKED) return 0;
18930
18931 return -1;
18932 }
Hashcat additions to support pwdhash