projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Add commandline support to override cpu spinning damper for nvidia runtime
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define 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 0
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 16
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 | | Show cracked passwords only |",
395 " --left | | Show un-cracked passwords only |",
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 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=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 "If you have no idea what just happened then visit the following pages:",
732 "",
733 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
734 "* https://hashcat.net/wiki/#frequently_asked_questions",
735 "",
736 NULL
737 };
738
739 /**
740 * hashcat specific functions
741 */
742
743 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
744 {
745 int exec_pos = (int) device_param->exec_pos - last_num_entries;
746
747 if (exec_pos < 0) exec_pos += EXEC_CACHE;
748
749 double exec_ms_sum = 0;
750
751 int exec_ms_cnt = 0;
752
753 for (int i = 0; i < last_num_entries; i++)
754 {
755 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
756
757 if (exec_ms)
758 {
759 exec_ms_sum += exec_ms;
760
761 exec_ms_cnt++;
762 }
763 }
764
765 if (exec_ms_cnt == 0) return 0;
766
767 return exec_ms_sum / exec_ms_cnt;
768 }
769
770 void status_display_machine_readable ()
771 {
772 FILE *out = stdout;
773
774 fprintf (out, "STATUS\t%u\t", data.devices_status);
775
776 /**
777 * speed new
778 */
779
780 fprintf (out, "SPEED\t");
781
782 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
783 {
784 hc_device_param_t *device_param = &data.devices_param[device_id];
785
786 if (device_param->skipped) continue;
787
788 u64 speed_cnt = 0;
789 double speed_ms = 0;
790
791 for (int i = 0; i < SPEED_CACHE; i++)
792 {
793 speed_cnt += device_param->speed_cnt[i];
794 speed_ms += device_param->speed_ms[i];
795 }
796
797 speed_cnt /= SPEED_CACHE;
798 speed_ms /= SPEED_CACHE;
799
800 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
801 }
802
803 /**
804 * exec time
805 */
806
807 fprintf (out, "EXEC_RUNTIME\t");
808
809 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
810 {
811 hc_device_param_t *device_param = &data.devices_param[device_id];
812
813 if (device_param->skipped) continue;
814
815 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
816
817 fprintf (out, "%f\t", exec_ms_avg);
818 }
819
820 /**
821 * words_cur
822 */
823
824 u64 words_cur = get_lowest_words_done ();
825
826 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
827
828 /**
829 * counter
830 */
831
832 u64 progress_total = data.words_cnt * data.salts_cnt;
833
834 u64 all_done = 0;
835 u64 all_rejected = 0;
836 u64 all_restored = 0;
837
838 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
839 {
840 all_done += data.words_progress_done[salt_pos];
841 all_rejected += data.words_progress_rejected[salt_pos];
842 all_restored += data.words_progress_restored[salt_pos];
843 }
844
845 u64 progress_cur = all_restored + all_done + all_rejected;
846 u64 progress_end = progress_total;
847
848 u64 progress_skip = 0;
849
850 if (data.skip)
851 {
852 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
853
854 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
855 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
856 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
857 }
858
859 if (data.limit)
860 {
861 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
862
863 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
864 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
865 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
866 }
867
868 u64 progress_cur_relative_skip = progress_cur - progress_skip;
869 u64 progress_end_relative_skip = progress_end - progress_skip;
870
871 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
872
873 /**
874 * cracks
875 */
876
877 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
878 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
879
880 /**
881 * temperature
882 */
883
884 #ifdef HAVE_HWMON
885 if (data.gpu_temp_disable == 0)
886 {
887 fprintf (out, "TEMP\t");
888
889 hc_thread_mutex_lock (mux_adl);
890
891 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
892 {
893 hc_device_param_t *device_param = &data.devices_param[device_id];
894
895 if (device_param->skipped) continue;
896
897 int temp = hm_get_temperature_with_device_id (device_id);
898
899 fprintf (out, "%d\t", temp);
900 }
901
902 hc_thread_mutex_unlock (mux_adl);
903 }
904 #endif // HAVE_HWMON
905
906 /**
907 * flush
908 */
909
910 #ifdef _WIN
911 fputc ('\r', out);
912 fputc ('\n', out);
913 #endif
914
915 #ifdef _POSIX
916 fputc ('\n', out);
917 #endif
918
919 fflush (out);
920 }
921
922 void status_display ()
923 {
924 if (data.devices_status == STATUS_INIT) return;
925 if (data.devices_status == STATUS_STARTING) return;
926 if (data.devices_status == STATUS_BYPASS) return;
927
928 if (data.machine_readable == 1)
929 {
930 status_display_machine_readable ();
931
932 return;
933 }
934
935 char tmp_buf[1000] = { 0 };
936
937 uint tmp_len = 0;
938
939 log_info ("Session.Name...: %s", data.session);
940
941 char *status_type = strstatus (data.devices_status);
942
943 uint hash_mode = data.hash_mode;
944
945 char *hash_type = strhashtype (hash_mode); // not a bug
946
947 log_info ("Status.........: %s", status_type);
948
949 /**
950 * show rules
951 */
952
953 if (data.rp_files_cnt)
954 {
955 uint i;
956
957 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
958 {
959 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
960 }
961
962 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
963
964 log_info ("Rules.Type.....: %s", tmp_buf);
965
966 tmp_len = 0;
967 }
968
969 if (data.rp_gen)
970 {
971 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
972
973 if (data.rp_gen_seed)
974 {
975 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
976 }
977 }
978
979 /**
980 * show input
981 */
982
983 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
984 {
985 if (data.wordlist_mode == WL_MODE_FILE)
986 {
987 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
988 }
989 else if (data.wordlist_mode == WL_MODE_STDIN)
990 {
991 log_info ("Input.Mode.....: Pipe");
992 }
993 }
994 else if (data.attack_mode == ATTACK_MODE_COMBI)
995 {
996 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
997 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
998 }
999 else if (data.attack_mode == ATTACK_MODE_BF)
1000 {
1001 char *mask = data.mask;
1002
1003 if (mask != NULL)
1004 {
1005 uint mask_len = data.css_cnt;
1006
1007 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1008
1009 if (mask_len > 0)
1010 {
1011 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1012 {
1013 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1014 {
1015 mask_len -= data.salts_buf[0].salt_len;
1016 }
1017 }
1018
1019 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1020
1021 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1022 }
1023
1024 if (data.maskcnt > 1)
1025 {
1026 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1027
1028 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1029 }
1030
1031 log_info ("Input.Mode.....: %s", tmp_buf);
1032 }
1033
1034 tmp_len = 0;
1035 }
1036 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1037 {
1038 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1039 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1040 }
1041 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1042 {
1043 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1044 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1045 }
1046
1047 if (data.digests_cnt == 1)
1048 {
1049 if (data.hash_mode == 2500)
1050 {
1051 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1052
1053 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1054 (char *) data.salts_buf[0].salt_buf,
1055 wpa->orig_mac1[0],
1056 wpa->orig_mac1[1],
1057 wpa->orig_mac1[2],
1058 wpa->orig_mac1[3],
1059 wpa->orig_mac1[4],
1060 wpa->orig_mac1[5],
1061 wpa->orig_mac2[0],
1062 wpa->orig_mac2[1],
1063 wpa->orig_mac2[2],
1064 wpa->orig_mac2[3],
1065 wpa->orig_mac2[4],
1066 wpa->orig_mac2[5]);
1067 }
1068 else if (data.hash_mode == 5200)
1069 {
1070 log_info ("Hash.Target....: File (%s)", data.hashfile);
1071 }
1072 else if (data.hash_mode == 9000)
1073 {
1074 log_info ("Hash.Target....: File (%s)", data.hashfile);
1075 }
1076 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1077 {
1078 log_info ("Hash.Target....: File (%s)", data.hashfile);
1079 }
1080 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1081 {
1082 log_info ("Hash.Target....: File (%s)", data.hashfile);
1083 }
1084 else
1085 {
1086 char out_buf[HCBUFSIZ] = { 0 };
1087
1088 ascii_digest (out_buf, 0, 0);
1089
1090 // limit length
1091 if (strlen (out_buf) > 40)
1092 {
1093 out_buf[41] = '.';
1094 out_buf[42] = '.';
1095 out_buf[43] = '.';
1096 out_buf[44] = 0;
1097 }
1098
1099 log_info ("Hash.Target....: %s", out_buf);
1100 }
1101 }
1102 else
1103 {
1104 if (data.hash_mode == 3000)
1105 {
1106 char out_buf1[32] = { 0 };
1107 char out_buf2[32] = { 0 };
1108
1109 ascii_digest (out_buf1, 0, 0);
1110 ascii_digest (out_buf2, 0, 1);
1111
1112 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1113 }
1114 else
1115 {
1116 log_info ("Hash.Target....: File (%s)", data.hashfile);
1117 }
1118 }
1119
1120 log_info ("Hash.Type......: %s", hash_type);
1121
1122 /**
1123 * speed new
1124 */
1125
1126 u64 speed_cnt[DEVICES_MAX] = { 0 };
1127 double speed_ms[DEVICES_MAX] = { 0 };
1128
1129 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1130 {
1131 hc_device_param_t *device_param = &data.devices_param[device_id];
1132
1133 if (device_param->skipped) continue;
1134
1135 speed_cnt[device_id] = 0;
1136 speed_ms[device_id] = 0;
1137
1138 for (int i = 0; i < SPEED_CACHE; i++)
1139 {
1140 speed_cnt[device_id] += device_param->speed_cnt[i];
1141 speed_ms[device_id] += device_param->speed_ms[i];
1142 }
1143
1144 speed_cnt[device_id] /= SPEED_CACHE;
1145 speed_ms[device_id] /= SPEED_CACHE;
1146 }
1147
1148 double hashes_all_ms = 0;
1149
1150 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1151
1152 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1153 {
1154 hc_device_param_t *device_param = &data.devices_param[device_id];
1155
1156 if (device_param->skipped) continue;
1157
1158 hashes_dev_ms[device_id] = 0;
1159
1160 if (speed_ms[device_id])
1161 {
1162 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1163
1164 hashes_all_ms += hashes_dev_ms[device_id];
1165 }
1166 }
1167
1168 /**
1169 * exec time
1170 */
1171
1172 double exec_all_ms[DEVICES_MAX] = { 0 };
1173
1174 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1175 {
1176 hc_device_param_t *device_param = &data.devices_param[device_id];
1177
1178 if (device_param->skipped) continue;
1179
1180 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1181
1182 exec_all_ms[device_id] = exec_ms_avg;
1183 }
1184
1185 /**
1186 * timers
1187 */
1188
1189 double ms_running = 0;
1190
1191 hc_timer_get (data.timer_running, ms_running);
1192
1193 double ms_paused = data.ms_paused;
1194
1195 if (data.devices_status == STATUS_PAUSED)
1196 {
1197 double ms_paused_tmp = 0;
1198
1199 hc_timer_get (data.timer_paused, ms_paused_tmp);
1200
1201 ms_paused += ms_paused_tmp;
1202 }
1203
1204 #ifdef WIN
1205
1206 __time64_t sec_run = ms_running / 1000;
1207
1208 #else
1209
1210 time_t sec_run = ms_running / 1000;
1211
1212 #endif
1213
1214 if (sec_run)
1215 {
1216 char display_run[32] = { 0 };
1217
1218 struct tm tm_run;
1219
1220 struct tm *tmp = NULL;
1221
1222 #ifdef WIN
1223
1224 tmp = _gmtime64 (&sec_run);
1225
1226 #else
1227
1228 tmp = gmtime (&sec_run);
1229
1230 #endif
1231
1232 if (tmp != NULL)
1233 {
1234 memset (&tm_run, 0, sizeof (tm_run));
1235
1236 memcpy (&tm_run, tmp, sizeof (tm_run));
1237
1238 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1239
1240 char *start = ctime (&data.proc_start);
1241
1242 size_t start_len = strlen (start);
1243
1244 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1245 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1246
1247 log_info ("Time.Started...: %s (%s)", start, display_run);
1248 }
1249 }
1250 else
1251 {
1252 log_info ("Time.Started...: 0 secs");
1253 }
1254
1255 /**
1256 * counters
1257 */
1258
1259 u64 progress_total = data.words_cnt * data.salts_cnt;
1260
1261 u64 all_done = 0;
1262 u64 all_rejected = 0;
1263 u64 all_restored = 0;
1264
1265 u64 progress_noneed = 0;
1266
1267 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1268 {
1269 all_done += data.words_progress_done[salt_pos];
1270 all_rejected += data.words_progress_rejected[salt_pos];
1271 all_restored += data.words_progress_restored[salt_pos];
1272
1273 // Important for ETA only
1274
1275 if (data.salts_shown[salt_pos] == 1)
1276 {
1277 const u64 all = data.words_progress_done[salt_pos]
1278 + data.words_progress_rejected[salt_pos]
1279 + data.words_progress_restored[salt_pos];
1280
1281 const u64 left = data.words_cnt - all;
1282
1283 progress_noneed += left;
1284 }
1285 }
1286
1287 u64 progress_cur = all_restored + all_done + all_rejected;
1288 u64 progress_end = progress_total;
1289
1290 u64 progress_skip = 0;
1291
1292 if (data.skip)
1293 {
1294 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1295
1296 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1297 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1298 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1299 }
1300
1301 if (data.limit)
1302 {
1303 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1304
1305 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1306 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1307 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1308 }
1309
1310 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1311 u64 progress_end_relative_skip = progress_end - progress_skip;
1312
1313 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1314 {
1315 if (data.devices_status != STATUS_CRACKED)
1316 {
1317 #ifdef WIN
1318 __time64_t sec_etc = 0;
1319 #else
1320 time_t sec_etc = 0;
1321 #endif
1322
1323 if (hashes_all_ms)
1324 {
1325 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1326
1327 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1328
1329 sec_etc = ms_left / 1000;
1330 }
1331
1332 if (sec_etc == 0)
1333 {
1334 //log_info ("Time.Estimated.: 0 secs");
1335 }
1336 else if ((u64) sec_etc > ETC_MAX)
1337 {
1338 log_info ("Time.Estimated.: > 10 Years");
1339 }
1340 else
1341 {
1342 char display_etc[32] = { 0 };
1343
1344 struct tm tm_etc;
1345
1346 struct tm *tmp = NULL;
1347
1348 #ifdef WIN
1349
1350 tmp = _gmtime64 (&sec_etc);
1351
1352 #else
1353
1354 tmp = gmtime (&sec_etc);
1355
1356 #endif
1357
1358 if (tmp != NULL)
1359 {
1360 memset (&tm_etc, 0, sizeof (tm_etc));
1361
1362 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1363
1364 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1365
1366 time_t now;
1367
1368 time (&now);
1369
1370 now += sec_etc;
1371
1372 char *etc = ctime (&now);
1373
1374 size_t etc_len = strlen (etc);
1375
1376 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1377 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1378
1379 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1380 }
1381 }
1382 }
1383 }
1384
1385 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1386 {
1387 hc_device_param_t *device_param = &data.devices_param[device_id];
1388
1389 if (device_param->skipped) continue;
1390
1391 char display_dev_cur[16] = { 0 };
1392
1393 strncpy (display_dev_cur, "0.00", 4);
1394
1395 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1396
1397 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1398 }
1399
1400 char display_all_cur[16] = { 0 };
1401
1402 strncpy (display_all_cur, "0.00", 4);
1403
1404 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1405
1406 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1407
1408 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1409 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1410
1411 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);
1412
1413 // crack-per-time
1414
1415 if (data.digests_cnt > 100)
1416 {
1417 time_t now = time (NULL);
1418
1419 int cpt_cur_min = 0;
1420 int cpt_cur_hour = 0;
1421 int cpt_cur_day = 0;
1422
1423 for (int i = 0; i < CPT_BUF; i++)
1424 {
1425 const uint cracked = data.cpt_buf[i].cracked;
1426 const time_t timestamp = data.cpt_buf[i].timestamp;
1427
1428 if ((timestamp + 60) > now)
1429 {
1430 cpt_cur_min += cracked;
1431 }
1432
1433 if ((timestamp + 3600) > now)
1434 {
1435 cpt_cur_hour += cracked;
1436 }
1437
1438 if ((timestamp + 86400) > now)
1439 {
1440 cpt_cur_day += cracked;
1441 }
1442 }
1443
1444 double ms_real = ms_running - ms_paused;
1445
1446 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1447 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1448 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1449
1450 if ((data.cpt_start + 86400) < now)
1451 {
1452 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1453 cpt_cur_min,
1454 cpt_cur_hour,
1455 cpt_cur_day,
1456 cpt_avg_min,
1457 cpt_avg_hour,
1458 cpt_avg_day);
1459 }
1460 else if ((data.cpt_start + 3600) < now)
1461 {
1462 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1463 cpt_cur_min,
1464 cpt_cur_hour,
1465 cpt_avg_min,
1466 cpt_avg_hour,
1467 cpt_avg_day);
1468 }
1469 else if ((data.cpt_start + 60) < now)
1470 {
1471 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1472 cpt_cur_min,
1473 cpt_avg_min,
1474 cpt_avg_hour,
1475 cpt_avg_day);
1476 }
1477 else
1478 {
1479 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1480 cpt_avg_min,
1481 cpt_avg_hour,
1482 cpt_avg_day);
1483 }
1484 }
1485
1486 // Restore point
1487
1488 u64 restore_point = get_lowest_words_done ();
1489
1490 u64 restore_total = data.words_base;
1491
1492 float percent_restore = 0;
1493
1494 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1495
1496 if (progress_end_relative_skip)
1497 {
1498 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1499 {
1500 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1501 float percent_rejected = 0.0;
1502
1503 if (progress_cur)
1504 {
1505 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1506 }
1507
1508 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);
1509 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1510
1511 if (data.restore_disable == 0)
1512 {
1513 if (percent_finished != 1)
1514 {
1515 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1516 }
1517 }
1518 }
1519 }
1520 else
1521 {
1522 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1523 {
1524 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1525 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1526
1527 if (data.restore_disable == 0)
1528 {
1529 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1530 }
1531 }
1532 else
1533 {
1534 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1535 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1536
1537 // --restore not allowed if stdin is used -- really? why?
1538
1539 //if (data.restore_disable == 0)
1540 //{
1541 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1542 //}
1543 }
1544 }
1545
1546 #ifdef HAVE_HWMON
1547
1548 if (data.devices_status == STATUS_EXHAUSTED) return;
1549 if (data.devices_status == STATUS_CRACKED) return;
1550 if (data.devices_status == STATUS_ABORTED) return;
1551 if (data.devices_status == STATUS_QUIT) return;
1552
1553 if (data.gpu_temp_disable == 0)
1554 {
1555 hc_thread_mutex_lock (mux_adl);
1556
1557 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1558 {
1559 hc_device_param_t *device_param = &data.devices_param[device_id];
1560
1561 if (device_param->skipped) continue;
1562
1563 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1564 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1565 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1566 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1567 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1568 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1569 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1570
1571 char output_buf[256] = { 0 };
1572
1573 int output_len = 0;
1574
1575 if (num_temperature >= 0)
1576 {
1577 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1578
1579 output_len = strlen (output_buf);
1580 }
1581
1582 if (num_fanspeed >= 0)
1583 {
1584 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1585
1586 output_len = strlen (output_buf);
1587 }
1588
1589 if (num_utilization >= 0)
1590 {
1591 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1592
1593 output_len = strlen (output_buf);
1594 }
1595
1596 if (num_corespeed >= 0)
1597 {
1598 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1599
1600 output_len = strlen (output_buf);
1601 }
1602
1603 if (num_memoryspeed >= 0)
1604 {
1605 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1606
1607 output_len = strlen (output_buf);
1608 }
1609
1610 if (num_buslanes >= 0)
1611 {
1612 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1613
1614 output_len = strlen (output_buf);
1615 }
1616
1617 if (num_throttle == 1)
1618 {
1619 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1620
1621 output_len = strlen (output_buf);
1622 }
1623
1624 if (output_len == 0)
1625 {
1626 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1627
1628 output_len = strlen (output_buf);
1629 }
1630
1631 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1632 }
1633
1634 hc_thread_mutex_unlock (mux_adl);
1635 }
1636
1637 #endif // HAVE_HWMON
1638 }
1639
1640 static void status_benchmark_automate ()
1641 {
1642 u64 speed_cnt[DEVICES_MAX] = { 0 };
1643 double speed_ms[DEVICES_MAX] = { 0 };
1644
1645 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1646 {
1647 hc_device_param_t *device_param = &data.devices_param[device_id];
1648
1649 if (device_param->skipped) continue;
1650
1651 speed_cnt[device_id] = device_param->speed_cnt[0];
1652 speed_ms[device_id] = device_param->speed_ms[0];
1653 }
1654
1655 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1656
1657 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1658 {
1659 hc_device_param_t *device_param = &data.devices_param[device_id];
1660
1661 if (device_param->skipped) continue;
1662
1663 hashes_dev_ms[device_id] = 0;
1664
1665 if (speed_ms[device_id])
1666 {
1667 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1668 }
1669 }
1670
1671 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1672 {
1673 hc_device_param_t *device_param = &data.devices_param[device_id];
1674
1675 if (device_param->skipped) continue;
1676
1677 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1678 }
1679 }
1680
1681 static void status_benchmark ()
1682 {
1683 if (data.devices_status == STATUS_INIT) return;
1684 if (data.devices_status == STATUS_STARTING) return;
1685 if (data.devices_status == STATUS_BYPASS) return;
1686
1687 if (data.machine_readable == 1)
1688 {
1689 status_benchmark_automate ();
1690
1691 return;
1692 }
1693
1694 u64 speed_cnt[DEVICES_MAX] = { 0 };
1695 double speed_ms[DEVICES_MAX] = { 0 };
1696
1697 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1698 {
1699 hc_device_param_t *device_param = &data.devices_param[device_id];
1700
1701 if (device_param->skipped) continue;
1702
1703 speed_cnt[device_id] = device_param->speed_cnt[0];
1704 speed_ms[device_id] = device_param->speed_ms[0];
1705 }
1706
1707 double hashes_all_ms = 0;
1708
1709 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1710
1711 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1712 {
1713 hc_device_param_t *device_param = &data.devices_param[device_id];
1714
1715 if (device_param->skipped) continue;
1716
1717 hashes_dev_ms[device_id] = 0;
1718
1719 if (speed_ms[device_id])
1720 {
1721 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1722
1723 hashes_all_ms += hashes_dev_ms[device_id];
1724 }
1725 }
1726
1727 /**
1728 * exec time
1729 */
1730
1731 double exec_all_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 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1740
1741 exec_all_ms[device_id] = exec_ms_avg;
1742 }
1743
1744 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1745 {
1746 hc_device_param_t *device_param = &data.devices_param[device_id];
1747
1748 if (device_param->skipped) continue;
1749
1750 char display_dev_cur[16] = { 0 };
1751
1752 strncpy (display_dev_cur, "0.00", 4);
1753
1754 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1755
1756 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1757 }
1758
1759 char display_all_cur[16] = { 0 };
1760
1761 strncpy (display_all_cur, "0.00", 4);
1762
1763 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1764
1765 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1766 }
1767
1768 /**
1769 * hashcat -only- functions
1770 */
1771
1772 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1773 {
1774 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1775 {
1776 if (attack_kern == ATTACK_KERN_STRAIGHT)
1777 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1778 else if (attack_kern == ATTACK_KERN_COMBI)
1779 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1780 else if (attack_kern == ATTACK_KERN_BF)
1781 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1782 }
1783 else
1784 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1785 }
1786
1787 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)
1788 {
1789 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1790 {
1791 if (attack_kern == ATTACK_KERN_STRAIGHT)
1792 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1793 else if (attack_kern == ATTACK_KERN_COMBI)
1794 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1795 else if (attack_kern == ATTACK_KERN_BF)
1796 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1797 }
1798 else
1799 {
1800 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1801 }
1802 }
1803
1804 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1805 {
1806 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1807 {
1808 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1809 }
1810 else
1811 {
1812 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1813 }
1814 }
1815
1816 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)
1817 {
1818 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1819 {
1820 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1821 }
1822 else
1823 {
1824 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1825 }
1826 }
1827
1828 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1829 {
1830 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1831 }
1832
1833 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1834 {
1835 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1836 }
1837
1838 static uint convert_from_hex (char *line_buf, const uint line_len)
1839 {
1840 if (line_len & 1) return (line_len); // not in hex
1841
1842 if (data.hex_wordlist == 1)
1843 {
1844 uint i;
1845 uint j;
1846
1847 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1848 {
1849 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1850 }
1851
1852 memset (line_buf + i, 0, line_len - i);
1853
1854 return (i);
1855 }
1856 else if (line_len >= 6) // $HEX[] = 6
1857 {
1858 if (line_buf[0] != '$') return (line_len);
1859 if (line_buf[1] != 'H') return (line_len);
1860 if (line_buf[2] != 'E') return (line_len);
1861 if (line_buf[3] != 'X') return (line_len);
1862 if (line_buf[4] != '[') return (line_len);
1863 if (line_buf[line_len - 1] != ']') return (line_len);
1864
1865 uint i;
1866 uint j;
1867
1868 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1869 {
1870 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1871 }
1872
1873 memset (line_buf + i, 0, line_len - i);
1874
1875 return (i);
1876 }
1877
1878 return (line_len);
1879 }
1880
1881 static void clear_prompt ()
1882 {
1883 fputc ('\r', stdout);
1884
1885 for (size_t i = 0; i < strlen (PROMPT); i++)
1886 {
1887 fputc (' ', stdout);
1888 }
1889
1890 fputc ('\r', stdout);
1891
1892 fflush (stdout);
1893 }
1894
1895 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1896 {
1897 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);
1898 }
1899
1900 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1901 {
1902 char *outfile = data.outfile;
1903 uint quiet = data.quiet;
1904 FILE *pot_fp = data.pot_fp;
1905 uint loopback = data.loopback;
1906 uint debug_mode = data.debug_mode;
1907 char *debug_file = data.debug_file;
1908
1909 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1910 int debug_rule_len = 0; // -1 error
1911 uint debug_plain_len = 0;
1912
1913 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1914
1915 // hash
1916
1917 char out_buf[HCBUFSIZ] = { 0 };
1918
1919 const u32 salt_pos = plain->salt_pos;
1920 const u32 digest_pos = plain->digest_pos; // relative
1921 const u32 gidvid = plain->gidvid;
1922 const u32 il_pos = plain->il_pos;
1923
1924 ascii_digest (out_buf, salt_pos, digest_pos);
1925
1926 // plain
1927
1928 u64 crackpos = device_param->words_off;
1929
1930 uint plain_buf[16] = { 0 };
1931
1932 u8 *plain_ptr = (u8 *) plain_buf;
1933
1934 unsigned int plain_len = 0;
1935
1936 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1937 {
1938 pw_t pw;
1939
1940 gidd_to_pw_t (device_param, gidvid, &pw);
1941
1942 for (int i = 0; i < 16; i++)
1943 {
1944 plain_buf[i] = pw.i[i];
1945 }
1946
1947 plain_len = pw.pw_len;
1948
1949 const uint off = device_param->innerloop_pos + il_pos;
1950
1951 if (debug_mode > 0)
1952 {
1953 debug_rule_len = 0;
1954
1955 // save rule
1956 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1957 {
1958 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1959
1960 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1961 }
1962
1963 // save plain
1964 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1965 {
1966 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1967
1968 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1969
1970 debug_plain_len = plain_len;
1971 }
1972 }
1973
1974 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1975
1976 crackpos += gidvid;
1977 crackpos *= data.kernel_rules_cnt;
1978 crackpos += device_param->innerloop_pos + il_pos;
1979
1980 if (plain_len > data.pw_max) plain_len = data.pw_max;
1981 }
1982 else if (data.attack_mode == ATTACK_MODE_COMBI)
1983 {
1984 pw_t pw;
1985
1986 gidd_to_pw_t (device_param, gidvid, &pw);
1987
1988 for (int i = 0; i < 16; i++)
1989 {
1990 plain_buf[i] = pw.i[i];
1991 }
1992
1993 plain_len = pw.pw_len;
1994
1995 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1996 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1997
1998 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1999 {
2000 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2001 }
2002 else
2003 {
2004 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2005
2006 memcpy (plain_ptr, comb_buf, comb_len);
2007 }
2008
2009 plain_len += comb_len;
2010
2011 crackpos += gidvid;
2012 crackpos *= data.combs_cnt;
2013 crackpos += device_param->innerloop_pos + il_pos;
2014
2015 if (data.pw_max != PW_DICTMAX1)
2016 {
2017 if (plain_len > data.pw_max) plain_len = data.pw_max;
2018 }
2019 }
2020 else if (data.attack_mode == ATTACK_MODE_BF)
2021 {
2022 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2023 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2024
2025 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2026 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2027
2028 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2029 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2030
2031 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2032 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2033
2034 plain_len = data.css_cnt;
2035
2036 crackpos += gidvid;
2037 crackpos *= data.bfs_cnt;
2038 crackpos += device_param->innerloop_pos + il_pos;
2039 }
2040 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2041 {
2042 pw_t pw;
2043
2044 gidd_to_pw_t (device_param, gidvid, &pw);
2045
2046 for (int i = 0; i < 16; i++)
2047 {
2048 plain_buf[i] = pw.i[i];
2049 }
2050
2051 plain_len = pw.pw_len;
2052
2053 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2054
2055 uint start = 0;
2056 uint stop = device_param->kernel_params_mp_buf32[4];
2057
2058 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2059
2060 plain_len += start + stop;
2061
2062 crackpos += gidvid;
2063 crackpos *= data.combs_cnt;
2064 crackpos += device_param->innerloop_pos + il_pos;
2065
2066 if (data.pw_max != PW_DICTMAX1)
2067 {
2068 if (plain_len > data.pw_max) plain_len = data.pw_max;
2069 }
2070 }
2071 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2072 {
2073 pw_t pw;
2074
2075 gidd_to_pw_t (device_param, gidvid, &pw);
2076
2077 for (int i = 0; i < 16; i++)
2078 {
2079 plain_buf[i] = pw.i[i];
2080 }
2081
2082 plain_len = pw.pw_len;
2083
2084 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2085
2086 uint start = 0;
2087 uint stop = device_param->kernel_params_mp_buf32[4];
2088
2089 memmove (plain_ptr + stop, plain_ptr, plain_len);
2090
2091 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2092
2093 plain_len += start + stop;
2094
2095 crackpos += gidvid;
2096 crackpos *= data.combs_cnt;
2097 crackpos += device_param->innerloop_pos + il_pos;
2098
2099 if (data.pw_max != PW_DICTMAX1)
2100 {
2101 if (plain_len > data.pw_max) plain_len = data.pw_max;
2102 }
2103 }
2104
2105 if (data.attack_mode == ATTACK_MODE_BF)
2106 {
2107 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2108 {
2109 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2110 {
2111 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2112 {
2113 plain_len = plain_len - data.salts_buf[0].salt_len;
2114 }
2115 }
2116
2117 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2118 {
2119 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2120 {
2121 plain_ptr[j] = plain_ptr[i];
2122 }
2123
2124 plain_len = plain_len / 2;
2125 }
2126 }
2127 }
2128
2129 // if enabled, update also the potfile
2130
2131 if (pot_fp)
2132 {
2133 lock_file (pot_fp);
2134
2135 fprintf (pot_fp, "%s:", out_buf);
2136
2137 format_plain (pot_fp, plain_ptr, plain_len, 1);
2138
2139 fputc ('\n', pot_fp);
2140
2141 fflush (pot_fp);
2142
2143 unlock_file (pot_fp);
2144 }
2145
2146 // outfile
2147
2148 FILE *out_fp = NULL;
2149
2150 if (outfile != NULL)
2151 {
2152 if ((out_fp = fopen (outfile, "ab")) == NULL)
2153 {
2154 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2155
2156 out_fp = stdout;
2157 }
2158
2159 lock_file (out_fp);
2160 }
2161 else
2162 {
2163 out_fp = stdout;
2164
2165 if (quiet == 0) clear_prompt ();
2166 }
2167
2168 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2169
2170 if (outfile != NULL)
2171 {
2172 if (out_fp != stdout)
2173 {
2174 fclose (out_fp);
2175 }
2176 }
2177 else
2178 {
2179 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2180 {
2181 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2182 {
2183 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2184 if (quiet == 0) fflush (stdout);
2185 }
2186 }
2187 }
2188
2189 // loopback
2190
2191 if (loopback)
2192 {
2193 char *loopback_file = data.loopback_file;
2194
2195 FILE *fb_fp = NULL;
2196
2197 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2198 {
2199 lock_file (fb_fp);
2200
2201 format_plain (fb_fp, plain_ptr, plain_len, 1);
2202
2203 fputc ('\n', fb_fp);
2204
2205 fclose (fb_fp);
2206 }
2207 }
2208
2209 // (rule) debug mode
2210
2211 // the next check implies that:
2212 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2213 // - debug_mode > 0
2214
2215 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2216 {
2217 if (debug_rule_len < 0) debug_rule_len = 0;
2218
2219 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2220
2221 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2222
2223 if ((quiet == 0) && (debug_file == NULL))
2224 {
2225 fprintf (stdout, "%s", PROMPT);
2226
2227 fflush (stdout);
2228 }
2229 }
2230 }
2231
2232 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2233 {
2234 salt_t *salt_buf = &data.salts_buf[salt_pos];
2235
2236 u32 num_cracked;
2237
2238 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2239
2240 if (num_cracked)
2241 {
2242 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2243
2244 log_info_nn ("");
2245
2246 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2247
2248 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);
2249
2250 uint cpt_cracked = 0;
2251
2252 for (uint i = 0; i < num_cracked; i++)
2253 {
2254 const uint hash_pos = cracked[i].hash_pos;
2255
2256 if (data.digests_shown[hash_pos] == 1) continue;
2257
2258 hc_thread_mutex_lock (mux_display);
2259
2260 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2261 {
2262 data.digests_shown[hash_pos] = 1;
2263
2264 data.digests_done++;
2265
2266 cpt_cracked++;
2267
2268 salt_buf->digests_done++;
2269
2270 if (salt_buf->digests_done == salt_buf->digests_cnt)
2271 {
2272 data.salts_shown[salt_pos] = 1;
2273
2274 data.salts_done++;
2275 }
2276 }
2277
2278 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2279
2280 hc_thread_mutex_unlock (mux_display);
2281
2282 check_hash (device_param, &cracked[i]);
2283 }
2284
2285 myfree (cracked);
2286
2287 if (cpt_cracked > 0)
2288 {
2289 hc_thread_mutex_lock (mux_display);
2290
2291 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2292 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2293
2294 data.cpt_pos++;
2295
2296 data.cpt_total += cpt_cracked;
2297
2298 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2299
2300 hc_thread_mutex_unlock (mux_display);
2301 }
2302
2303 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2304 {
2305 // we need to reset cracked state on the device
2306 // otherwise host thinks again and again the hash was cracked
2307 // and returns invalid password each time
2308
2309 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2310
2311 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);
2312 }
2313
2314 num_cracked = 0;
2315
2316 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2317 }
2318 }
2319
2320 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2321 {
2322 char out_buf[HCBUFSIZ] = { 0 };
2323
2324 uint plain_buf[16] = { 0 };
2325
2326 u8 *plain_ptr = (u8 *) plain_buf;
2327
2328 uint plain_len = 0;
2329
2330 const uint il_cnt = device_param->kernel_params_buf32[27]; // ugly, i know
2331
2332 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2333 {
2334 pw_t pw;
2335
2336 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2337 {
2338 gidd_to_pw_t (device_param, gidvid, &pw);
2339
2340 const uint pos = device_param->innerloop_pos;
2341
2342 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2343 {
2344 for (int i = 0; i < 8; i++)
2345 {
2346 plain_buf[i] = pw.i[i];
2347 }
2348
2349 plain_len = pw.pw_len;
2350
2351 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2352
2353 if (plain_len > data.pw_max) plain_len = data.pw_max;
2354
2355 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2356 }
2357 }
2358 }
2359 else if (data.attack_mode == ATTACK_MODE_COMBI)
2360 {
2361 pw_t pw;
2362
2363 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2364 {
2365 gidd_to_pw_t (device_param, gidvid, &pw);
2366
2367 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2368 {
2369 for (int i = 0; i < 8; i++)
2370 {
2371 plain_buf[i] = pw.i[i];
2372 }
2373
2374 plain_len = pw.pw_len;
2375
2376 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2377 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2378
2379 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2380 {
2381 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2382 }
2383 else
2384 {
2385 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2386
2387 memcpy (plain_ptr, comb_buf, comb_len);
2388 }
2389
2390 plain_len += comb_len;
2391
2392 if (data.pw_max != PW_DICTMAX1)
2393 {
2394 if (plain_len > data.pw_max) plain_len = data.pw_max;
2395 }
2396
2397 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2398 }
2399 }
2400 }
2401 else if (data.attack_mode == ATTACK_MODE_BF)
2402 {
2403 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2404 {
2405 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2406 {
2407 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2408 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2409
2410 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2411 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2412
2413 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2414 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2415
2416 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2417 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2418
2419 plain_len = data.css_cnt;
2420
2421 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2422 }
2423 }
2424 }
2425 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2426 {
2427 pw_t pw;
2428
2429 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2430 {
2431 gidd_to_pw_t (device_param, gidvid, &pw);
2432
2433 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2434 {
2435 for (int i = 0; i < 8; i++)
2436 {
2437 plain_buf[i] = pw.i[i];
2438 }
2439
2440 plain_len = pw.pw_len;
2441
2442 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2443
2444 uint start = 0;
2445 uint stop = device_param->kernel_params_mp_buf32[4];
2446
2447 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2448
2449 plain_len += start + stop;
2450
2451 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2452 }
2453 }
2454 }
2455 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2456 {
2457 pw_t pw;
2458
2459 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2460 {
2461 gidd_to_pw_t (device_param, gidvid, &pw);
2462
2463 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2464 {
2465 for (int i = 0; i < 8; i++)
2466 {
2467 plain_buf[i] = pw.i[i];
2468 }
2469
2470 plain_len = pw.pw_len;
2471
2472 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2473
2474 uint start = 0;
2475 uint stop = device_param->kernel_params_mp_buf32[4];
2476
2477 memmove (plain_ptr + stop, plain_ptr, plain_len);
2478
2479 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2480
2481 plain_len += start + stop;
2482
2483 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2484 }
2485 }
2486 }
2487 }
2488
2489 static void save_hash ()
2490 {
2491 char *hashfile = data.hashfile;
2492
2493 char new_hashfile[256] = { 0 };
2494 char old_hashfile[256] = { 0 };
2495
2496 snprintf (new_hashfile, 255, "%s.new", hashfile);
2497 snprintf (old_hashfile, 255, "%s.old", hashfile);
2498
2499 unlink (new_hashfile);
2500
2501 char separator = data.separator;
2502
2503 FILE *fp = fopen (new_hashfile, "wb");
2504
2505 if (fp == NULL)
2506 {
2507 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2508
2509 exit (-1);
2510 }
2511
2512 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2513 {
2514 if (data.salts_shown[salt_pos] == 1) continue;
2515
2516 salt_t *salt_buf = &data.salts_buf[salt_pos];
2517
2518 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2519 {
2520 uint idx = salt_buf->digests_offset + digest_pos;
2521
2522 if (data.digests_shown[idx] == 1) continue;
2523
2524 if (data.hash_mode != 2500)
2525 {
2526 if (data.username == 1)
2527 {
2528 user_t *user = data.hash_info[idx]->user;
2529
2530 uint i;
2531
2532 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2533
2534 fputc (separator, fp);
2535 }
2536
2537 char out_buf[HCBUFSIZ]; // scratch buffer
2538
2539 out_buf[0] = 0;
2540
2541 ascii_digest (out_buf, salt_pos, digest_pos);
2542
2543 fputs (out_buf, fp);
2544
2545 fputc ('\n', fp);
2546 }
2547 else
2548 {
2549 hccap_t hccap;
2550
2551 to_hccap_t (&hccap, salt_pos, digest_pos);
2552
2553 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2554 }
2555 }
2556 }
2557
2558 fflush (fp);
2559
2560 fclose (fp);
2561
2562 unlink (old_hashfile);
2563
2564 if (rename (hashfile, old_hashfile) != 0)
2565 {
2566 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2567
2568 exit (-1);
2569 }
2570
2571 unlink (hashfile);
2572
2573 if (rename (new_hashfile, hashfile) != 0)
2574 {
2575 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2576
2577 exit (-1);
2578 }
2579
2580 unlink (old_hashfile);
2581 }
2582
2583 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2584 {
2585 uint num_elements = num;
2586
2587 device_param->kernel_params_buf32[30] = data.combs_mode;
2588 device_param->kernel_params_buf32[31] = num;
2589
2590 uint kernel_threads = device_param->kernel_threads;
2591
2592 while (num_elements % kernel_threads) num_elements++;
2593
2594 cl_kernel kernel = NULL;
2595
2596 switch (kern_run)
2597 {
2598 case KERN_RUN_1: kernel = device_param->kernel1; break;
2599 case KERN_RUN_12: kernel = device_param->kernel12; break;
2600 case KERN_RUN_2: kernel = device_param->kernel2; break;
2601 case KERN_RUN_23: kernel = device_param->kernel23; break;
2602 case KERN_RUN_3: kernel = device_param->kernel3; break;
2603 }
2604
2605 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2606 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2607 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2608 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2609 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2610 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2611 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2612 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2613 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2614 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2615 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2616
2617 cl_event event;
2618
2619 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2620 {
2621 const size_t global_work_size[3] = { num_elements, 32, 1 };
2622 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2623
2624 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2625 }
2626 else
2627 {
2628 if (kern_run == KERN_RUN_2)
2629 {
2630 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2631 {
2632 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2633 }
2634 }
2635
2636 while (num_elements % kernel_threads) num_elements++;
2637
2638 const size_t global_work_size[3] = { num_elements, 1, 1 };
2639 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2640
2641 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2642 }
2643
2644 hc_clFlush (data.ocl, device_param->command_queue);
2645
2646 if (device_param->nvidia_spin_damp)
2647 {
2648 if (data.devices_status == STATUS_RUNNING)
2649 {
2650 if (iteration < EXPECTED_ITERATIONS)
2651 {
2652 switch (kern_run)
2653 {
2654 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2655 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2656 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2657 }
2658 }
2659 }
2660 }
2661
2662 hc_clWaitForEvents (data.ocl, 1, &event);
2663
2664 cl_ulong time_start;
2665 cl_ulong time_end;
2666
2667 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2668 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2669
2670 const double exec_us = (double) (time_end - time_start) / 1000;
2671
2672 if (data.devices_status == STATUS_RUNNING)
2673 {
2674 if (iteration < EXPECTED_ITERATIONS)
2675 {
2676 switch (kern_run)
2677 {
2678 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2679 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2680 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2681 }
2682 }
2683 }
2684
2685 if (event_update)
2686 {
2687 uint exec_pos = device_param->exec_pos;
2688
2689 device_param->exec_ms[exec_pos] = exec_us / 1000;
2690
2691 exec_pos++;
2692
2693 if (exec_pos == EXEC_CACHE)
2694 {
2695 exec_pos = 0;
2696 }
2697
2698 device_param->exec_pos = exec_pos;
2699 }
2700
2701 hc_clReleaseEvent (data.ocl, event);
2702
2703 hc_clFinish (data.ocl, device_param->command_queue);
2704 }
2705
2706 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2707 {
2708 uint num_elements = num;
2709
2710 switch (kern_run)
2711 {
2712 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2713 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2714 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2715 }
2716
2717 // causes problems with special threads like in bcrypt
2718 // const uint kernel_threads = device_param->kernel_threads;
2719
2720 uint kernel_threads = device_param->kernel_threads;
2721
2722 while (num_elements % kernel_threads) num_elements++;
2723
2724 cl_kernel kernel = NULL;
2725
2726 switch (kern_run)
2727 {
2728 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2729 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2730 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2731 }
2732
2733 switch (kern_run)
2734 {
2735 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2736 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2737 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2738 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2739 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2740 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2741 break;
2742 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2743 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2744 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2745 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2746 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2747 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2748 break;
2749 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2750 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2751 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2752 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2753 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2754 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2755 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2756 break;
2757 }
2758
2759 const size_t global_work_size[3] = { num_elements, 1, 1 };
2760 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2761
2762 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2763
2764 hc_clFlush (data.ocl, device_param->command_queue);
2765
2766 hc_clFinish (data.ocl, device_param->command_queue);
2767 }
2768
2769 static void run_kernel_tm (hc_device_param_t *device_param)
2770 {
2771 const uint num_elements = 1024; // fixed
2772
2773 uint kernel_threads = 32;
2774
2775 cl_kernel kernel = device_param->kernel_tm;
2776
2777 const size_t global_work_size[3] = { num_elements, 1, 1 };
2778 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2779
2780 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2781
2782 hc_clFlush (data.ocl, device_param->command_queue);
2783
2784 hc_clFinish (data.ocl, device_param->command_queue);
2785 }
2786
2787 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2788 {
2789 uint num_elements = num;
2790
2791 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2792 device_param->kernel_params_amp_buf32[6] = num_elements;
2793
2794 // causes problems with special threads like in bcrypt
2795 // const uint kernel_threads = device_param->kernel_threads;
2796
2797 uint kernel_threads = device_param->kernel_threads;
2798
2799 while (num_elements % kernel_threads) num_elements++;
2800
2801 cl_kernel kernel = device_param->kernel_amp;
2802
2803 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2804 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2805
2806 const size_t global_work_size[3] = { num_elements, 1, 1 };
2807 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2808
2809 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2810
2811 hc_clFlush (data.ocl, device_param->command_queue);
2812
2813 hc_clFinish (data.ocl, device_param->command_queue);
2814 }
2815
2816 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2817 {
2818 const u32 num16d = num / 16;
2819 const u32 num16m = num % 16;
2820
2821 if (num16d)
2822 {
2823 device_param->kernel_params_memset_buf32[1] = value;
2824 device_param->kernel_params_memset_buf32[2] = num16d;
2825
2826 uint kernel_threads = device_param->kernel_threads;
2827
2828 uint num_elements = num16d;
2829
2830 while (num_elements % kernel_threads) num_elements++;
2831
2832 cl_kernel kernel = device_param->kernel_memset;
2833
2834 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2835 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2836 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2837
2838 const size_t global_work_size[3] = { num_elements, 1, 1 };
2839 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2840
2841 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2842
2843 hc_clFlush (data.ocl, device_param->command_queue);
2844
2845 hc_clFinish (data.ocl, device_param->command_queue);
2846 }
2847
2848 if (num16m)
2849 {
2850 u32 tmp[4];
2851
2852 tmp[0] = value;
2853 tmp[1] = value;
2854 tmp[2] = value;
2855 tmp[3] = value;
2856
2857 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2858 }
2859 }
2860
2861 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2862 {
2863 run_kernel_memset (device_param, buf, 0, size);
2864
2865 /*
2866 int rc = -1;
2867
2868 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2869 {
2870 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2871
2872 const cl_uchar zero = 0;
2873
2874 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2875 }
2876
2877 if (rc != 0)
2878 {
2879 // NOTE: clEnqueueFillBuffer () always fails with -59
2880 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2881 // How's that possible, OpenCL 1.2 support is advertised??
2882 // We need to workaround...
2883
2884 #define FILLSZ 0x100000
2885
2886 char *tmp = (char *) mymalloc (FILLSZ);
2887
2888 for (size_t i = 0; i < size; i += FILLSZ)
2889 {
2890 const size_t left = size - i;
2891
2892 const size_t fillsz = MIN (FILLSZ, left);
2893
2894 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2895 }
2896
2897 myfree (tmp);
2898 }
2899 */
2900 }
2901
2902 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)
2903 {
2904 if (data.hash_mode == 2000)
2905 {
2906 process_stdout (device_param, pws_cnt);
2907
2908 return;
2909 }
2910
2911 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2912 {
2913 if (attack_mode == ATTACK_MODE_BF)
2914 {
2915 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2916 {
2917 const uint size_tm = 32 * sizeof (bs_word_t);
2918
2919 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2920
2921 run_kernel_tm (device_param);
2922
2923 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);
2924 }
2925 }
2926
2927 if (highest_pw_len < 16)
2928 {
2929 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
2930 }
2931 else if (highest_pw_len < 32)
2932 {
2933 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
2934 }
2935 else
2936 {
2937 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
2938 }
2939 }
2940 else
2941 {
2942 run_kernel_amp (device_param, pws_cnt);
2943
2944 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
2945
2946 if (opts_type & OPTS_TYPE_HOOK12)
2947 {
2948 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
2949
2950 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);
2951
2952 // do something with data
2953
2954 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);
2955 }
2956
2957 uint iter = salt_buf->salt_iter;
2958
2959 uint loop_step = device_param->kernel_loops;
2960
2961 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
2962 {
2963 uint loop_left = iter - loop_pos;
2964
2965 loop_left = MIN (loop_left, loop_step);
2966
2967 device_param->kernel_params_buf32[25] = loop_pos;
2968 device_param->kernel_params_buf32[26] = loop_left;
2969
2970 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
2971
2972 if (data.devices_status == STATUS_CRACKED) break;
2973 if (data.devices_status == STATUS_ABORTED) break;
2974 if (data.devices_status == STATUS_QUIT) break;
2975
2976 /**
2977 * speed
2978 */
2979
2980 const float iter_part = (float) (loop_pos + loop_left) / iter;
2981
2982 const u64 perf_sum_all = pws_cnt * iter_part;
2983
2984 double speed_ms;
2985
2986 hc_timer_get (device_param->timer_speed, speed_ms);
2987
2988 const u32 speed_pos = device_param->speed_pos;
2989
2990 device_param->speed_cnt[speed_pos] = perf_sum_all;
2991
2992 device_param->speed_ms[speed_pos] = speed_ms;
2993
2994 if (data.benchmark == 1)
2995 {
2996 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2997 }
2998 }
2999
3000 if (opts_type & OPTS_TYPE_HOOK23)
3001 {
3002 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3003
3004 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);
3005
3006 // do something with data
3007
3008 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);
3009 }
3010
3011 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3012 }
3013 }
3014
3015 static int run_rule_engine (const int rule_len, const char *rule_buf)
3016 {
3017 if (rule_len == 0)
3018 {
3019 return 0;
3020 }
3021 else if (rule_len == 1)
3022 {
3023 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3024 }
3025
3026 return 1;
3027 }
3028
3029 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3030 {
3031 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3032 {
3033 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);
3034 }
3035 else if (data.attack_kern == ATTACK_KERN_COMBI)
3036 {
3037 if (data.attack_mode == ATTACK_MODE_COMBI)
3038 {
3039 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3040 {
3041 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3042 {
3043 for (u32 i = 0; i < pws_cnt; i++)
3044 {
3045 const u32 pw_len = device_param->pws_buf[i].pw_len;
3046
3047 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3048
3049 ptr[pw_len] = 0x01;
3050 }
3051 }
3052 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3053 {
3054 for (u32 i = 0; i < pws_cnt; i++)
3055 {
3056 const u32 pw_len = device_param->pws_buf[i].pw_len;
3057
3058 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3059
3060 ptr[pw_len] = 0x80;
3061 }
3062 }
3063 }
3064 }
3065 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3066 {
3067 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3068 {
3069 for (u32 i = 0; i < pws_cnt; i++)
3070 {
3071 const u32 pw_len = device_param->pws_buf[i].pw_len;
3072
3073 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3074
3075 ptr[pw_len] = 0x01;
3076 }
3077 }
3078 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3079 {
3080 for (u32 i = 0; i < pws_cnt; i++)
3081 {
3082 const u32 pw_len = device_param->pws_buf[i].pw_len;
3083
3084 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3085
3086 ptr[pw_len] = 0x80;
3087 }
3088 }
3089 }
3090
3091 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);
3092 }
3093 else if (data.attack_kern == ATTACK_KERN_BF)
3094 {
3095 const u64 off = device_param->words_off;
3096
3097 device_param->kernel_params_mp_l_buf64[3] = off;
3098
3099 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3100 }
3101 }
3102
3103 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3104 {
3105 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3106
3107 device_param->kernel_params_buf32[25] = 0;
3108 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
3109 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3110
3111 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3112 {
3113 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3114 }
3115 else
3116 {
3117 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3118 }
3119
3120 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3121
3122 return exec_ms_prev;
3123 }
3124
3125 static void autotune (hc_device_param_t *device_param)
3126 {
3127 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3128
3129 const u32 kernel_accel_min = device_param->kernel_accel_min;
3130 const u32 kernel_accel_max = device_param->kernel_accel_max;
3131
3132 const u32 kernel_loops_min = device_param->kernel_loops_min;
3133 const u32 kernel_loops_max = device_param->kernel_loops_max;
3134
3135 u32 kernel_accel = kernel_accel_min;
3136 u32 kernel_loops = kernel_loops_min;
3137
3138 // in this case the user specified a fixed -u and -n on the commandline
3139 // no way to tune anything
3140 // but we need to run a few caching rounds
3141
3142 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3143 {
3144 if (data.hash_mode != 2000)
3145 {
3146 try_run (device_param, kernel_accel, kernel_loops);
3147 try_run (device_param, kernel_accel, kernel_loops);
3148 try_run (device_param, kernel_accel, kernel_loops);
3149 try_run (device_param, kernel_accel, kernel_loops);
3150 }
3151
3152 device_param->kernel_accel = kernel_accel;
3153 device_param->kernel_loops = kernel_loops;
3154
3155 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3156
3157 device_param->kernel_power = kernel_power;
3158
3159 return;
3160 }
3161
3162 // from here it's clear we are allowed to autotune
3163 // so let's init some fake words
3164
3165 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3166
3167 if (data.attack_kern == ATTACK_KERN_BF)
3168 {
3169 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3170 }
3171 else
3172 {
3173 for (u32 i = 0; i < kernel_power_max; i++)
3174 {
3175 device_param->pws_buf[i].i[0] = i;
3176 device_param->pws_buf[i].i[1] = 0x01234567;
3177 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3178 }
3179
3180 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);
3181 }
3182
3183 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3184 {
3185 if (data.kernel_rules_cnt > 1)
3186 {
3187 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);
3188 }
3189 }
3190 else
3191 {
3192 run_kernel_amp (device_param, kernel_power_max);
3193 }
3194
3195 #define VERIFIER_CNT 1
3196
3197 // first find out highest kernel-loops that stays below target_ms
3198
3199 if (kernel_loops_min < kernel_loops_max)
3200 {
3201 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3202 {
3203 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3204
3205 for (int i = 0; i < VERIFIER_CNT; i++)
3206 {
3207 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3208
3209 exec_ms = MIN (exec_ms, exec_ms_v);
3210 }
3211
3212 if (exec_ms < target_ms) break;
3213 }
3214 }
3215
3216 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3217
3218 #define STEPS_CNT 10
3219
3220 if (kernel_accel_min < kernel_accel_max)
3221 {
3222 for (int i = 0; i < STEPS_CNT; i++)
3223 {
3224 const u32 kernel_accel_try = 1 << i;
3225
3226 if (kernel_accel_try < kernel_accel_min) continue;
3227 if (kernel_accel_try > kernel_accel_max) break;
3228
3229 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3230
3231 for (int i = 0; i < VERIFIER_CNT; i++)
3232 {
3233 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3234
3235 exec_ms = MIN (exec_ms, exec_ms_v);
3236 }
3237
3238 if (exec_ms > target_ms) break;
3239
3240 kernel_accel = kernel_accel_try;
3241 }
3242 }
3243
3244 // at this point we want to know the actual runtime for the following reason:
3245 // we need a reference for the balancing loop following up, and this
3246 // the balancing loop can have an effect that the creates a new opportunity, for example:
3247 // if the target is 95 ms and the current runtime is 48ms the above loop
3248 // stopped the execution because the previous exec_ms was > 95ms
3249 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3250 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3251
3252 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3253
3254 for (int i = 0; i < VERIFIER_CNT; i++)
3255 {
3256 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3257
3258 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3259 }
3260
3261 u32 diff = kernel_loops - kernel_accel;
3262
3263 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3264 {
3265 u32 kernel_accel_orig = kernel_accel;
3266 u32 kernel_loops_orig = kernel_loops;
3267
3268 for (u32 f = 1; f < 1024; f++)
3269 {
3270 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3271 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3272
3273 if (kernel_accel_try > kernel_accel_max) break;
3274 if (kernel_loops_try < kernel_loops_min) break;
3275
3276 u32 diff_new = kernel_loops_try - kernel_accel_try;
3277
3278 if (diff_new > diff) break;
3279
3280 diff_new = diff;
3281
3282 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3283
3284 for (int i = 0; i < VERIFIER_CNT; i++)
3285 {
3286 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3287
3288 exec_ms = MIN (exec_ms, exec_ms_v);
3289 }
3290
3291 if (exec_ms < exec_ms_pre_final)
3292 {
3293 exec_ms_pre_final = exec_ms;
3294
3295 kernel_accel = kernel_accel_try;
3296 kernel_loops = kernel_loops_try;
3297 }
3298 }
3299 }
3300
3301 const double exec_left = target_ms / exec_ms_pre_final;
3302
3303 const double accel_left = kernel_accel_max / kernel_accel;
3304
3305 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3306
3307 if (exec_accel_min >= 1.0)
3308 {
3309 // this is safe to not overflow kernel_accel_max because of accel_left
3310
3311 kernel_accel = (double) kernel_accel * exec_accel_min;
3312 }
3313
3314 // reset them fake words
3315
3316 /*
3317 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3318
3319 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);
3320 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);
3321 */
3322
3323 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3324
3325 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3326 {
3327 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3328 }
3329
3330 // reset timer
3331
3332 device_param->exec_pos = 0;
3333
3334 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3335
3336 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3337 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3338 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3339
3340 // store
3341
3342 device_param->kernel_accel = kernel_accel;
3343 device_param->kernel_loops = kernel_loops;
3344
3345 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3346
3347 device_param->kernel_power = kernel_power;
3348
3349 #ifdef DEBUG
3350
3351 if (data.quiet == 0)
3352 {
3353 clear_prompt ();
3354
3355 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3356 "Device #%u: autotuned kernel-loops to %u\n",
3357 device_param->device_id + 1, kernel_accel,
3358 device_param->device_id + 1, kernel_loops);
3359
3360 fprintf (stdout, "%s", PROMPT);
3361
3362 fflush (stdout);
3363 }
3364
3365 #endif
3366 }
3367
3368 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3369 {
3370 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3371
3372 // init speed timer
3373
3374 uint speed_pos = device_param->speed_pos;
3375
3376 #ifdef _POSIX
3377 if (device_param->timer_speed.tv_sec == 0)
3378 {
3379 hc_timer_set (&device_param->timer_speed);
3380 }
3381 #endif
3382
3383 #ifdef _WIN
3384 if (device_param->timer_speed.QuadPart == 0)
3385 {
3386 hc_timer_set (&device_param->timer_speed);
3387 }
3388 #endif
3389
3390 // find higest password length, this is for optimization stuff
3391
3392 uint highest_pw_len = 0;
3393
3394 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3395 {
3396 }
3397 else if (data.attack_kern == ATTACK_KERN_COMBI)
3398 {
3399 }
3400 else if (data.attack_kern == ATTACK_KERN_BF)
3401 {
3402 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3403 + device_param->kernel_params_mp_l_buf32[5];
3404 }
3405
3406 // iteration type
3407
3408 uint innerloop_step = 0;
3409 uint innerloop_cnt = 0;
3410
3411 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3412 else innerloop_step = 1;
3413
3414 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3415 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3416 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3417
3418 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3419
3420 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3421 {
3422 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3423
3424 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3425
3426 if (data.devices_status == STATUS_CRACKED) break;
3427 if (data.devices_status == STATUS_ABORTED) break;
3428 if (data.devices_status == STATUS_QUIT) break;
3429 if (data.devices_status == STATUS_BYPASS) break;
3430
3431 salt_t *salt_buf = &data.salts_buf[salt_pos];
3432
3433 device_param->kernel_params_buf32[24] = salt_pos;
3434 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3435 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3436
3437 FILE *combs_fp = device_param->combs_fp;
3438
3439 if (data.attack_mode == ATTACK_MODE_COMBI)
3440 {
3441 rewind (combs_fp);
3442 }
3443
3444 // innerloops
3445
3446 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3447 {
3448 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3449
3450 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3451
3452 if (data.devices_status == STATUS_CRACKED) break;
3453 if (data.devices_status == STATUS_ABORTED) break;
3454 if (data.devices_status == STATUS_QUIT) break;
3455 if (data.devices_status == STATUS_BYPASS) break;
3456
3457 uint fast_iteration = 0;
3458
3459 uint innerloop_left = innerloop_cnt - innerloop_pos;
3460
3461 if (innerloop_left > innerloop_step)
3462 {
3463 innerloop_left = innerloop_step;
3464
3465 fast_iteration = 1;
3466 }
3467
3468 device_param->innerloop_pos = innerloop_pos;
3469 device_param->innerloop_left = innerloop_left;
3470
3471 device_param->kernel_params_buf32[27] = innerloop_left;
3472
3473 // i think we can get rid of this
3474 if (innerloop_left == 0)
3475 {
3476 puts ("bug, how should this happen????\n");
3477
3478 continue;
3479 }
3480
3481 if (data.salts_shown[salt_pos] == 1)
3482 {
3483 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3484
3485 continue;
3486 }
3487
3488 // initialize amplifiers
3489
3490 if (data.attack_mode == ATTACK_MODE_COMBI)
3491 {
3492 uint i = 0;
3493
3494 while (i < innerloop_left)
3495 {
3496 if (feof (combs_fp)) break;
3497
3498 int line_len = fgetl (combs_fp, line_buf);
3499
3500 if (line_len >= PW_MAX1) continue;
3501
3502 line_len = convert_from_hex (line_buf, line_len);
3503
3504 char *line_buf_new = line_buf;
3505
3506 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3507 {
3508 char rule_buf_out[BLOCK_SIZE] = { 0 };
3509
3510 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3511
3512 if (rule_len_out < 0)
3513 {
3514 data.words_progress_rejected[salt_pos] += pws_cnt;
3515
3516 continue;
3517 }
3518
3519 line_len = rule_len_out;
3520
3521 line_buf_new = rule_buf_out;
3522 }
3523
3524 line_len = MIN (line_len, PW_DICTMAX);
3525
3526 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3527
3528 memcpy (ptr, line_buf_new, line_len);
3529
3530 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3531
3532 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3533 {
3534 uppercase (ptr, line_len);
3535 }
3536
3537 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3538 {
3539 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3540 {
3541 ptr[line_len] = 0x80;
3542 }
3543
3544 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3545 {
3546 ptr[line_len] = 0x01;
3547 }
3548 }
3549
3550 device_param->combs_buf[i].pw_len = line_len;
3551
3552 i++;
3553 }
3554
3555 for (uint j = i; j < innerloop_left; j++)
3556 {
3557 device_param->combs_buf[j].i[0] = 0;
3558 device_param->combs_buf[j].i[1] = 0;
3559 device_param->combs_buf[j].i[2] = 0;
3560 device_param->combs_buf[j].i[3] = 0;
3561 device_param->combs_buf[j].i[4] = 0;
3562 device_param->combs_buf[j].i[5] = 0;
3563 device_param->combs_buf[j].i[6] = 0;
3564 device_param->combs_buf[j].i[7] = 0;
3565
3566 device_param->combs_buf[j].pw_len = 0;
3567 }
3568
3569 innerloop_left = i;
3570 }
3571 else if (data.attack_mode == ATTACK_MODE_BF)
3572 {
3573 u64 off = innerloop_pos;
3574
3575 device_param->kernel_params_mp_r_buf64[3] = off;
3576
3577 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3578 }
3579 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3580 {
3581 u64 off = innerloop_pos;
3582
3583 device_param->kernel_params_mp_buf64[3] = off;
3584
3585 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3586 }
3587 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3588 {
3589 u64 off = innerloop_pos;
3590
3591 device_param->kernel_params_mp_buf64[3] = off;
3592
3593 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3594 }
3595
3596 // copy amplifiers
3597
3598 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3599 {
3600 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);
3601 }
3602 else if (data.attack_mode == ATTACK_MODE_COMBI)
3603 {
3604 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);
3605 }
3606 else if (data.attack_mode == ATTACK_MODE_BF)
3607 {
3608 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);
3609 }
3610 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3611 {
3612 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);
3613 }
3614 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3615 {
3616 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);
3617 }
3618
3619 if (data.benchmark == 1)
3620 {
3621 hc_timer_set (&device_param->timer_speed);
3622 }
3623
3624 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3625
3626 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3627
3628 if (data.devices_status == STATUS_CRACKED) break;
3629 if (data.devices_status == STATUS_ABORTED) break;
3630 if (data.devices_status == STATUS_QUIT) break;
3631
3632 /**
3633 * result
3634 */
3635
3636 if (data.benchmark == 0)
3637 {
3638 check_cracked (device_param, salt_pos);
3639 }
3640
3641 /**
3642 * progress
3643 */
3644
3645 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3646
3647 hc_thread_mutex_lock (mux_counter);
3648
3649 data.words_progress_done[salt_pos] += perf_sum_all;
3650
3651 hc_thread_mutex_unlock (mux_counter);
3652
3653 /**
3654 * speed
3655 */
3656
3657 double speed_ms;
3658
3659 hc_timer_get (device_param->timer_speed, speed_ms);
3660
3661 hc_timer_set (&device_param->timer_speed);
3662
3663 // current speed
3664
3665 //hc_thread_mutex_lock (mux_display);
3666
3667 device_param->speed_cnt[speed_pos] = perf_sum_all;
3668
3669 device_param->speed_ms[speed_pos] = speed_ms;
3670
3671 //hc_thread_mutex_unlock (mux_display);
3672
3673 speed_pos++;
3674
3675 if (speed_pos == SPEED_CACHE)
3676 {
3677 speed_pos = 0;
3678 }
3679
3680 /**
3681 * benchmark
3682 */
3683
3684 if (data.benchmark == 1) break;
3685 }
3686 }
3687
3688 device_param->speed_pos = speed_pos;
3689
3690 myfree (line_buf);
3691 }
3692
3693 static void load_segment (wl_data_t *wl_data, FILE *fd)
3694 {
3695 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3696
3697 wl_data->pos = 0;
3698
3699 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3700
3701 wl_data->buf[wl_data->cnt] = 0;
3702
3703 if (wl_data->cnt == 0) return;
3704
3705 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3706
3707 while (!feof (fd))
3708 {
3709 if (wl_data->cnt == wl_data->avail)
3710 {
3711 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3712
3713 wl_data->avail += wl_data->incr;
3714 }
3715
3716 const int c = fgetc (fd);
3717
3718 if (c == EOF) break;
3719
3720 wl_data->buf[wl_data->cnt] = (char) c;
3721
3722 wl_data->cnt++;
3723
3724 if (c == '\n') break;
3725 }
3726
3727 // ensure stream ends with a newline
3728
3729 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3730 {
3731 wl_data->cnt++;
3732
3733 wl_data->buf[wl_data->cnt - 1] = '\n';
3734 }
3735
3736 return;
3737 }
3738
3739 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3740 {
3741 char *ptr = buf;
3742
3743 for (u32 i = 0; i < sz; i++, ptr++)
3744 {
3745 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3746
3747 if (i == 7)
3748 {
3749 *off = i;
3750 *len = i;
3751
3752 return;
3753 }
3754
3755 if (*ptr != '\n') continue;
3756
3757 *off = i + 1;
3758
3759 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3760
3761 *len = i;
3762
3763 return;
3764 }
3765
3766 *off = sz;
3767 *len = sz;
3768 }
3769
3770 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3771 {
3772 char *ptr = buf;
3773
3774 for (u32 i = 0; i < sz; i++, ptr++)
3775 {
3776 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3777
3778 if (*ptr != '\n') continue;
3779
3780 *off = i + 1;
3781
3782 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3783
3784 *len = i;
3785
3786 return;
3787 }
3788
3789 *off = sz;
3790 *len = sz;
3791 }
3792
3793 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3794 {
3795 char *ptr = buf;
3796
3797 for (u32 i = 0; i < sz; i++, ptr++)
3798 {
3799 if (*ptr != '\n') continue;
3800
3801 *off = i + 1;
3802
3803 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3804
3805 *len = i;
3806
3807 return;
3808 }
3809
3810 *off = sz;
3811 *len = sz;
3812 }
3813
3814 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3815 {
3816 while (wl_data->pos < wl_data->cnt)
3817 {
3818 uint off;
3819 uint len;
3820
3821 char *ptr = wl_data->buf + wl_data->pos;
3822
3823 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3824
3825 wl_data->pos += off;
3826
3827 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3828 {
3829 char rule_buf_out[BLOCK_SIZE] = { 0 };
3830
3831 int rule_len_out = -1;
3832
3833 if (len < BLOCK_SIZE)
3834 {
3835 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3836 }
3837
3838 if (rule_len_out < 0)
3839 {
3840 continue;
3841 }
3842
3843 if (rule_len_out > PW_MAX)
3844 {
3845 continue;
3846 }
3847 }
3848 else
3849 {
3850 if (len > PW_MAX)
3851 {
3852 continue;
3853 }
3854 }
3855
3856 *out_buf = ptr;
3857 *out_len = len;
3858
3859 return;
3860 }
3861
3862 if (feof (fd))
3863 {
3864 fprintf (stderr, "BUG feof()!!\n");
3865
3866 return;
3867 }
3868
3869 load_segment (wl_data, fd);
3870
3871 get_next_word (wl_data, fd, out_buf, out_len);
3872 }
3873
3874 #ifdef _POSIX
3875 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3876 #endif
3877
3878 #ifdef _WIN
3879 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3880 #endif
3881 {
3882 hc_signal (NULL);
3883
3884 dictstat_t d;
3885
3886 d.cnt = 0;
3887
3888 #ifdef _POSIX
3889 fstat (fileno (fd), &d.stat);
3890 #endif
3891
3892 #ifdef _WIN
3893 _fstat64 (fileno (fd), &d.stat);
3894 #endif
3895
3896 d.stat.st_mode = 0;
3897 d.stat.st_nlink = 0;
3898 d.stat.st_uid = 0;
3899 d.stat.st_gid = 0;
3900 d.stat.st_rdev = 0;
3901 d.stat.st_atime = 0;
3902
3903 #ifdef _POSIX
3904 d.stat.st_blksize = 0;
3905 d.stat.st_blocks = 0;
3906 #endif
3907
3908 if (d.stat.st_size == 0) return 0;
3909
3910 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3911
3912 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3913 {
3914 if (d_cache)
3915 {
3916 u64 cnt = d_cache->cnt;
3917
3918 u64 keyspace = cnt;
3919
3920 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3921 {
3922 keyspace *= data.kernel_rules_cnt;
3923 }
3924 else if (data.attack_kern == ATTACK_KERN_COMBI)
3925 {
3926 keyspace *= data.combs_cnt;
3927 }
3928
3929 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);
3930 if (data.quiet == 0) log_info ("");
3931
3932 hc_signal (sigHandler_default);
3933
3934 return (keyspace);
3935 }
3936 }
3937
3938 time_t now = 0;
3939 time_t prev = 0;
3940
3941 u64 comp = 0;
3942 u64 cnt = 0;
3943 u64 cnt2 = 0;
3944
3945 while (!feof (fd))
3946 {
3947 load_segment (wl_data, fd);
3948
3949 comp += wl_data->cnt;
3950
3951 u32 i = 0;
3952
3953 while (i < wl_data->cnt)
3954 {
3955 u32 len;
3956 u32 off;
3957
3958 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3959
3960 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3961 {
3962 char rule_buf_out[BLOCK_SIZE] = { 0 };
3963
3964 int rule_len_out = -1;
3965
3966 if (len < BLOCK_SIZE)
3967 {
3968 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3969 }
3970
3971 if (rule_len_out < 0)
3972 {
3973 len = PW_MAX1;
3974 }
3975 else
3976 {
3977 len = rule_len_out;
3978 }
3979 }
3980
3981 if (len < PW_MAX1)
3982 {
3983 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3984 {
3985 cnt += data.kernel_rules_cnt;
3986 }
3987 else if (data.attack_kern == ATTACK_KERN_COMBI)
3988 {
3989 cnt += data.combs_cnt;
3990 }
3991
3992 d.cnt++;
3993 }
3994
3995 i += off;
3996
3997 cnt2++;
3998 }
3999
4000 time (&now);
4001
4002 if ((now - prev) == 0) continue;
4003
4004 float percent = (float) comp / (float) d.stat.st_size;
4005
4006 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);
4007
4008 time (&prev);
4009 }
4010
4011 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);
4012 if (data.quiet == 0) log_info ("");
4013
4014 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4015
4016 hc_signal (sigHandler_default);
4017
4018 return (cnt);
4019 }
4020
4021 static void *thread_monitor (void *p)
4022 {
4023 uint runtime_check = 0;
4024 uint remove_check = 0;
4025 uint status_check = 0;
4026 uint restore_check = 0;
4027
4028 uint restore_left = data.restore_timer;
4029 uint remove_left = data.remove_timer;
4030 uint status_left = data.status_timer;
4031
4032 #ifdef HAVE_HWMON
4033 uint hwmon_check = 0;
4034
4035 int slowdown_warnings = 0;
4036
4037 // these variables are mainly used for fan control
4038
4039 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4040
4041 // temperature controller "loopback" values
4042
4043 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4044 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4045
4046 int temp_threshold = 1; // degrees celcius
4047
4048 int fan_speed_min = 15; // in percentage
4049 int fan_speed_max = 100;
4050
4051 time_t last_temp_check_time;
4052 #endif // HAVE_HWMON
4053
4054 uint sleep_time = 1;
4055
4056 if (data.runtime)
4057 {
4058 runtime_check = 1;
4059 }
4060
4061 if (data.restore_timer)
4062 {
4063 restore_check = 1;
4064 }
4065
4066 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4067 {
4068 remove_check = 1;
4069 }
4070
4071 if (data.status == 1)
4072 {
4073 status_check = 1;
4074 }
4075
4076 #ifdef HAVE_HWMON
4077 if (data.gpu_temp_disable == 0)
4078 {
4079 time (&last_temp_check_time);
4080
4081 hwmon_check = 1;
4082 }
4083 #endif
4084
4085 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4086 {
4087 #ifdef HAVE_HWMON
4088 if (hwmon_check == 0)
4089 #endif
4090 return (p);
4091 }
4092
4093 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4094 {
4095 hc_sleep (sleep_time);
4096
4097 if (data.devices_status != STATUS_RUNNING) continue;
4098
4099 #ifdef HAVE_HWMON
4100
4101 if (hwmon_check == 1)
4102 {
4103 hc_thread_mutex_lock (mux_adl);
4104
4105 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4106 {
4107 hc_device_param_t *device_param = &data.devices_param[device_id];
4108
4109 if (device_param->skipped) continue;
4110
4111 if (device_param->device_vendor_id == VENDOR_ID_NV)
4112 {
4113 if (data.hm_nvapi)
4114 {
4115 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
4116 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4117
4118 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4119 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4120
4121 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4122
4123 perfPolicies_status.info_value = perfPolicies_info.info_value;
4124
4125 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4126
4127 if (perfPolicies_status.throttle & 2)
4128 {
4129 if (slowdown_warnings < 3)
4130 {
4131 if (data.quiet == 0) clear_prompt ();
4132
4133 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4134
4135 if (slowdown_warnings == 2)
4136 {
4137 log_info ("");
4138 }
4139
4140 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4141 if (data.quiet == 0) fflush (stdout);
4142
4143 slowdown_warnings++;
4144 }
4145 }
4146 else
4147 {
4148 slowdown_warnings = 0;
4149 }
4150 }
4151 }
4152 }
4153
4154 hc_thread_mutex_unlock (mux_adl);
4155 }
4156
4157 if (hwmon_check == 1)
4158 {
4159 hc_thread_mutex_lock (mux_adl);
4160
4161 time_t temp_check_time;
4162
4163 time (&temp_check_time);
4164
4165 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4166
4167 if (Ta == 0) Ta = 1;
4168
4169 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4170 {
4171 hc_device_param_t *device_param = &data.devices_param[device_id];
4172
4173 if (device_param->skipped) continue;
4174
4175 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4176
4177 const int temperature = hm_get_temperature_with_device_id (device_id);
4178
4179 if (temperature > (int) data.gpu_temp_abort)
4180 {
4181 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4182
4183 if (data.devices_status != STATUS_QUIT) myabort ();
4184
4185 break;
4186 }
4187
4188 const int gpu_temp_retain = data.gpu_temp_retain;
4189
4190 if (gpu_temp_retain)
4191 {
4192 if (data.hm_device[device_id].fan_set_supported == 1)
4193 {
4194 int temp_cur = temperature;
4195
4196 int temp_diff_new = gpu_temp_retain - temp_cur;
4197
4198 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4199
4200 // calculate Ta value (time difference in seconds between the last check and this check)
4201
4202 last_temp_check_time = temp_check_time;
4203
4204 float Kp = 1.8;
4205 float Ki = 0.005;
4206 float Kd = 6;
4207
4208 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4209
4210 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);
4211
4212 if (abs (fan_diff_required) >= temp_threshold)
4213 {
4214 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4215
4216 int fan_speed_level = fan_speed_cur;
4217
4218 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4219
4220 int fan_speed_new = fan_speed_level - fan_diff_required;
4221
4222 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4223 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4224
4225 if (fan_speed_new != fan_speed_cur)
4226 {
4227 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4228 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4229
4230 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4231 {
4232 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4233 {
4234 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4235 }
4236 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4237 {
4238
4239 }
4240
4241 fan_speed_chgd[device_id] = 1;
4242 }
4243
4244 temp_diff_old[device_id] = temp_diff_new;
4245 }
4246 }
4247 }
4248 }
4249 }
4250
4251 hc_thread_mutex_unlock (mux_adl);
4252 }
4253 #endif // HAVE_HWMON
4254
4255 if (restore_check == 1)
4256 {
4257 restore_left--;
4258
4259 if (restore_left == 0)
4260 {
4261 if (data.restore_disable == 0) cycle_restore ();
4262
4263 restore_left = data.restore_timer;
4264 }
4265 }
4266
4267 if ((runtime_check == 1) && (data.runtime_start > 0))
4268 {
4269 time_t runtime_cur;
4270
4271 time (&runtime_cur);
4272
4273 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4274
4275 if (runtime_left <= 0)
4276 {
4277 if (data.benchmark == 0)
4278 {
4279 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4280 }
4281
4282 if (data.devices_status != STATUS_QUIT) myabort ();
4283 }
4284 }
4285
4286 if (remove_check == 1)
4287 {
4288 remove_left--;
4289
4290 if (remove_left == 0)
4291 {
4292 if (data.digests_saved != data.digests_done)
4293 {
4294 data.digests_saved = data.digests_done;
4295
4296 save_hash ();
4297 }
4298
4299 remove_left = data.remove_timer;
4300 }
4301 }
4302
4303 if (status_check == 1)
4304 {
4305 status_left--;
4306
4307 if (status_left == 0)
4308 {
4309 //hc_thread_mutex_lock (mux_display);
4310
4311 if (data.quiet == 0) clear_prompt ();
4312
4313 if (data.quiet == 0) log_info ("");
4314
4315 status_display ();
4316
4317 if (data.quiet == 0) log_info ("");
4318
4319 //hc_thread_mutex_unlock (mux_display);
4320
4321 status_left = data.status_timer;
4322 }
4323 }
4324 }
4325
4326 #ifdef HAVE_HWMON
4327 myfree (fan_speed_chgd);
4328
4329 myfree (temp_diff_old);
4330 myfree (temp_diff_sum);
4331 #endif
4332
4333 p = NULL;
4334
4335 return (p);
4336 }
4337
4338 static void *thread_outfile_remove (void *p)
4339 {
4340 // some hash-dependent constants
4341 char *outfile_dir = data.outfile_check_directory;
4342 uint dgst_size = data.dgst_size;
4343 uint isSalted = data.isSalted;
4344 uint esalt_size = data.esalt_size;
4345 uint hash_mode = data.hash_mode;
4346
4347 uint outfile_check_timer = data.outfile_check_timer;
4348
4349 char separator = data.separator;
4350
4351 // some hash-dependent functions
4352 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4353 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4354
4355 // buffers
4356 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4357
4358 hash_buf.digest = mymalloc (dgst_size);
4359
4360 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4361
4362 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4363
4364 uint digest_buf[64] = { 0 };
4365
4366 outfile_data_t *out_info = NULL;
4367
4368 char **out_files = NULL;
4369
4370 time_t folder_mtime = 0;
4371
4372 int out_cnt = 0;
4373
4374 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4375
4376 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4377 {
4378 hc_sleep (1);
4379
4380 if (data.devices_status != STATUS_RUNNING) continue;
4381
4382 check_left--;
4383
4384 if (check_left == 0)
4385 {
4386 struct stat outfile_check_stat;
4387
4388 if (stat (outfile_dir, &outfile_check_stat) == 0)
4389 {
4390 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4391
4392 if (is_dir == 1)
4393 {
4394 if (outfile_check_stat.st_mtime > folder_mtime)
4395 {
4396 char **out_files_new = scan_directory (outfile_dir);
4397
4398 int out_cnt_new = count_dictionaries (out_files_new);
4399
4400 outfile_data_t *out_info_new = NULL;
4401
4402 if (out_cnt_new > 0)
4403 {
4404 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4405
4406 for (int i = 0; i < out_cnt_new; i++)
4407 {
4408 out_info_new[i].file_name = out_files_new[i];
4409
4410 // check if there are files that we have seen/checked before (and not changed)
4411
4412 for (int j = 0; j < out_cnt; j++)
4413 {
4414 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4415 {
4416 struct stat outfile_stat;
4417
4418 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4419 {
4420 if (outfile_stat.st_ctime == out_info[j].ctime)
4421 {
4422 out_info_new[i].ctime = out_info[j].ctime;
4423 out_info_new[i].seek = out_info[j].seek;
4424 }
4425 }
4426 }
4427 }
4428 }
4429 }
4430
4431 local_free (out_info);
4432 local_free (out_files);
4433
4434 out_files = out_files_new;
4435 out_cnt = out_cnt_new;
4436 out_info = out_info_new;
4437
4438 folder_mtime = outfile_check_stat.st_mtime;
4439 }
4440
4441 for (int j = 0; j < out_cnt; j++)
4442 {
4443 FILE *fp = fopen (out_info[j].file_name, "rb");
4444
4445 if (fp != NULL)
4446 {
4447 //hc_thread_mutex_lock (mux_display);
4448
4449 #ifdef _POSIX
4450 struct stat outfile_stat;
4451
4452 fstat (fileno (fp), &outfile_stat);
4453 #endif
4454
4455 #ifdef _WIN
4456 struct stat64 outfile_stat;
4457
4458 _fstat64 (fileno (fp), &outfile_stat);
4459 #endif
4460
4461 if (outfile_stat.st_ctime > out_info[j].ctime)
4462 {
4463 out_info[j].ctime = outfile_stat.st_ctime;
4464 out_info[j].seek = 0;
4465 }
4466
4467 fseek (fp, out_info[j].seek, SEEK_SET);
4468
4469 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4470
4471 while (!feof (fp))
4472 {
4473 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4474
4475 if (ptr == NULL) break;
4476
4477 int line_len = strlen (line_buf);
4478
4479 if (line_len <= 0) continue;
4480
4481 int iter = MAX_CUT_TRIES;
4482
4483 for (uint i = line_len - 1; i && iter; i--, line_len--)
4484 {
4485 if (line_buf[i] != separator) continue;
4486
4487 int parser_status = PARSER_OK;
4488
4489 if ((hash_mode != 2500) && (hash_mode != 6800))
4490 {
4491 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4492 }
4493
4494 uint found = 0;
4495
4496 if (parser_status == PARSER_OK)
4497 {
4498 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4499 {
4500 if (data.salts_shown[salt_pos] == 1) continue;
4501
4502 salt_t *salt_buf = &data.salts_buf[salt_pos];
4503
4504 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4505 {
4506 uint idx = salt_buf->digests_offset + digest_pos;
4507
4508 if (data.digests_shown[idx] == 1) continue;
4509
4510 uint cracked = 0;
4511
4512 if (hash_mode == 6800)
4513 {
4514 if (i == salt_buf->salt_len)
4515 {
4516 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4517 }
4518 }
4519 else if (hash_mode == 2500)
4520 {
4521 // BSSID : MAC1 : MAC2 (:plain)
4522 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4523 {
4524 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4525
4526 if (!cracked) continue;
4527
4528 // now compare MAC1 and MAC2 too, since we have this additional info
4529 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4530 char *mac2_pos = mac1_pos + 12 + 1;
4531
4532 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4533 wpa_t *wpa = &wpas[salt_pos];
4534
4535 // compare hex string(s) vs binary MAC address(es)
4536
4537 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4538 {
4539 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4540 {
4541 cracked = 0;
4542
4543 break;
4544 }
4545 }
4546
4547 // early skip ;)
4548 if (!cracked) continue;
4549
4550 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4551 {
4552 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4553 {
4554 cracked = 0;
4555
4556 break;
4557 }
4558 }
4559 }
4560 }
4561 else
4562 {
4563 char *digests_buf_ptr = (char *) data.digests_buf;
4564
4565 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4566
4567 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4568 }
4569
4570 if (cracked == 1)
4571 {
4572 found = 1;
4573
4574 data.digests_shown[idx] = 1;
4575
4576 data.digests_done++;
4577
4578 salt_buf->digests_done++;
4579
4580 if (salt_buf->digests_done == salt_buf->digests_cnt)
4581 {
4582 data.salts_shown[salt_pos] = 1;
4583
4584 data.salts_done++;
4585
4586 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4587 }
4588 }
4589 }
4590
4591 if (data.devices_status == STATUS_CRACKED) break;
4592 }
4593 }
4594
4595 if (found) break;
4596
4597 if (data.devices_status == STATUS_CRACKED) break;
4598
4599 iter--;
4600 }
4601
4602 if (data.devices_status == STATUS_CRACKED) break;
4603 }
4604
4605 myfree (line_buf);
4606
4607 out_info[j].seek = ftell (fp);
4608
4609 //hc_thread_mutex_unlock (mux_display);
4610
4611 fclose (fp);
4612 }
4613 }
4614 }
4615 }
4616
4617 check_left = outfile_check_timer;
4618 }
4619 }
4620
4621 if (esalt_size) local_free (hash_buf.esalt);
4622
4623 if (isSalted) local_free (hash_buf.salt);
4624
4625 local_free (hash_buf.digest);
4626
4627 local_free (out_info);
4628
4629 local_free (out_files);
4630
4631 p = NULL;
4632
4633 return (p);
4634 }
4635
4636 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4637 {
4638 //if (device_param->pws_cnt < device_param->kernel_power)
4639 //{
4640 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4641
4642 u8 *ptr = (u8 *) pw->i;
4643
4644 memcpy (ptr, pw_buf, pw_len);
4645
4646 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4647
4648 pw->pw_len = pw_len;
4649
4650 device_param->pws_cnt++;
4651 //}
4652 //else
4653 //{
4654 // fprintf (stderr, "BUG pw_add()!!\n");
4655 //
4656 // return;
4657 //}
4658 }
4659
4660 static void set_kernel_power_final (const u64 kernel_power_final)
4661 {
4662 if (data.quiet == 0)
4663 {
4664 clear_prompt ();
4665
4666 //log_info ("");
4667
4668 log_info ("INFO: approaching final keyspace, workload adjusted");
4669 log_info ("");
4670
4671 fprintf (stdout, "%s", PROMPT);
4672
4673 fflush (stdout);
4674 }
4675
4676 data.kernel_power_final = kernel_power_final;
4677 }
4678
4679 static u32 get_power (hc_device_param_t *device_param)
4680 {
4681 const u64 kernel_power_final = data.kernel_power_final;
4682
4683 if (kernel_power_final)
4684 {
4685 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4686
4687 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4688
4689 // work should be at least the hardware power available without any accelerator
4690
4691 const u64 work = MAX (words_left_device, device_param->hardware_power);
4692
4693 return work;
4694 }
4695
4696 return device_param->kernel_power;
4697 }
4698
4699 static uint get_work (hc_device_param_t *device_param, const u64 max)
4700 {
4701 hc_thread_mutex_lock (mux_dispatcher);
4702
4703 const u64 words_cur = data.words_cur;
4704 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4705
4706 device_param->words_off = words_cur;
4707
4708 const u64 kernel_power_all = data.kernel_power_all;
4709
4710 const u64 words_left = words_base - words_cur;
4711
4712 if (words_left < kernel_power_all)
4713 {
4714 if (data.kernel_power_final == 0)
4715 {
4716 set_kernel_power_final (words_left);
4717 }
4718 }
4719
4720 const u32 kernel_power = get_power (device_param);
4721
4722 uint work = MIN (words_left, kernel_power);
4723
4724 work = MIN (work, max);
4725
4726 data.words_cur += work;
4727
4728 hc_thread_mutex_unlock (mux_dispatcher);
4729
4730 return work;
4731 }
4732
4733 static void *thread_autotune (void *p)
4734 {
4735 hc_device_param_t *device_param = (hc_device_param_t *) p;
4736
4737 if (device_param->skipped) return NULL;
4738
4739 autotune (device_param);
4740
4741 return NULL;
4742 }
4743
4744 static void *thread_calc_stdin (void *p)
4745 {
4746 hc_device_param_t *device_param = (hc_device_param_t *) p;
4747
4748 if (device_param->skipped) return NULL;
4749
4750 char *buf = (char *) mymalloc (HCBUFSIZ);
4751
4752 const uint attack_kern = data.attack_kern;
4753
4754 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4755 {
4756 hc_thread_mutex_lock (mux_dispatcher);
4757
4758 if (feof (stdin) != 0)
4759 {
4760 hc_thread_mutex_unlock (mux_dispatcher);
4761
4762 break;
4763 }
4764
4765 uint words_cur = 0;
4766
4767 while (words_cur < device_param->kernel_power)
4768 {
4769 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4770
4771 if (line_buf == NULL) break;
4772
4773 uint line_len = in_superchop (line_buf);
4774
4775 line_len = convert_from_hex (line_buf, line_len);
4776
4777 // post-process rule engine
4778
4779 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4780 {
4781 char rule_buf_out[BLOCK_SIZE] = { 0 };
4782
4783 int rule_len_out = -1;
4784
4785 if (line_len < BLOCK_SIZE)
4786 {
4787 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4788 }
4789
4790 if (rule_len_out < 0) continue;
4791
4792 line_buf = rule_buf_out;
4793 line_len = rule_len_out;
4794 }
4795
4796 if (line_len > PW_MAX)
4797 {
4798 continue;
4799 }
4800
4801 // hmm that's always the case, or?
4802
4803 if (attack_kern == ATTACK_KERN_STRAIGHT)
4804 {
4805 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4806 {
4807 hc_thread_mutex_lock (mux_counter);
4808
4809 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4810 {
4811 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4812 }
4813
4814 hc_thread_mutex_unlock (mux_counter);
4815
4816 continue;
4817 }
4818 }
4819
4820 pw_add (device_param, (u8 *) line_buf, line_len);
4821
4822 words_cur++;
4823
4824 if (data.devices_status == STATUS_CRACKED) break;
4825 if (data.devices_status == STATUS_ABORTED) break;
4826 if (data.devices_status == STATUS_QUIT) break;
4827 if (data.devices_status == STATUS_BYPASS) break;
4828 }
4829
4830 hc_thread_mutex_unlock (mux_dispatcher);
4831
4832 if (data.devices_status == STATUS_CRACKED) break;
4833 if (data.devices_status == STATUS_ABORTED) break;
4834 if (data.devices_status == STATUS_QUIT) break;
4835 if (data.devices_status == STATUS_BYPASS) break;
4836
4837 // flush
4838
4839 const uint pws_cnt = device_param->pws_cnt;
4840
4841 if (pws_cnt)
4842 {
4843 run_copy (device_param, pws_cnt);
4844
4845 run_cracker (device_param, pws_cnt);
4846
4847 device_param->pws_cnt = 0;
4848
4849 /*
4850 still required?
4851 if (attack_kern == ATTACK_KERN_STRAIGHT)
4852 {
4853 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4854 }
4855 else if (attack_kern == ATTACK_KERN_COMBI)
4856 {
4857 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4858 }
4859 */
4860 }
4861 }
4862
4863 device_param->kernel_accel = 0;
4864 device_param->kernel_loops = 0;
4865
4866 myfree (buf);
4867
4868 return NULL;
4869 }
4870
4871 static void *thread_calc (void *p)
4872 {
4873 hc_device_param_t *device_param = (hc_device_param_t *) p;
4874
4875 if (device_param->skipped) return NULL;
4876
4877 const uint attack_mode = data.attack_mode;
4878 const uint attack_kern = data.attack_kern;
4879
4880 if (attack_mode == ATTACK_MODE_BF)
4881 {
4882 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4883 {
4884 const uint work = get_work (device_param, -1);
4885
4886 if (work == 0) break;
4887
4888 const u64 words_off = device_param->words_off;
4889 const u64 words_fin = words_off + work;
4890
4891 const uint pws_cnt = work;
4892
4893 device_param->pws_cnt = pws_cnt;
4894
4895 if (pws_cnt)
4896 {
4897 run_copy (device_param, pws_cnt);
4898
4899 run_cracker (device_param, pws_cnt);
4900
4901 device_param->pws_cnt = 0;
4902
4903 /*
4904 still required?
4905 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4906 */
4907 }
4908
4909 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4910
4911 if (data.devices_status == STATUS_CRACKED) break;
4912 if (data.devices_status == STATUS_ABORTED) break;
4913 if (data.devices_status == STATUS_QUIT) break;
4914 if (data.devices_status == STATUS_BYPASS) break;
4915
4916 if (data.benchmark == 1) break;
4917
4918 device_param->words_done = words_fin;
4919 }
4920 }
4921 else
4922 {
4923 const uint segment_size = data.segment_size;
4924
4925 char *dictfile = data.dictfile;
4926
4927 if (attack_mode == ATTACK_MODE_COMBI)
4928 {
4929 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4930 {
4931 dictfile = data.dictfile2;
4932 }
4933 }
4934
4935 FILE *fd = fopen (dictfile, "rb");
4936
4937 if (fd == NULL)
4938 {
4939 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4940
4941 return NULL;
4942 }
4943
4944 if (attack_mode == ATTACK_MODE_COMBI)
4945 {
4946 const uint combs_mode = data.combs_mode;
4947
4948 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4949 {
4950 const char *dictfilec = data.dictfile2;
4951
4952 FILE *combs_fp = fopen (dictfilec, "rb");
4953
4954 if (combs_fp == NULL)
4955 {
4956 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4957
4958 fclose (fd);
4959
4960 return NULL;
4961 }
4962
4963 device_param->combs_fp = combs_fp;
4964 }
4965 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4966 {
4967 const char *dictfilec = data.dictfile;
4968
4969 FILE *combs_fp = fopen (dictfilec, "rb");
4970
4971 if (combs_fp == NULL)
4972 {
4973 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4974
4975 fclose (fd);
4976
4977 return NULL;
4978 }
4979
4980 device_param->combs_fp = combs_fp;
4981 }
4982 }
4983
4984 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4985
4986 wl_data->buf = (char *) mymalloc (segment_size);
4987 wl_data->avail = segment_size;
4988 wl_data->incr = segment_size;
4989 wl_data->cnt = 0;
4990 wl_data->pos = 0;
4991
4992 u64 words_cur = 0;
4993
4994 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4995 {
4996 u64 words_off = 0;
4997 u64 words_fin = 0;
4998
4999 u64 max = -1;
5000
5001 while (max)
5002 {
5003 const uint work = get_work (device_param, max);
5004
5005 if (work == 0) break;
5006
5007 max = 0;
5008
5009 words_off = device_param->words_off;
5010 words_fin = words_off + work;
5011
5012 char *line_buf;
5013 uint line_len;
5014
5015 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5016
5017 for ( ; words_cur < words_fin; words_cur++)
5018 {
5019 get_next_word (wl_data, fd, &line_buf, &line_len);
5020
5021 line_len = convert_from_hex (line_buf, line_len);
5022
5023 // post-process rule engine
5024
5025 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5026 {
5027 char rule_buf_out[BLOCK_SIZE] = { 0 };
5028
5029 int rule_len_out = -1;
5030
5031 if (line_len < BLOCK_SIZE)
5032 {
5033 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5034 }
5035
5036 if (rule_len_out < 0) continue;
5037
5038 line_buf = rule_buf_out;
5039 line_len = rule_len_out;
5040 }
5041
5042 if (attack_kern == ATTACK_KERN_STRAIGHT)
5043 {
5044 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5045 {
5046 max++;
5047
5048 hc_thread_mutex_lock (mux_counter);
5049
5050 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5051 {
5052 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5053 }
5054
5055 hc_thread_mutex_unlock (mux_counter);
5056
5057 continue;
5058 }
5059 }
5060 else if (attack_kern == ATTACK_KERN_COMBI)
5061 {
5062 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5063 // since we still need to combine the plains
5064
5065 if (line_len > data.pw_max)
5066 {
5067 max++;
5068
5069 hc_thread_mutex_lock (mux_counter);
5070
5071 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5072 {
5073 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5074 }
5075
5076 hc_thread_mutex_unlock (mux_counter);
5077
5078 continue;
5079 }
5080 }
5081
5082 pw_add (device_param, (u8 *) line_buf, line_len);
5083
5084 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5085
5086 if (data.devices_status == STATUS_CRACKED) break;
5087 if (data.devices_status == STATUS_ABORTED) break;
5088 if (data.devices_status == STATUS_QUIT) break;
5089 if (data.devices_status == STATUS_BYPASS) break;
5090 }
5091
5092 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5093
5094 if (data.devices_status == STATUS_CRACKED) break;
5095 if (data.devices_status == STATUS_ABORTED) break;
5096 if (data.devices_status == STATUS_QUIT) break;
5097 if (data.devices_status == STATUS_BYPASS) break;
5098 }
5099
5100 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5101
5102 if (data.devices_status == STATUS_CRACKED) break;
5103 if (data.devices_status == STATUS_ABORTED) break;
5104 if (data.devices_status == STATUS_QUIT) break;
5105 if (data.devices_status == STATUS_BYPASS) break;
5106
5107 //
5108 // flush
5109 //
5110
5111 const uint pws_cnt = device_param->pws_cnt;
5112
5113 if (pws_cnt)
5114 {
5115 run_copy (device_param, pws_cnt);
5116
5117 run_cracker (device_param, pws_cnt);
5118
5119 device_param->pws_cnt = 0;
5120
5121 /*
5122 still required?
5123 if (attack_kern == ATTACK_KERN_STRAIGHT)
5124 {
5125 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5126 }
5127 else if (attack_kern == ATTACK_KERN_COMBI)
5128 {
5129 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5130 }
5131 */
5132 }
5133
5134 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5135
5136 if (data.devices_status == STATUS_CRACKED) break;
5137 if (data.devices_status == STATUS_ABORTED) break;
5138 if (data.devices_status == STATUS_QUIT) break;
5139 if (data.devices_status == STATUS_BYPASS) break;
5140
5141 if (words_fin == 0) break;
5142
5143 device_param->words_done = words_fin;
5144 }
5145
5146 if (attack_mode == ATTACK_MODE_COMBI)
5147 {
5148 fclose (device_param->combs_fp);
5149 }
5150
5151 free (wl_data->buf);
5152 free (wl_data);
5153
5154 fclose (fd);
5155 }
5156
5157 device_param->kernel_accel = 0;
5158 device_param->kernel_loops = 0;
5159
5160 return NULL;
5161 }
5162
5163 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5164 {
5165 if (!device_param)
5166 {
5167 log_error ("ERROR: %s : Invalid argument", __func__);
5168
5169 exit (-1);
5170 }
5171
5172 salt_t *salt_buf = &data.salts_buf[salt_pos];
5173
5174 device_param->kernel_params_buf32[24] = salt_pos;
5175 device_param->kernel_params_buf32[27] = 1;
5176 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
5177 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
5178 device_param->kernel_params_buf32[30] = 0;
5179 device_param->kernel_params_buf32[31] = 1;
5180
5181 char *dictfile_old = data.dictfile;
5182
5183 const char *weak_hash_check = "weak-hash-check";
5184
5185 data.dictfile = (char *) weak_hash_check;
5186
5187 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5188
5189 data.kernel_rules_buf[0].cmds[0] = 0;
5190
5191 /**
5192 * run the kernel
5193 */
5194
5195 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5196 {
5197 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5198 }
5199 else
5200 {
5201 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5202
5203 uint loop_step = 16;
5204
5205 const uint iter = salt_buf->salt_iter;
5206
5207 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5208 {
5209 uint loop_left = iter - loop_pos;
5210
5211 loop_left = MIN (loop_left, loop_step);
5212
5213 device_param->kernel_params_buf32[25] = loop_pos;
5214 device_param->kernel_params_buf32[26] = loop_left;
5215
5216 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5217 }
5218
5219 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5220 }
5221
5222 /**
5223 * result
5224 */
5225
5226 check_cracked (device_param, salt_pos);
5227
5228 /**
5229 * cleanup
5230 */
5231
5232 device_param->kernel_params_buf32[24] = 0;
5233 device_param->kernel_params_buf32[25] = 0;
5234 device_param->kernel_params_buf32[26] = 0;
5235 device_param->kernel_params_buf32[27] = 0;
5236 device_param->kernel_params_buf32[28] = 0;
5237 device_param->kernel_params_buf32[29] = 0;
5238 device_param->kernel_params_buf32[30] = 0;
5239 device_param->kernel_params_buf32[31] = 0;
5240
5241 data.dictfile = dictfile_old;
5242
5243 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5244 }
5245
5246 // hlfmt hashcat
5247
5248 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5249 {
5250 if (data.username == 0)
5251 {
5252 *hashbuf_pos = line_buf;
5253 *hashbuf_len = line_len;
5254 }
5255 else
5256 {
5257 char *pos = line_buf;
5258 int len = line_len;
5259
5260 for (int i = 0; i < line_len; i++, pos++, len--)
5261 {
5262 if (line_buf[i] == data.separator)
5263 {
5264 pos++;
5265
5266 len--;
5267
5268 break;
5269 }
5270 }
5271
5272 *hashbuf_pos = pos;
5273 *hashbuf_len = len;
5274 }
5275 }
5276
5277 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5278 {
5279 char *pos = NULL;
5280 int len = 0;
5281
5282 int sep_cnt = 0;
5283
5284 for (int i = 0; i < line_len; i++)
5285 {
5286 if (line_buf[i] == data.separator)
5287 {
5288 sep_cnt++;
5289
5290 continue;
5291 }
5292
5293 if (sep_cnt == 0)
5294 {
5295 if (pos == NULL) pos = line_buf + i;
5296
5297 len++;
5298 }
5299 }
5300
5301 *userbuf_pos = pos;
5302 *userbuf_len = len;
5303 }
5304
5305 // hlfmt pwdump
5306
5307 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5308 {
5309 int sep_cnt = 0;
5310
5311 int sep2_len = 0;
5312 int sep3_len = 0;
5313
5314 for (int i = 0; i < line_len; i++)
5315 {
5316 if (line_buf[i] == ':')
5317 {
5318 sep_cnt++;
5319
5320 continue;
5321 }
5322
5323 if (sep_cnt == 2) sep2_len++;
5324 if (sep_cnt == 3) sep3_len++;
5325 }
5326
5327 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5328
5329 return 0;
5330 }
5331
5332 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5333 {
5334 char *pos = NULL;
5335 int len = 0;
5336
5337 int sep_cnt = 0;
5338
5339 for (int i = 0; i < line_len; i++)
5340 {
5341 if (line_buf[i] == ':')
5342 {
5343 sep_cnt++;
5344
5345 continue;
5346 }
5347
5348 if (data.hash_mode == 1000)
5349 {
5350 if (sep_cnt == 3)
5351 {
5352 if (pos == NULL) pos = line_buf + i;
5353
5354 len++;
5355 }
5356 }
5357 else if (data.hash_mode == 3000)
5358 {
5359 if (sep_cnt == 2)
5360 {
5361 if (pos == NULL) pos = line_buf + i;
5362
5363 len++;
5364 }
5365 }
5366 }
5367
5368 *hashbuf_pos = pos;
5369 *hashbuf_len = len;
5370 }
5371
5372 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5373 {
5374 char *pos = NULL;
5375 int len = 0;
5376
5377 int sep_cnt = 0;
5378
5379 for (int i = 0; i < line_len; i++)
5380 {
5381 if (line_buf[i] == ':')
5382 {
5383 sep_cnt++;
5384
5385 continue;
5386 }
5387
5388 if (sep_cnt == 0)
5389 {
5390 if (pos == NULL) pos = line_buf + i;
5391
5392 len++;
5393 }
5394 }
5395
5396 *userbuf_pos = pos;
5397 *userbuf_len = len;
5398 }
5399
5400 // hlfmt passwd
5401
5402 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5403 {
5404 int sep_cnt = 0;
5405
5406 char sep5_first = 0;
5407 char sep6_first = 0;
5408
5409 for (int i = 0; i < line_len; i++)
5410 {
5411 if (line_buf[i] == ':')
5412 {
5413 sep_cnt++;
5414
5415 continue;
5416 }
5417
5418 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5419 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5420 }
5421
5422 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5423
5424 return 0;
5425 }
5426
5427 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5428 {
5429 char *pos = NULL;
5430 int len = 0;
5431
5432 int sep_cnt = 0;
5433
5434 for (int i = 0; i < line_len; i++)
5435 {
5436 if (line_buf[i] == ':')
5437 {
5438 sep_cnt++;
5439
5440 continue;
5441 }
5442
5443 if (sep_cnt == 1)
5444 {
5445 if (pos == NULL) pos = line_buf + i;
5446
5447 len++;
5448 }
5449 }
5450
5451 *hashbuf_pos = pos;
5452 *hashbuf_len = len;
5453 }
5454
5455 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5456 {
5457 char *pos = NULL;
5458 int len = 0;
5459
5460 int sep_cnt = 0;
5461
5462 for (int i = 0; i < line_len; i++)
5463 {
5464 if (line_buf[i] == ':')
5465 {
5466 sep_cnt++;
5467
5468 continue;
5469 }
5470
5471 if (sep_cnt == 0)
5472 {
5473 if (pos == NULL) pos = line_buf + i;
5474
5475 len++;
5476 }
5477 }
5478
5479 *userbuf_pos = pos;
5480 *userbuf_len = len;
5481 }
5482
5483 // hlfmt shadow
5484
5485 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5486 {
5487 int sep_cnt = 0;
5488
5489 for (int i = 0; i < line_len; i++)
5490 {
5491 if (line_buf[i] == ':') sep_cnt++;
5492 }
5493
5494 if (sep_cnt == 8) return 1;
5495
5496 return 0;
5497 }
5498
5499 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5500 {
5501 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5502 }
5503
5504 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5505 {
5506 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5507 }
5508
5509 // hlfmt main
5510
5511 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5512 {
5513 switch (hashfile_format)
5514 {
5515 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5516 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5517 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5518 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5519 }
5520 }
5521
5522 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5523 {
5524 switch (hashfile_format)
5525 {
5526 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5527 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5528 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5529 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5530 }
5531 }
5532
5533 char *strhlfmt (const uint hashfile_format)
5534 {
5535 switch (hashfile_format)
5536 {
5537 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5538 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5539 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5540 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5541 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5542 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5543 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5544 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5545 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5546 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5547 }
5548
5549 return ((char *) "Unknown");
5550 }
5551
5552 static uint hlfmt_detect (FILE *fp, uint max_check)
5553 {
5554 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5555
5556 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5557 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5558
5559 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5560
5561 uint num_check = 0;
5562
5563 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5564
5565 while (!feof (fp))
5566 {
5567 int line_len = fgetl (fp, line_buf);
5568
5569 if (line_len == 0) continue;
5570
5571 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5572 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5573 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5574
5575 if (num_check == max_check) break;
5576
5577 num_check++;
5578 }
5579
5580 myfree (line_buf);
5581
5582 uint hashlist_format = HLFMT_HASHCAT;
5583
5584 for (int i = 1; i < HLFMTS_CNT; i++)
5585 {
5586 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5587
5588 hashlist_format = i;
5589 }
5590
5591 free (formats_cnt);
5592
5593 return hashlist_format;
5594 }
5595
5596 /**
5597 * some further helper function
5598 */
5599
5600 // wrapper around mymalloc for ADL
5601
5602 #if defined(HAVE_HWMON)
5603 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5604 {
5605 return mymalloc (iSize);
5606 }
5607 #endif
5608
5609 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)
5610 {
5611 u64 collisions = 0;
5612
5613 const uint dgst_pos0 = data.dgst_pos0;
5614 const uint dgst_pos1 = data.dgst_pos1;
5615 const uint dgst_pos2 = data.dgst_pos2;
5616 const uint dgst_pos3 = data.dgst_pos3;
5617
5618 memset (bitmap_a, 0, bitmap_size);
5619 memset (bitmap_b, 0, bitmap_size);
5620 memset (bitmap_c, 0, bitmap_size);
5621 memset (bitmap_d, 0, bitmap_size);
5622
5623 for (uint i = 0; i < digests_cnt; i++)
5624 {
5625 uint *digest_ptr = (uint *) digests_buf_ptr;
5626
5627 digests_buf_ptr += dgst_size;
5628
5629 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5630 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5631 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5632 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5633
5634 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5635 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5636 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5637 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5638
5639 if (bitmap_a[idx0] & val0) collisions++;
5640 if (bitmap_b[idx1] & val1) collisions++;
5641 if (bitmap_c[idx2] & val2) collisions++;
5642 if (bitmap_d[idx3] & val3) collisions++;
5643
5644 bitmap_a[idx0] |= val0;
5645 bitmap_b[idx1] |= val1;
5646 bitmap_c[idx2] |= val2;
5647 bitmap_d[idx3] |= val3;
5648
5649 if (collisions >= collisions_max) return 0x7fffffff;
5650 }
5651
5652 return collisions;
5653 }
5654
5655 /**
5656 * main
5657 */
5658
5659 #ifdef WIN
5660 void SetConsoleWindowSize (const int x)
5661 {
5662 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5663
5664 if (h == INVALID_HANDLE_VALUE) return;
5665
5666 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5667
5668 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5669
5670 SMALL_RECT *sr = &bufferInfo.srWindow;
5671
5672 sr->Right = MAX (sr->Right, x - 1);
5673
5674 COORD co;
5675
5676 co.X = sr->Right + 1;
5677 co.Y = 9999;
5678
5679 if (!SetConsoleScreenBufferSize (h, co)) return;
5680
5681 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5682 }
5683 #endif
5684
5685 int main (int argc, char **argv)
5686 {
5687 #ifdef WIN
5688 SetConsoleWindowSize (132);
5689 #endif
5690
5691 /**
5692 * To help users a bit
5693 */
5694
5695 char *compute = getenv ("COMPUTE");
5696
5697 if (compute)
5698 {
5699 static char display[100];
5700
5701 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5702
5703 putenv (display);
5704 }
5705 else
5706 {
5707 if (getenv ("DISPLAY") == NULL)
5708 putenv ((char *) "DISPLAY=:0");
5709 }
5710
5711 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5712 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5713
5714 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5715 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5716
5717 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5718 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5719
5720 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5721 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5722
5723 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5724 putenv ((char *) "POCL_KERNEL_CACHE=0");
5725
5726 umask (077);
5727
5728 /**
5729 * Real init
5730 */
5731
5732 memset (&data, 0, sizeof (hc_global_data_t));
5733
5734 time_t proc_start;
5735
5736 time (&proc_start);
5737
5738 data.proc_start = proc_start;
5739
5740 int myargc = argc;
5741 char **myargv = argv;
5742
5743 hc_thread_mutex_init (mux_dispatcher);
5744 hc_thread_mutex_init (mux_counter);
5745 hc_thread_mutex_init (mux_display);
5746 hc_thread_mutex_init (mux_adl);
5747
5748 /**
5749 * commandline parameters
5750 */
5751
5752 uint usage = USAGE;
5753 uint version = VERSION;
5754 uint quiet = QUIET;
5755 uint benchmark = BENCHMARK;
5756 uint stdout_flag = STDOUT_FLAG;
5757 uint show = SHOW;
5758 uint left = LEFT;
5759 uint username = USERNAME;
5760 uint remove = REMOVE;
5761 uint remove_timer = REMOVE_TIMER;
5762 u64 skip = SKIP;
5763 u64 limit = LIMIT;
5764 uint keyspace = KEYSPACE;
5765 uint potfile_disable = POTFILE_DISABLE;
5766 char *potfile_path = NULL;
5767 uint debug_mode = DEBUG_MODE;
5768 char *debug_file = NULL;
5769 char *induction_dir = NULL;
5770 char *outfile_check_dir = NULL;
5771 uint force = FORCE;
5772 uint runtime = RUNTIME;
5773 uint hash_mode = HASH_MODE;
5774 uint attack_mode = ATTACK_MODE;
5775 uint markov_disable = MARKOV_DISABLE;
5776 uint markov_classic = MARKOV_CLASSIC;
5777 uint markov_threshold = MARKOV_THRESHOLD;
5778 char *markov_hcstat = NULL;
5779 char *outfile = NULL;
5780 uint outfile_format = OUTFILE_FORMAT;
5781 uint outfile_autohex = OUTFILE_AUTOHEX;
5782 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5783 uint restore = RESTORE;
5784 uint restore_timer = RESTORE_TIMER;
5785 uint restore_disable = RESTORE_DISABLE;
5786 uint status = STATUS;
5787 uint status_timer = STATUS_TIMER;
5788 uint machine_readable = MACHINE_READABLE;
5789 uint loopback = LOOPBACK;
5790 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5791 char *session = NULL;
5792 uint hex_charset = HEX_CHARSET;
5793 uint hex_salt = HEX_SALT;
5794 uint hex_wordlist = HEX_WORDLIST;
5795 uint rp_gen = RP_GEN;
5796 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5797 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5798 uint rp_gen_seed = RP_GEN_SEED;
5799 char *rule_buf_l = (char *) RULE_BUF_L;
5800 char *rule_buf_r = (char *) RULE_BUF_R;
5801 uint increment = INCREMENT;
5802 uint increment_min = INCREMENT_MIN;
5803 uint increment_max = INCREMENT_MAX;
5804 char *cpu_affinity = NULL;
5805 OCL_PTR *ocl = NULL;
5806 char *opencl_devices = NULL;
5807 char *opencl_platforms = NULL;
5808 char *opencl_device_types = NULL;
5809 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5810 char *truecrypt_keyfiles = NULL;
5811 char *veracrypt_keyfiles = NULL;
5812 uint veracrypt_pim = 0;
5813 uint workload_profile = WORKLOAD_PROFILE;
5814 uint kernel_accel = KERNEL_ACCEL;
5815 uint kernel_loops = KERNEL_LOOPS;
5816 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
5817 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5818 #ifdef HAVE_HWMON
5819 uint gpu_temp_abort = GPU_TEMP_ABORT;
5820 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5821 uint powertune_enable = POWERTUNE_ENABLE;
5822 #endif
5823 uint logfile_disable = LOGFILE_DISABLE;
5824 uint segment_size = SEGMENT_SIZE;
5825 uint scrypt_tmto = SCRYPT_TMTO;
5826 char separator = SEPARATOR;
5827 uint bitmap_min = BITMAP_MIN;
5828 uint bitmap_max = BITMAP_MAX;
5829 char *custom_charset_1 = NULL;
5830 char *custom_charset_2 = NULL;
5831 char *custom_charset_3 = NULL;
5832 char *custom_charset_4 = NULL;
5833
5834 #define IDX_HELP 'h'
5835 #define IDX_VERSION 'V'
5836 #define IDX_VERSION_LOWER 'v'
5837 #define IDX_QUIET 0xff02
5838 #define IDX_SHOW 0xff03
5839 #define IDX_LEFT 0xff04
5840 #define IDX_REMOVE 0xff05
5841 #define IDX_REMOVE_TIMER 0xff37
5842 #define IDX_SKIP 's'
5843 #define IDX_LIMIT 'l'
5844 #define IDX_KEYSPACE 0xff35
5845 #define IDX_POTFILE_DISABLE 0xff06
5846 #define IDX_POTFILE_PATH 0xffe0
5847 #define IDX_DEBUG_MODE 0xff43
5848 #define IDX_DEBUG_FILE 0xff44
5849 #define IDX_INDUCTION_DIR 0xff46
5850 #define IDX_OUTFILE_CHECK_DIR 0xff47
5851 #define IDX_USERNAME 0xff07
5852 #define IDX_FORCE 0xff08
5853 #define IDX_RUNTIME 0xff09
5854 #define IDX_BENCHMARK 'b'
5855 #define IDX_STDOUT_FLAG 0xff77
5856 #define IDX_HASH_MODE 'm'
5857 #define IDX_ATTACK_MODE 'a'
5858 #define IDX_RP_FILE 'r'
5859 #define IDX_RP_GEN 'g'
5860 #define IDX_RP_GEN_FUNC_MIN 0xff10
5861 #define IDX_RP_GEN_FUNC_MAX 0xff11
5862 #define IDX_RP_GEN_SEED 0xff34
5863 #define IDX_RULE_BUF_L 'j'
5864 #define IDX_RULE_BUF_R 'k'
5865 #define IDX_INCREMENT 'i'
5866 #define IDX_INCREMENT_MIN 0xff12
5867 #define IDX_INCREMENT_MAX 0xff13
5868 #define IDX_OUTFILE 'o'
5869 #define IDX_OUTFILE_FORMAT 0xff14
5870 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5871 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5872 #define IDX_RESTORE 0xff15
5873 #define IDX_RESTORE_DISABLE 0xff27
5874 #define IDX_STATUS 0xff17
5875 #define IDX_STATUS_TIMER 0xff18
5876 #define IDX_MACHINE_READABLE 0xff50
5877 #define IDX_LOOPBACK 0xff38
5878 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5879 #define IDX_SESSION 0xff19
5880 #define IDX_HEX_CHARSET 0xff20
5881 #define IDX_HEX_SALT 0xff21
5882 #define IDX_HEX_WORDLIST 0xff40
5883 #define IDX_MARKOV_DISABLE 0xff22
5884 #define IDX_MARKOV_CLASSIC 0xff23
5885 #define IDX_MARKOV_THRESHOLD 't'
5886 #define IDX_MARKOV_HCSTAT 0xff24
5887 #define IDX_CPU_AFFINITY 0xff25
5888 #define IDX_OPENCL_DEVICES 'd'
5889 #define IDX_OPENCL_PLATFORMS 0xff72
5890 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5891 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5892 #define IDX_WORKLOAD_PROFILE 'w'
5893 #define IDX_KERNEL_ACCEL 'n'
5894 #define IDX_KERNEL_LOOPS 'u'
5895 #define IDX_NVIDIA_SPIN_DAMP 0xff79
5896 #define IDX_GPU_TEMP_DISABLE 0xff29
5897 #define IDX_GPU_TEMP_ABORT 0xff30
5898 #define IDX_GPU_TEMP_RETAIN 0xff31
5899 #define IDX_POWERTUNE_ENABLE 0xff41
5900 #define IDX_LOGFILE_DISABLE 0xff51
5901 #define IDX_TRUECRYPT_KEYFILES 0xff52
5902 #define IDX_VERACRYPT_KEYFILES 0xff53
5903 #define IDX_VERACRYPT_PIM 0xff54
5904 #define IDX_SCRYPT_TMTO 0xff61
5905 #define IDX_SEGMENT_SIZE 'c'
5906 #define IDX_SEPARATOR 'p'
5907 #define IDX_BITMAP_MIN 0xff70
5908 #define IDX_BITMAP_MAX 0xff71
5909 #define IDX_CUSTOM_CHARSET_1 '1'
5910 #define IDX_CUSTOM_CHARSET_2 '2'
5911 #define IDX_CUSTOM_CHARSET_3 '3'
5912 #define IDX_CUSTOM_CHARSET_4 '4'
5913
5914 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5915
5916 struct option long_options[] =
5917 {
5918 {"help", no_argument, 0, IDX_HELP},
5919 {"version", no_argument, 0, IDX_VERSION},
5920 {"quiet", no_argument, 0, IDX_QUIET},
5921 {"show", no_argument, 0, IDX_SHOW},
5922 {"left", no_argument, 0, IDX_LEFT},
5923 {"username", no_argument, 0, IDX_USERNAME},
5924 {"remove", no_argument, 0, IDX_REMOVE},
5925 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5926 {"skip", required_argument, 0, IDX_SKIP},
5927 {"limit", required_argument, 0, IDX_LIMIT},
5928 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5929 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5930 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5931 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5932 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5933 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5934 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5935 {"force", no_argument, 0, IDX_FORCE},
5936 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5937 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
5938 {"restore", no_argument, 0, IDX_RESTORE},
5939 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5940 {"status", no_argument, 0, IDX_STATUS},
5941 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5942 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5943 {"loopback", no_argument, 0, IDX_LOOPBACK},
5944 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5945 {"session", required_argument, 0, IDX_SESSION},
5946 {"runtime", required_argument, 0, IDX_RUNTIME},
5947 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5948 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5949 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5950 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5951 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5952 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5953 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5954 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5955 {"rules-file", required_argument, 0, IDX_RP_FILE},
5956 {"outfile", required_argument, 0, IDX_OUTFILE},
5957 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5958 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5959 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5960 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5961 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5962 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5963 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5964 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5965 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5966 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5967 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5968 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5969 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5970 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5971 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5972 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5973 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5974 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5975 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
5976 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5977 #ifdef HAVE_HWMON
5978 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5979 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5980 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5981 #endif // HAVE_HWMON
5982 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5983 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5984 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5985 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5986 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5987 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5988 {"seperator", required_argument, 0, IDX_SEPARATOR},
5989 {"separator", required_argument, 0, IDX_SEPARATOR},
5990 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5991 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5992 {"increment", no_argument, 0, IDX_INCREMENT},
5993 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5994 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5995 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5996 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5997 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5998 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5999 {0, 0, 0, 0}
6000 };
6001
6002 uint rp_files_cnt = 0;
6003
6004 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6005
6006 int option_index = 0;
6007 int c = -1;
6008
6009 optind = 1;
6010 optopt = 0;
6011
6012 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6013 {
6014 switch (c)
6015 {
6016 case IDX_HELP: usage = 1; break;
6017 case IDX_VERSION:
6018 case IDX_VERSION_LOWER: version = 1; break;
6019 case IDX_RESTORE: restore = 1; break;
6020 case IDX_SESSION: session = optarg; break;
6021 case IDX_SHOW: show = 1; break;
6022 case IDX_LEFT: left = 1; break;
6023 case '?': return (-1);
6024 }
6025 }
6026
6027 if (optopt != 0)
6028 {
6029 log_error ("ERROR: Invalid argument specified");
6030
6031 return (-1);
6032 }
6033
6034 /**
6035 * exit functions
6036 */
6037
6038 if (version)
6039 {
6040 log_info ("%s", VERSION_TAG);
6041
6042 return (0);
6043 }
6044
6045 if (usage)
6046 {
6047 usage_big_print (PROGNAME);
6048
6049 return (0);
6050 }
6051
6052 /**
6053 * session needs to be set, always!
6054 */
6055
6056 if (session == NULL) session = (char *) PROGNAME;
6057
6058 /**
6059 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6060 */
6061
6062 char *exec_path = get_exec_path ();
6063
6064 #ifdef LINUX
6065
6066 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6067 char *resolved_exec_path = realpath (exec_path, NULL);
6068
6069 char *install_dir = get_install_dir (resolved_exec_path);
6070 char *profile_dir = NULL;
6071 char *session_dir = NULL;
6072 char *shared_dir = NULL;
6073
6074 if (strcmp (install_dir, resolved_install_folder) == 0)
6075 {
6076 struct passwd *pw = getpwuid (getuid ());
6077
6078 const char *homedir = pw->pw_dir;
6079
6080 profile_dir = get_profile_dir (homedir);
6081 session_dir = get_session_dir (profile_dir);
6082 shared_dir = strdup (SHARED_FOLDER);
6083
6084 mkdir (profile_dir, 0700);
6085 mkdir (session_dir, 0700);
6086 }
6087 else
6088 {
6089 profile_dir = install_dir;
6090 session_dir = install_dir;
6091 shared_dir = install_dir;
6092 }
6093
6094 myfree (resolved_install_folder);
6095 myfree (resolved_exec_path);
6096
6097 #else
6098
6099 char *install_dir = get_install_dir (exec_path);
6100 char *profile_dir = install_dir;
6101 char *session_dir = install_dir;
6102 char *shared_dir = install_dir;
6103
6104 #endif
6105
6106 data.install_dir = install_dir;
6107 data.profile_dir = profile_dir;
6108 data.session_dir = session_dir;
6109 data.shared_dir = shared_dir;
6110
6111 myfree (exec_path);
6112
6113 /**
6114 * kernel cache, we need to make sure folder exist
6115 */
6116
6117 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6118
6119 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6120
6121 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6122
6123 mkdir (kernels_folder, 0700);
6124
6125 myfree (kernels_folder);
6126
6127 /**
6128 * session
6129 */
6130
6131 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6132
6133 data.session = session;
6134
6135 char *eff_restore_file = (char *) mymalloc (session_size);
6136 char *new_restore_file = (char *) mymalloc (session_size);
6137
6138 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6139 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6140
6141 data.eff_restore_file = eff_restore_file;
6142 data.new_restore_file = new_restore_file;
6143
6144 if (((show == 1) || (left == 1)) && (restore == 1))
6145 {
6146 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6147 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6148
6149 return (-1);
6150 }
6151
6152 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6153 if ((show == 1) || (left == 1))
6154 {
6155 restore_disable = 1;
6156
6157 restore = 0;
6158 }
6159
6160 data.restore_disable = restore_disable;
6161
6162 restore_data_t *rd = init_restore (argc, argv);
6163
6164 data.rd = rd;
6165
6166 /**
6167 * restore file
6168 */
6169
6170 if (restore == 1)
6171 {
6172 read_restore (eff_restore_file, rd);
6173
6174 if (rd->version_bin < RESTORE_MIN)
6175 {
6176 log_error ("ERROR: Incompatible restore-file version");
6177
6178 return (-1);
6179 }
6180
6181 myargc = rd->argc;
6182 myargv = rd->argv;
6183
6184 #ifdef _POSIX
6185 rd->pid = getpid ();
6186 #elif _WIN
6187 rd->pid = GetCurrentProcessId ();
6188 #endif
6189 }
6190
6191 uint hash_mode_chgd = 0;
6192 uint runtime_chgd = 0;
6193 uint kernel_loops_chgd = 0;
6194 uint kernel_accel_chgd = 0;
6195 uint nvidia_spin_damp_chgd = 0;
6196 uint attack_mode_chgd = 0;
6197 uint outfile_format_chgd = 0;
6198 uint rp_gen_seed_chgd = 0;
6199 uint remove_timer_chgd = 0;
6200 uint increment_min_chgd = 0;
6201 uint increment_max_chgd = 0;
6202 uint workload_profile_chgd = 0;
6203 uint opencl_vector_width_chgd = 0;
6204
6205 optind = 1;
6206 optopt = 0;
6207 option_index = 0;
6208
6209 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6210 {
6211 switch (c)
6212 {
6213 //case IDX_HELP: usage = 1; break;
6214 //case IDX_VERSION: version = 1; break;
6215 //case IDX_RESTORE: restore = 1; break;
6216 case IDX_QUIET: quiet = 1; break;
6217 //case IDX_SHOW: show = 1; break;
6218 case IDX_SHOW: break;
6219 //case IDX_LEFT: left = 1; break;
6220 case IDX_LEFT: break;
6221 case IDX_USERNAME: username = 1; break;
6222 case IDX_REMOVE: remove = 1; break;
6223 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6224 remove_timer_chgd = 1; break;
6225 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6226 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6227 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6228 case IDX_DEBUG_FILE: debug_file = optarg; break;
6229 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6230 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6231 case IDX_FORCE: force = 1; break;
6232 case IDX_SKIP: skip = atoll (optarg); break;
6233 case IDX_LIMIT: limit = atoll (optarg); break;
6234 case IDX_KEYSPACE: keyspace = 1; break;
6235 case IDX_BENCHMARK: benchmark = 1; break;
6236 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6237 case IDX_RESTORE: break;
6238 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6239 case IDX_STATUS: status = 1; break;
6240 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6241 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6242 case IDX_LOOPBACK: loopback = 1; break;
6243 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6244 //case IDX_SESSION: session = optarg; break;
6245 case IDX_SESSION: break;
6246 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6247 hash_mode_chgd = 1; break;
6248 case IDX_RUNTIME: runtime = atoi (optarg);
6249 runtime_chgd = 1; break;
6250 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6251 attack_mode_chgd = 1; break;
6252 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6253 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6254 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6255 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6256 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6257 rp_gen_seed_chgd = 1; break;
6258 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6259 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6260 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6261 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6262 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6263 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6264 case IDX_OUTFILE: outfile = optarg; break;
6265 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6266 outfile_format_chgd = 1; break;
6267 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6268 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6269 case IDX_HEX_CHARSET: hex_charset = 1; break;
6270 case IDX_HEX_SALT: hex_salt = 1; break;
6271 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6272 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6273 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6274 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6275 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6276 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6277 opencl_vector_width_chgd = 1; break;
6278 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6279 workload_profile_chgd = 1; break;
6280 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6281 kernel_accel_chgd = 1; break;
6282 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6283 kernel_loops_chgd = 1; break;
6284 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6285 nvidia_spin_damp_chgd = 1; break;
6286 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6287 #ifdef HAVE_HWMON
6288 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6289 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6290 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6291 #endif // HAVE_HWMON
6292 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6293 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6294 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6295 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6296 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6297 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6298 case IDX_SEPARATOR: separator = optarg[0]; break;
6299 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6300 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6301 case IDX_INCREMENT: increment = 1; break;
6302 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6303 increment_min_chgd = 1; break;
6304 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6305 increment_max_chgd = 1; break;
6306 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6307 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6308 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6309 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6310
6311 default:
6312 log_error ("ERROR: Invalid argument specified");
6313 return (-1);
6314 }
6315 }
6316
6317 if (optopt != 0)
6318 {
6319 log_error ("ERROR: Invalid argument specified");
6320
6321 return (-1);
6322 }
6323
6324 /**
6325 * Inform user things getting started,
6326 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6327 * - we do not need to check algorithm_pos
6328 */
6329
6330 if (quiet == 0)
6331 {
6332 if (benchmark == 1)
6333 {
6334 if (machine_readable == 0)
6335 {
6336 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6337 log_info ("");
6338 log_info ("Note: Reported benchmark cracking speed = real cracking speed");
6339 log_info ("To verify, run hashcat like this: only_one_hash.txt -a 3 -w 3 ?b?b?b?b?b?b?b");
6340 log_info ("");
6341 }
6342 else
6343 {
6344 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6345 }
6346 }
6347 else if (restore == 1)
6348 {
6349 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6350 log_info ("");
6351 }
6352 else if (stdout_flag == 1)
6353 {
6354 // do nothing
6355 }
6356 else
6357 {
6358 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6359 log_info ("");
6360 }
6361 }
6362
6363 /**
6364 * sanity check
6365 */
6366
6367 if (attack_mode > 7)
6368 {
6369 log_error ("ERROR: Invalid attack-mode specified");
6370
6371 return (-1);
6372 }
6373
6374 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6375 {
6376 log_error ("ERROR: Invalid runtime specified");
6377
6378 return (-1);
6379 }
6380
6381 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6382 {
6383 log_error ("ERROR: Invalid hash-type specified");
6384
6385 return (-1);
6386 }
6387
6388 // renamed hash modes
6389
6390 if (hash_mode_chgd)
6391 {
6392 int n = -1;
6393
6394 switch (hash_mode)
6395 {
6396 case 123: n = 124;
6397 break;
6398 }
6399
6400 if (n >= 0)
6401 {
6402 log_error ("Old -m specified, use -m %d instead", n);
6403
6404 return (-1);
6405 }
6406 }
6407
6408 if (username == 1)
6409 {
6410 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6411 {
6412 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6413
6414 return (-1);
6415 }
6416 }
6417
6418 if (outfile_format > 16)
6419 {
6420 log_error ("ERROR: Invalid outfile-format specified");
6421
6422 return (-1);
6423 }
6424
6425 if (left == 1)
6426 {
6427 if (outfile_format_chgd == 1)
6428 {
6429 if (outfile_format > 1)
6430 {
6431 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6432
6433 return (-1);
6434 }
6435 }
6436 else
6437 {
6438 outfile_format = OUTFILE_FMT_HASH;
6439 }
6440 }
6441
6442 if (show == 1)
6443 {
6444 if (outfile_format_chgd == 1)
6445 {
6446 if ((outfile_format > 7) && (outfile_format < 16))
6447 {
6448 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6449
6450 return (-1);
6451 }
6452 }
6453 }
6454
6455 if (increment_min < INCREMENT_MIN)
6456 {
6457 log_error ("ERROR: Invalid increment-min specified");
6458
6459 return (-1);
6460 }
6461
6462 if (increment_max > INCREMENT_MAX)
6463 {
6464 log_error ("ERROR: Invalid increment-max specified");
6465
6466 return (-1);
6467 }
6468
6469 if (increment_min > increment_max)
6470 {
6471 log_error ("ERROR: Invalid increment-min specified");
6472
6473 return (-1);
6474 }
6475
6476 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6477 {
6478 log_error ("ERROR: increment is not allowed in attack-mode 0");
6479
6480 return (-1);
6481 }
6482
6483 if ((increment == 0) && (increment_min_chgd == 1))
6484 {
6485 log_error ("ERROR: increment-min is only supported together with increment switch");
6486
6487 return (-1);
6488 }
6489
6490 if ((increment == 0) && (increment_max_chgd == 1))
6491 {
6492 log_error ("ERROR: increment-max is only supported together with increment switch");
6493
6494 return (-1);
6495 }
6496
6497 if (rp_files_cnt && rp_gen)
6498 {
6499 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6500
6501 return (-1);
6502 }
6503
6504 if (rp_files_cnt || rp_gen)
6505 {
6506 if (attack_mode != ATTACK_MODE_STRAIGHT)
6507 {
6508 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6509
6510 return (-1);
6511 }
6512 }
6513
6514 if (rp_gen_func_min > rp_gen_func_max)
6515 {
6516 log_error ("ERROR: Invalid rp-gen-func-min specified");
6517
6518 return (-1);
6519 }
6520
6521 if (kernel_accel_chgd == 1)
6522 {
6523 if (force == 0)
6524 {
6525 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6526 log_info ("Please consider using the option -w instead");
6527 log_info ("You can use --force to override this but do not post error reports if you do so");
6528 log_info ("");
6529
6530 return (-1);
6531 }
6532
6533 if (kernel_accel < 1)
6534 {
6535 log_error ("ERROR: Invalid kernel-accel specified");
6536
6537 return (-1);
6538 }
6539
6540 if (kernel_accel > 1024)
6541 {
6542 log_error ("ERROR: Invalid kernel-accel specified");
6543
6544 return (-1);
6545 }
6546 }
6547
6548 if (kernel_loops_chgd == 1)
6549 {
6550 if (force == 0)
6551 {
6552 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6553 log_info ("Please consider using the option -w instead");
6554 log_info ("You can use --force to override this but do not post error reports if you do so");
6555 log_info ("");
6556
6557 return (-1);
6558 }
6559
6560 if (kernel_loops < 1)
6561 {
6562 log_error ("ERROR: Invalid kernel-loops specified");
6563
6564 return (-1);
6565 }
6566
6567 if (kernel_loops > 1024)
6568 {
6569 log_error ("ERROR: Invalid kernel-loops specified");
6570
6571 return (-1);
6572 }
6573 }
6574
6575 if ((workload_profile < 1) || (workload_profile > 4))
6576 {
6577 log_error ("ERROR: workload-profile %i not available", workload_profile);
6578
6579 return (-1);
6580 }
6581
6582 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6583 {
6584 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6585
6586 return (-1);
6587 }
6588
6589 if (show == 1 || left == 1)
6590 {
6591 attack_mode = ATTACK_MODE_NONE;
6592
6593 if (remove == 1)
6594 {
6595 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6596
6597 return (-1);
6598 }
6599
6600 if (potfile_disable == 1)
6601 {
6602 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6603
6604 return (-1);
6605 }
6606 }
6607
6608 uint attack_kern = ATTACK_KERN_NONE;
6609
6610 switch (attack_mode)
6611 {
6612 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6613 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6614 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6615 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6616 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6617 }
6618
6619 if (benchmark == 1)
6620 {
6621 if (myargv[optind] != 0)
6622 {
6623 log_error ("ERROR: Invalid argument for benchmark mode specified");
6624
6625 return (-1);
6626 }
6627
6628 if (attack_mode_chgd == 1)
6629 {
6630 if (attack_mode != ATTACK_MODE_BF)
6631 {
6632 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6633
6634 return (-1);
6635 }
6636 }
6637 }
6638 else
6639 {
6640 if (stdout_flag == 1) // no hash here
6641 {
6642 optind--;
6643 }
6644
6645 if (keyspace == 1)
6646 {
6647 int num_additional_params = 1;
6648
6649 if (attack_kern == ATTACK_KERN_COMBI)
6650 {
6651 num_additional_params = 2;
6652 }
6653
6654 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6655
6656 if (keyspace_wordlist_specified == 0) optind--;
6657 }
6658
6659 if (attack_kern == ATTACK_KERN_NONE)
6660 {
6661 if ((optind + 1) != myargc)
6662 {
6663 usage_mini_print (myargv[0]);
6664
6665 return (-1);
6666 }
6667 }
6668 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6669 {
6670 if ((optind + 1) > myargc)
6671 {
6672 usage_mini_print (myargv[0]);
6673
6674 return (-1);
6675 }
6676 }
6677 else if (attack_kern == ATTACK_KERN_COMBI)
6678 {
6679 if ((optind + 3) != myargc)
6680 {
6681 usage_mini_print (myargv[0]);
6682
6683 return (-1);
6684 }
6685 }
6686 else if (attack_kern == ATTACK_KERN_BF)
6687 {
6688 if ((optind + 1) > myargc)
6689 {
6690 usage_mini_print (myargv[0]);
6691
6692 return (-1);
6693 }
6694 }
6695 else
6696 {
6697 usage_mini_print (myargv[0]);
6698
6699 return (-1);
6700 }
6701 }
6702
6703 if (skip != 0 && limit != 0)
6704 {
6705 limit += skip;
6706 }
6707
6708 if (keyspace == 1)
6709 {
6710 if (show == 1)
6711 {
6712 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6713
6714 return (-1);
6715 }
6716 else if (left == 1)
6717 {
6718 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6719
6720 return (-1);
6721 }
6722
6723 potfile_disable = 1;
6724
6725 restore_disable = 1;
6726
6727 restore = 0;
6728
6729 weak_hash_threshold = 0;
6730
6731 quiet = 1;
6732 }
6733
6734 if (stdout_flag == 1)
6735 {
6736 status_timer = 0;
6737 restore_timer = 0;
6738 restore_disable = 1;
6739 restore = 0;
6740 potfile_disable = 1;
6741 weak_hash_threshold = 0;
6742 gpu_temp_disable = 1;
6743 hash_mode = 2000;
6744 quiet = 1;
6745 outfile_format = OUTFILE_FMT_PLAIN;
6746 kernel_accel = 1024;
6747 kernel_loops = 1024;
6748 force = 1;
6749 outfile_check_timer = 0;
6750 }
6751
6752 if (remove_timer_chgd == 1)
6753 {
6754 if (remove == 0)
6755 {
6756 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6757
6758 return (-1);
6759 }
6760
6761 if (remove_timer < 1)
6762 {
6763 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6764
6765 return (-1);
6766 }
6767 }
6768
6769 if (loopback == 1)
6770 {
6771 if (attack_mode == ATTACK_MODE_STRAIGHT)
6772 {
6773 if ((rp_files_cnt == 0) && (rp_gen == 0))
6774 {
6775 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6776
6777 return (-1);
6778 }
6779 }
6780 else
6781 {
6782 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6783
6784 return (-1);
6785 }
6786 }
6787
6788 if (debug_mode > 0)
6789 {
6790 if (attack_mode != ATTACK_MODE_STRAIGHT)
6791 {
6792 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6793
6794 return (-1);
6795 }
6796
6797 if ((rp_files_cnt == 0) && (rp_gen == 0))
6798 {
6799 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6800
6801 return (-1);
6802 }
6803 }
6804
6805 if (debug_mode > 4)
6806 {
6807 log_error ("ERROR: Invalid debug-mode specified");
6808
6809 return (-1);
6810 }
6811
6812 if (debug_file != NULL)
6813 {
6814 if (debug_mode < 1)
6815 {
6816 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6817
6818 return (-1);
6819 }
6820 }
6821
6822 if (induction_dir != NULL)
6823 {
6824 if (attack_mode == ATTACK_MODE_BF)
6825 {
6826 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6827
6828 return (-1);
6829 }
6830 }
6831
6832 if (attack_mode != ATTACK_MODE_STRAIGHT)
6833 {
6834 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6835 {
6836 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6837
6838 return (-1);
6839 }
6840
6841 weak_hash_threshold = 0;
6842 }
6843
6844 if (nvidia_spin_damp > 100)
6845 {
6846 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6847
6848 return (-1);
6849 }
6850
6851
6852 /**
6853 * induction directory
6854 */
6855
6856 char *induction_directory = NULL;
6857
6858 if (attack_mode != ATTACK_MODE_BF)
6859 {
6860 if (induction_dir == NULL)
6861 {
6862 induction_directory = (char *) mymalloc (session_size);
6863
6864 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6865
6866 // create induction folder if it does not already exist
6867
6868 if (keyspace == 0)
6869 {
6870 if (rmdir (induction_directory) == -1)
6871 {
6872 if (errno == ENOENT)
6873 {
6874 // good, we can ignore
6875 }
6876 else if (errno == ENOTEMPTY)
6877 {
6878 char *induction_directory_mv = (char *) mymalloc (session_size);
6879
6880 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6881
6882 if (rename (induction_directory, induction_directory_mv) != 0)
6883 {
6884 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6885
6886 return (-1);
6887 }
6888 }
6889 else
6890 {
6891 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6892
6893 return (-1);
6894 }
6895 }
6896
6897 if (mkdir (induction_directory, 0700) == -1)
6898 {
6899 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6900
6901 return (-1);
6902 }
6903 }
6904 }
6905 else
6906 {
6907 induction_directory = induction_dir;
6908 }
6909 }
6910
6911 data.induction_directory = induction_directory;
6912
6913 /**
6914 * loopback
6915 */
6916
6917 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6918
6919 char *loopback_file = (char *) mymalloc (loopback_size);
6920
6921 /**
6922 * tuning db
6923 */
6924
6925 char tuning_db_file[256] = { 0 };
6926
6927 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6928
6929 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6930
6931 /**
6932 * outfile-check directory
6933 */
6934
6935 char *outfile_check_directory = NULL;
6936
6937 if (outfile_check_dir == NULL)
6938 {
6939 outfile_check_directory = (char *) mymalloc (session_size);
6940
6941 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6942 }
6943 else
6944 {
6945 outfile_check_directory = outfile_check_dir;
6946 }
6947
6948 data.outfile_check_directory = outfile_check_directory;
6949
6950 if (keyspace == 0)
6951 {
6952 struct stat outfile_check_stat;
6953
6954 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6955 {
6956 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6957
6958 if (is_dir == 0)
6959 {
6960 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6961
6962 return (-1);
6963 }
6964 }
6965 else if (outfile_check_dir == NULL)
6966 {
6967 if (mkdir (outfile_check_directory, 0700) == -1)
6968 {
6969 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6970
6971 return (-1);
6972 }
6973 }
6974 }
6975
6976 /**
6977 * special other stuff
6978 */
6979
6980 if (hash_mode == 9710)
6981 {
6982 outfile_format = 5;
6983 outfile_format_chgd = 1;
6984 }
6985
6986 if (hash_mode == 9810)
6987 {
6988 outfile_format = 5;
6989 outfile_format_chgd = 1;
6990 }
6991
6992 if (hash_mode == 10410)
6993 {
6994 outfile_format = 5;
6995 outfile_format_chgd = 1;
6996 }
6997
6998 /**
6999 * store stuff
7000 */
7001
7002 data.hash_mode = hash_mode;
7003 data.restore = restore;
7004 data.restore_timer = restore_timer;
7005 data.restore_disable = restore_disable;
7006 data.status = status;
7007 data.status_timer = status_timer;
7008 data.machine_readable = machine_readable;
7009 data.loopback = loopback;
7010 data.runtime = runtime;
7011 data.remove = remove;
7012 data.remove_timer = remove_timer;
7013 data.debug_mode = debug_mode;
7014 data.debug_file = debug_file;
7015 data.username = username;
7016 data.quiet = quiet;
7017 data.outfile = outfile;
7018 data.outfile_format = outfile_format;
7019 data.outfile_autohex = outfile_autohex;
7020 data.hex_charset = hex_charset;
7021 data.hex_salt = hex_salt;
7022 data.hex_wordlist = hex_wordlist;
7023 data.separator = separator;
7024 data.rp_files = rp_files;
7025 data.rp_files_cnt = rp_files_cnt;
7026 data.rp_gen = rp_gen;
7027 data.rp_gen_seed = rp_gen_seed;
7028 data.force = force;
7029 data.benchmark = benchmark;
7030 data.skip = skip;
7031 data.limit = limit;
7032 #ifdef HAVE_HWMON
7033 data.powertune_enable = powertune_enable;
7034 #endif
7035 data.logfile_disable = logfile_disable;
7036 data.truecrypt_keyfiles = truecrypt_keyfiles;
7037 data.veracrypt_keyfiles = veracrypt_keyfiles;
7038 data.veracrypt_pim = veracrypt_pim;
7039 data.scrypt_tmto = scrypt_tmto;
7040 data.workload_profile = workload_profile;
7041
7042 /**
7043 * cpu affinity
7044 */
7045
7046 if (cpu_affinity)
7047 {
7048 set_cpu_affinity (cpu_affinity);
7049 }
7050
7051 if (rp_gen_seed_chgd == 0)
7052 {
7053 srand (proc_start);
7054 }
7055 else
7056 {
7057 srand (rp_gen_seed);
7058 }
7059
7060 /**
7061 * logfile init
7062 */
7063
7064 if (logfile_disable == 0)
7065 {
7066 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7067
7068 char *logfile = (char *) mymalloc (logfile_size);
7069
7070 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7071
7072 data.logfile = logfile;
7073
7074 char *topid = logfile_generate_topid ();
7075
7076 data.topid = topid;
7077 }
7078
7079 // logfile_append() checks for logfile_disable internally to make it easier from here
7080
7081 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7082 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7083 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7084 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7085 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7086 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7087 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7088 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7089 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7090 #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));
7091
7092 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7093 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7094 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7095 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7096 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7097 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7098 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7099 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7100
7101 logfile_top_msg ("START");
7102
7103 logfile_top_uint (attack_mode);
7104 logfile_top_uint (attack_kern);
7105 logfile_top_uint (benchmark);
7106 logfile_top_uint (stdout_flag);
7107 logfile_top_uint (bitmap_min);
7108 logfile_top_uint (bitmap_max);
7109 logfile_top_uint (debug_mode);
7110 logfile_top_uint (force);
7111 logfile_top_uint (kernel_accel);
7112 logfile_top_uint (kernel_loops);
7113 logfile_top_uint (nvidia_spin_damp);
7114 logfile_top_uint (gpu_temp_disable);
7115 #ifdef HAVE_HWMON
7116 logfile_top_uint (gpu_temp_abort);
7117 logfile_top_uint (gpu_temp_retain);
7118 #endif
7119 logfile_top_uint (hash_mode);
7120 logfile_top_uint (hex_charset);
7121 logfile_top_uint (hex_salt);
7122 logfile_top_uint (hex_wordlist);
7123 logfile_top_uint (increment);
7124 logfile_top_uint (increment_max);
7125 logfile_top_uint (increment_min);
7126 logfile_top_uint (keyspace);
7127 logfile_top_uint (left);
7128 logfile_top_uint (logfile_disable);
7129 logfile_top_uint (loopback);
7130 logfile_top_uint (markov_classic);
7131 logfile_top_uint (markov_disable);
7132 logfile_top_uint (markov_threshold);
7133 logfile_top_uint (outfile_autohex);
7134 logfile_top_uint (outfile_check_timer);
7135 logfile_top_uint (outfile_format);
7136 logfile_top_uint (potfile_disable);
7137 logfile_top_string (potfile_path);
7138 #if defined(HAVE_HWMON)
7139 logfile_top_uint (powertune_enable);
7140 #endif
7141 logfile_top_uint (scrypt_tmto);
7142 logfile_top_uint (quiet);
7143 logfile_top_uint (remove);
7144 logfile_top_uint (remove_timer);
7145 logfile_top_uint (restore);
7146 logfile_top_uint (restore_disable);
7147 logfile_top_uint (restore_timer);
7148 logfile_top_uint (rp_gen);
7149 logfile_top_uint (rp_gen_func_max);
7150 logfile_top_uint (rp_gen_func_min);
7151 logfile_top_uint (rp_gen_seed);
7152 logfile_top_uint (runtime);
7153 logfile_top_uint (segment_size);
7154 logfile_top_uint (show);
7155 logfile_top_uint (status);
7156 logfile_top_uint (machine_readable);
7157 logfile_top_uint (status_timer);
7158 logfile_top_uint (usage);
7159 logfile_top_uint (username);
7160 logfile_top_uint (version);
7161 logfile_top_uint (weak_hash_threshold);
7162 logfile_top_uint (workload_profile);
7163 logfile_top_uint64 (limit);
7164 logfile_top_uint64 (skip);
7165 logfile_top_char (separator);
7166 logfile_top_string (cpu_affinity);
7167 logfile_top_string (custom_charset_1);
7168 logfile_top_string (custom_charset_2);
7169 logfile_top_string (custom_charset_3);
7170 logfile_top_string (custom_charset_4);
7171 logfile_top_string (debug_file);
7172 logfile_top_string (opencl_devices);
7173 logfile_top_string (opencl_platforms);
7174 logfile_top_string (opencl_device_types);
7175 logfile_top_uint (opencl_vector_width);
7176 logfile_top_string (induction_dir);
7177 logfile_top_string (markov_hcstat);
7178 logfile_top_string (outfile);
7179 logfile_top_string (outfile_check_dir);
7180 logfile_top_string (rule_buf_l);
7181 logfile_top_string (rule_buf_r);
7182 logfile_top_string (session);
7183 logfile_top_string (truecrypt_keyfiles);
7184 logfile_top_string (veracrypt_keyfiles);
7185 logfile_top_uint (veracrypt_pim);
7186
7187 /**
7188 * Init OpenCL library loader
7189 */
7190
7191 if (keyspace == 0)
7192 {
7193 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7194
7195 ocl_init (ocl);
7196
7197 data.ocl = ocl;
7198 }
7199
7200 /**
7201 * OpenCL platform selection
7202 */
7203
7204 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7205
7206 /**
7207 * OpenCL device selection
7208 */
7209
7210 u32 devices_filter = setup_devices_filter (opencl_devices);
7211
7212 /**
7213 * OpenCL device type selection
7214 */
7215
7216 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7217
7218 /**
7219 * benchmark
7220 */
7221
7222 if (benchmark == 1)
7223 {
7224 /**
7225 * disable useless stuff for benchmark
7226 */
7227
7228 status_timer = 0;
7229 restore_timer = 0;
7230 restore_disable = 1;
7231 potfile_disable = 1;
7232 weak_hash_threshold = 0;
7233 nvidia_spin_damp = 0;
7234 gpu_temp_disable = 1;
7235 outfile_check_timer = 0;
7236
7237 #ifdef HAVE_HWMON
7238 if (powertune_enable == 1)
7239 {
7240 gpu_temp_disable = 0;
7241 }
7242 #endif
7243
7244 data.status_timer = status_timer;
7245 data.restore_timer = restore_timer;
7246 data.restore_disable = restore_disable;
7247 data.outfile_check_timer = outfile_check_timer;
7248
7249 /**
7250 * force attack mode to be bruteforce
7251 */
7252
7253 attack_mode = ATTACK_MODE_BF;
7254 attack_kern = ATTACK_KERN_BF;
7255
7256 if (workload_profile_chgd == 0)
7257 {
7258 workload_profile = 3;
7259
7260 data.workload_profile = workload_profile;
7261 }
7262 }
7263
7264 /**
7265 * config
7266 */
7267
7268 uint hash_type = 0;
7269 uint salt_type = 0;
7270 uint attack_exec = 0;
7271 uint opts_type = 0;
7272 uint kern_type = 0;
7273 uint dgst_size = 0;
7274 uint esalt_size = 0;
7275 uint opti_type = 0;
7276 uint dgst_pos0 = -1;
7277 uint dgst_pos1 = -1;
7278 uint dgst_pos2 = -1;
7279 uint dgst_pos3 = -1;
7280
7281 int (*parse_func) (char *, uint, hash_t *);
7282 int (*sort_by_digest) (const void *, const void *);
7283
7284 uint algorithm_pos = 0;
7285 uint algorithm_max = 1;
7286
7287 uint *algorithms = default_benchmark_algorithms;
7288
7289 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7290
7291 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7292 {
7293 /*
7294 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7295 * the following algos are skipped entirely
7296 */
7297
7298 if (algorithm_pos > 0)
7299 {
7300 local_free (rd);
7301
7302 rd = init_restore (argc, argv);
7303
7304 data.rd = rd;
7305 }
7306
7307 /**
7308 * update hash_mode in case of multihash benchmark
7309 */
7310
7311 if (benchmark == 1)
7312 {
7313 if (hash_mode_chgd == 0)
7314 {
7315 hash_mode = algorithms[algorithm_pos];
7316
7317 data.hash_mode = hash_mode;
7318 }
7319
7320 quiet = 1;
7321
7322 data.quiet = quiet;
7323 }
7324
7325 switch (hash_mode)
7326 {
7327 case 0: hash_type = HASH_TYPE_MD5;
7328 salt_type = SALT_TYPE_NONE;
7329 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7330 opts_type = OPTS_TYPE_PT_GENERATE_LE
7331 | OPTS_TYPE_PT_ADD80
7332 | OPTS_TYPE_PT_ADDBITS14;
7333 kern_type = KERN_TYPE_MD5;
7334 dgst_size = DGST_SIZE_4_4;
7335 parse_func = md5_parse_hash;
7336 sort_by_digest = sort_by_digest_4_4;
7337 opti_type = OPTI_TYPE_ZERO_BYTE
7338 | OPTI_TYPE_PRECOMPUTE_INIT
7339 | OPTI_TYPE_PRECOMPUTE_MERKLE
7340 | OPTI_TYPE_MEET_IN_MIDDLE
7341 | OPTI_TYPE_EARLY_SKIP
7342 | OPTI_TYPE_NOT_ITERATED
7343 | OPTI_TYPE_NOT_SALTED
7344 | OPTI_TYPE_RAW_HASH;
7345 dgst_pos0 = 0;
7346 dgst_pos1 = 3;
7347 dgst_pos2 = 2;
7348 dgst_pos3 = 1;
7349 break;
7350
7351 case 10: hash_type = HASH_TYPE_MD5;
7352 salt_type = SALT_TYPE_INTERN;
7353 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7354 opts_type = OPTS_TYPE_PT_GENERATE_LE
7355 | OPTS_TYPE_ST_ADD80
7356 | OPTS_TYPE_ST_ADDBITS14;
7357 kern_type = KERN_TYPE_MD5_PWSLT;
7358 dgst_size = DGST_SIZE_4_4;
7359 parse_func = md5s_parse_hash;
7360 sort_by_digest = sort_by_digest_4_4;
7361 opti_type = OPTI_TYPE_ZERO_BYTE
7362 | OPTI_TYPE_PRECOMPUTE_INIT
7363 | OPTI_TYPE_PRECOMPUTE_MERKLE
7364 | OPTI_TYPE_MEET_IN_MIDDLE
7365 | OPTI_TYPE_EARLY_SKIP
7366 | OPTI_TYPE_NOT_ITERATED
7367 | OPTI_TYPE_APPENDED_SALT
7368 | OPTI_TYPE_RAW_HASH;
7369 dgst_pos0 = 0;
7370 dgst_pos1 = 3;
7371 dgst_pos2 = 2;
7372 dgst_pos3 = 1;
7373 break;
7374
7375 case 11: hash_type = HASH_TYPE_MD5;
7376 salt_type = SALT_TYPE_INTERN;
7377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7378 opts_type = OPTS_TYPE_PT_GENERATE_LE
7379 | OPTS_TYPE_ST_ADD80
7380 | OPTS_TYPE_ST_ADDBITS14;
7381 kern_type = KERN_TYPE_MD5_PWSLT;
7382 dgst_size = DGST_SIZE_4_4;
7383 parse_func = joomla_parse_hash;
7384 sort_by_digest = sort_by_digest_4_4;
7385 opti_type = OPTI_TYPE_ZERO_BYTE
7386 | OPTI_TYPE_PRECOMPUTE_INIT
7387 | OPTI_TYPE_PRECOMPUTE_MERKLE
7388 | OPTI_TYPE_MEET_IN_MIDDLE
7389 | OPTI_TYPE_EARLY_SKIP
7390 | OPTI_TYPE_NOT_ITERATED
7391 | OPTI_TYPE_APPENDED_SALT
7392 | OPTI_TYPE_RAW_HASH;
7393 dgst_pos0 = 0;
7394 dgst_pos1 = 3;
7395 dgst_pos2 = 2;
7396 dgst_pos3 = 1;
7397 break;
7398
7399 case 12: hash_type = HASH_TYPE_MD5;
7400 salt_type = SALT_TYPE_INTERN;
7401 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7402 opts_type = OPTS_TYPE_PT_GENERATE_LE
7403 | OPTS_TYPE_ST_ADD80
7404 | OPTS_TYPE_ST_ADDBITS14;
7405 kern_type = KERN_TYPE_MD5_PWSLT;
7406 dgst_size = DGST_SIZE_4_4;
7407 parse_func = postgresql_parse_hash;
7408 sort_by_digest = sort_by_digest_4_4;
7409 opti_type = OPTI_TYPE_ZERO_BYTE
7410 | OPTI_TYPE_PRECOMPUTE_INIT
7411 | OPTI_TYPE_PRECOMPUTE_MERKLE
7412 | OPTI_TYPE_MEET_IN_MIDDLE
7413 | OPTI_TYPE_EARLY_SKIP
7414 | OPTI_TYPE_NOT_ITERATED
7415 | OPTI_TYPE_APPENDED_SALT
7416 | OPTI_TYPE_RAW_HASH;
7417 dgst_pos0 = 0;
7418 dgst_pos1 = 3;
7419 dgst_pos2 = 2;
7420 dgst_pos3 = 1;
7421 break;
7422
7423 case 20: hash_type = HASH_TYPE_MD5;
7424 salt_type = SALT_TYPE_INTERN;
7425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7426 opts_type = OPTS_TYPE_PT_GENERATE_LE
7427 | OPTS_TYPE_PT_ADD80
7428 | OPTS_TYPE_PT_ADDBITS14;
7429 kern_type = KERN_TYPE_MD5_SLTPW;
7430 dgst_size = DGST_SIZE_4_4;
7431 parse_func = md5s_parse_hash;
7432 sort_by_digest = sort_by_digest_4_4;
7433 opti_type = OPTI_TYPE_ZERO_BYTE
7434 | OPTI_TYPE_PRECOMPUTE_INIT
7435 | OPTI_TYPE_PRECOMPUTE_MERKLE
7436 | OPTI_TYPE_EARLY_SKIP
7437 | OPTI_TYPE_NOT_ITERATED
7438 | OPTI_TYPE_PREPENDED_SALT
7439 | OPTI_TYPE_RAW_HASH;
7440 dgst_pos0 = 0;
7441 dgst_pos1 = 3;
7442 dgst_pos2 = 2;
7443 dgst_pos3 = 1;
7444 break;
7445
7446 case 21: hash_type = HASH_TYPE_MD5;
7447 salt_type = SALT_TYPE_INTERN;
7448 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7449 opts_type = OPTS_TYPE_PT_GENERATE_LE
7450 | OPTS_TYPE_PT_ADD80
7451 | OPTS_TYPE_PT_ADDBITS14;
7452 kern_type = KERN_TYPE_MD5_SLTPW;
7453 dgst_size = DGST_SIZE_4_4;
7454 parse_func = osc_parse_hash;
7455 sort_by_digest = sort_by_digest_4_4;
7456 opti_type = OPTI_TYPE_ZERO_BYTE
7457 | OPTI_TYPE_PRECOMPUTE_INIT
7458 | OPTI_TYPE_PRECOMPUTE_MERKLE
7459 | OPTI_TYPE_EARLY_SKIP
7460 | OPTI_TYPE_NOT_ITERATED
7461 | OPTI_TYPE_PREPENDED_SALT
7462 | OPTI_TYPE_RAW_HASH;
7463 dgst_pos0 = 0;
7464 dgst_pos1 = 3;
7465 dgst_pos2 = 2;
7466 dgst_pos3 = 1;
7467 break;
7468
7469 case 22: hash_type = HASH_TYPE_MD5;
7470 salt_type = SALT_TYPE_EMBEDDED;
7471 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7472 opts_type = OPTS_TYPE_PT_GENERATE_LE
7473 | OPTS_TYPE_PT_ADD80
7474 | OPTS_TYPE_PT_ADDBITS14;
7475 kern_type = KERN_TYPE_MD5_SLTPW;
7476 dgst_size = DGST_SIZE_4_4;
7477 parse_func = netscreen_parse_hash;
7478 sort_by_digest = sort_by_digest_4_4;
7479 opti_type = OPTI_TYPE_ZERO_BYTE
7480 | OPTI_TYPE_PRECOMPUTE_INIT
7481 | OPTI_TYPE_PRECOMPUTE_MERKLE
7482 | OPTI_TYPE_EARLY_SKIP
7483 | OPTI_TYPE_NOT_ITERATED
7484 | OPTI_TYPE_PREPENDED_SALT
7485 | OPTI_TYPE_RAW_HASH;
7486 dgst_pos0 = 0;
7487 dgst_pos1 = 3;
7488 dgst_pos2 = 2;
7489 dgst_pos3 = 1;
7490 break;
7491
7492 case 23: hash_type = HASH_TYPE_MD5;
7493 salt_type = SALT_TYPE_EMBEDDED;
7494 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7495 opts_type = OPTS_TYPE_PT_GENERATE_LE
7496 | OPTS_TYPE_PT_ADD80
7497 | OPTS_TYPE_PT_ADDBITS14;
7498 kern_type = KERN_TYPE_MD5_SLTPW;
7499 dgst_size = DGST_SIZE_4_4;
7500 parse_func = skype_parse_hash;
7501 sort_by_digest = sort_by_digest_4_4;
7502 opti_type = OPTI_TYPE_ZERO_BYTE
7503 | OPTI_TYPE_PRECOMPUTE_INIT
7504 | OPTI_TYPE_PRECOMPUTE_MERKLE
7505 | OPTI_TYPE_EARLY_SKIP
7506 | OPTI_TYPE_NOT_ITERATED
7507 | OPTI_TYPE_PREPENDED_SALT
7508 | OPTI_TYPE_RAW_HASH;
7509 dgst_pos0 = 0;
7510 dgst_pos1 = 3;
7511 dgst_pos2 = 2;
7512 dgst_pos3 = 1;
7513 break;
7514
7515 case 30: hash_type = HASH_TYPE_MD5;
7516 salt_type = SALT_TYPE_INTERN;
7517 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7518 opts_type = OPTS_TYPE_PT_GENERATE_LE
7519 | OPTS_TYPE_PT_UNICODE
7520 | OPTS_TYPE_ST_ADD80
7521 | OPTS_TYPE_ST_ADDBITS14;
7522 kern_type = KERN_TYPE_MD5_PWUSLT;
7523 dgst_size = DGST_SIZE_4_4;
7524 parse_func = md5s_parse_hash;
7525 sort_by_digest = sort_by_digest_4_4;
7526 opti_type = OPTI_TYPE_ZERO_BYTE
7527 | OPTI_TYPE_PRECOMPUTE_INIT
7528 | OPTI_TYPE_PRECOMPUTE_MERKLE
7529 | OPTI_TYPE_MEET_IN_MIDDLE
7530 | OPTI_TYPE_EARLY_SKIP
7531 | OPTI_TYPE_NOT_ITERATED
7532 | OPTI_TYPE_APPENDED_SALT
7533 | OPTI_TYPE_RAW_HASH;
7534 dgst_pos0 = 0;
7535 dgst_pos1 = 3;
7536 dgst_pos2 = 2;
7537 dgst_pos3 = 1;
7538 break;
7539
7540 case 40: hash_type = HASH_TYPE_MD5;
7541 salt_type = SALT_TYPE_INTERN;
7542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7543 opts_type = OPTS_TYPE_PT_GENERATE_LE
7544 | OPTS_TYPE_PT_ADD80
7545 | OPTS_TYPE_PT_ADDBITS14
7546 | OPTS_TYPE_PT_UNICODE;
7547 kern_type = KERN_TYPE_MD5_SLTPWU;
7548 dgst_size = DGST_SIZE_4_4;
7549 parse_func = md5s_parse_hash;
7550 sort_by_digest = sort_by_digest_4_4;
7551 opti_type = OPTI_TYPE_ZERO_BYTE
7552 | OPTI_TYPE_PRECOMPUTE_INIT
7553 | OPTI_TYPE_PRECOMPUTE_MERKLE
7554 | OPTI_TYPE_EARLY_SKIP
7555 | OPTI_TYPE_NOT_ITERATED
7556 | OPTI_TYPE_PREPENDED_SALT
7557 | OPTI_TYPE_RAW_HASH;
7558 dgst_pos0 = 0;
7559 dgst_pos1 = 3;
7560 dgst_pos2 = 2;
7561 dgst_pos3 = 1;
7562 break;
7563
7564 case 50: hash_type = HASH_TYPE_MD5;
7565 salt_type = SALT_TYPE_INTERN;
7566 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7567 opts_type = OPTS_TYPE_PT_GENERATE_LE
7568 | OPTS_TYPE_ST_ADD80
7569 | OPTS_TYPE_ST_ADDBITS14;
7570 kern_type = KERN_TYPE_HMACMD5_PW;
7571 dgst_size = DGST_SIZE_4_4;
7572 parse_func = hmacmd5_parse_hash;
7573 sort_by_digest = sort_by_digest_4_4;
7574 opti_type = OPTI_TYPE_ZERO_BYTE
7575 | OPTI_TYPE_NOT_ITERATED;
7576 dgst_pos0 = 0;
7577 dgst_pos1 = 3;
7578 dgst_pos2 = 2;
7579 dgst_pos3 = 1;
7580 break;
7581
7582 case 60: 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_HMACMD5_SLT;
7589 dgst_size = DGST_SIZE_4_4;
7590 parse_func = hmacmd5_parse_hash;
7591 sort_by_digest = sort_by_digest_4_4;
7592 opti_type = OPTI_TYPE_ZERO_BYTE
7593 | OPTI_TYPE_NOT_ITERATED;
7594 dgst_pos0 = 0;
7595 dgst_pos1 = 3;
7596 dgst_pos2 = 2;
7597 dgst_pos3 = 1;
7598 break;
7599
7600 case 100: hash_type = HASH_TYPE_SHA1;
7601 salt_type = SALT_TYPE_NONE;
7602 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7603 opts_type = OPTS_TYPE_PT_GENERATE_BE
7604 | OPTS_TYPE_PT_ADD80
7605 | OPTS_TYPE_PT_ADDBITS15;
7606 kern_type = KERN_TYPE_SHA1;
7607 dgst_size = DGST_SIZE_4_5;
7608 parse_func = sha1_parse_hash;
7609 sort_by_digest = sort_by_digest_4_5;
7610 opti_type = OPTI_TYPE_ZERO_BYTE
7611 | OPTI_TYPE_PRECOMPUTE_INIT
7612 | OPTI_TYPE_PRECOMPUTE_MERKLE
7613 | OPTI_TYPE_EARLY_SKIP
7614 | OPTI_TYPE_NOT_ITERATED
7615 | OPTI_TYPE_NOT_SALTED
7616 | OPTI_TYPE_RAW_HASH;
7617 dgst_pos0 = 3;
7618 dgst_pos1 = 4;
7619 dgst_pos2 = 2;
7620 dgst_pos3 = 1;
7621 break;
7622
7623 case 101: hash_type = HASH_TYPE_SHA1;
7624 salt_type = SALT_TYPE_NONE;
7625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7626 opts_type = OPTS_TYPE_PT_GENERATE_BE
7627 | OPTS_TYPE_PT_ADD80
7628 | OPTS_TYPE_PT_ADDBITS15;
7629 kern_type = KERN_TYPE_SHA1;
7630 dgst_size = DGST_SIZE_4_5;
7631 parse_func = sha1b64_parse_hash;
7632 sort_by_digest = sort_by_digest_4_5;
7633 opti_type = OPTI_TYPE_ZERO_BYTE
7634 | OPTI_TYPE_PRECOMPUTE_INIT
7635 | OPTI_TYPE_PRECOMPUTE_MERKLE
7636 | OPTI_TYPE_EARLY_SKIP
7637 | OPTI_TYPE_NOT_ITERATED
7638 | OPTI_TYPE_NOT_SALTED
7639 | OPTI_TYPE_RAW_HASH;
7640 dgst_pos0 = 3;
7641 dgst_pos1 = 4;
7642 dgst_pos2 = 2;
7643 dgst_pos3 = 1;
7644 break;
7645
7646 case 110: hash_type = HASH_TYPE_SHA1;
7647 salt_type = SALT_TYPE_INTERN;
7648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7649 opts_type = OPTS_TYPE_PT_GENERATE_BE
7650 | OPTS_TYPE_ST_ADD80
7651 | OPTS_TYPE_ST_ADDBITS15;
7652 kern_type = KERN_TYPE_SHA1_PWSLT;
7653 dgst_size = DGST_SIZE_4_5;
7654 parse_func = sha1s_parse_hash;
7655 sort_by_digest = sort_by_digest_4_5;
7656 opti_type = OPTI_TYPE_ZERO_BYTE
7657 | OPTI_TYPE_PRECOMPUTE_INIT
7658 | OPTI_TYPE_PRECOMPUTE_MERKLE
7659 | OPTI_TYPE_EARLY_SKIP
7660 | OPTI_TYPE_NOT_ITERATED
7661 | OPTI_TYPE_APPENDED_SALT
7662 | OPTI_TYPE_RAW_HASH;
7663 dgst_pos0 = 3;
7664 dgst_pos1 = 4;
7665 dgst_pos2 = 2;
7666 dgst_pos3 = 1;
7667 break;
7668
7669 case 111: hash_type = HASH_TYPE_SHA1;
7670 salt_type = SALT_TYPE_EMBEDDED;
7671 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7672 opts_type = OPTS_TYPE_PT_GENERATE_BE
7673 | OPTS_TYPE_ST_ADD80
7674 | OPTS_TYPE_ST_ADDBITS15;
7675 kern_type = KERN_TYPE_SHA1_PWSLT;
7676 dgst_size = DGST_SIZE_4_5;
7677 parse_func = sha1b64s_parse_hash;
7678 sort_by_digest = sort_by_digest_4_5;
7679 opti_type = OPTI_TYPE_ZERO_BYTE
7680 | OPTI_TYPE_PRECOMPUTE_INIT
7681 | OPTI_TYPE_PRECOMPUTE_MERKLE
7682 | OPTI_TYPE_EARLY_SKIP
7683 | OPTI_TYPE_NOT_ITERATED
7684 | OPTI_TYPE_APPENDED_SALT
7685 | OPTI_TYPE_RAW_HASH;
7686 dgst_pos0 = 3;
7687 dgst_pos1 = 4;
7688 dgst_pos2 = 2;
7689 dgst_pos3 = 1;
7690 break;
7691
7692 case 112: hash_type = HASH_TYPE_SHA1;
7693 salt_type = SALT_TYPE_INTERN;
7694 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7695 opts_type = OPTS_TYPE_PT_GENERATE_BE
7696 | OPTS_TYPE_ST_ADD80
7697 | OPTS_TYPE_ST_ADDBITS15
7698 | OPTS_TYPE_ST_HEX;
7699 kern_type = KERN_TYPE_SHA1_PWSLT;
7700 dgst_size = DGST_SIZE_4_5;
7701 parse_func = oracles_parse_hash;
7702 sort_by_digest = sort_by_digest_4_5;
7703 opti_type = OPTI_TYPE_ZERO_BYTE
7704 | OPTI_TYPE_PRECOMPUTE_INIT
7705 | OPTI_TYPE_PRECOMPUTE_MERKLE
7706 | OPTI_TYPE_EARLY_SKIP
7707 | OPTI_TYPE_NOT_ITERATED
7708 | OPTI_TYPE_APPENDED_SALT
7709 | OPTI_TYPE_RAW_HASH;
7710 dgst_pos0 = 3;
7711 dgst_pos1 = 4;
7712 dgst_pos2 = 2;
7713 dgst_pos3 = 1;
7714 break;
7715
7716 case 120: hash_type = HASH_TYPE_SHA1;
7717 salt_type = SALT_TYPE_INTERN;
7718 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7719 opts_type = OPTS_TYPE_PT_GENERATE_BE
7720 | OPTS_TYPE_PT_ADD80
7721 | OPTS_TYPE_PT_ADDBITS15;
7722 kern_type = KERN_TYPE_SHA1_SLTPW;
7723 dgst_size = DGST_SIZE_4_5;
7724 parse_func = sha1s_parse_hash;
7725 sort_by_digest = sort_by_digest_4_5;
7726 opti_type = OPTI_TYPE_ZERO_BYTE
7727 | OPTI_TYPE_PRECOMPUTE_INIT
7728 | OPTI_TYPE_PRECOMPUTE_MERKLE
7729 | OPTI_TYPE_EARLY_SKIP
7730 | OPTI_TYPE_NOT_ITERATED
7731 | OPTI_TYPE_PREPENDED_SALT
7732 | OPTI_TYPE_RAW_HASH;
7733 dgst_pos0 = 3;
7734 dgst_pos1 = 4;
7735 dgst_pos2 = 2;
7736 dgst_pos3 = 1;
7737 break;
7738
7739 case 121: hash_type = HASH_TYPE_SHA1;
7740 salt_type = SALT_TYPE_INTERN;
7741 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7742 opts_type = OPTS_TYPE_PT_GENERATE_BE
7743 | OPTS_TYPE_PT_ADD80
7744 | OPTS_TYPE_PT_ADDBITS15
7745 | OPTS_TYPE_ST_LOWER;
7746 kern_type = KERN_TYPE_SHA1_SLTPW;
7747 dgst_size = DGST_SIZE_4_5;
7748 parse_func = smf_parse_hash;
7749 sort_by_digest = sort_by_digest_4_5;
7750 opti_type = OPTI_TYPE_ZERO_BYTE
7751 | OPTI_TYPE_PRECOMPUTE_INIT
7752 | OPTI_TYPE_PRECOMPUTE_MERKLE
7753 | OPTI_TYPE_EARLY_SKIP
7754 | OPTI_TYPE_NOT_ITERATED
7755 | OPTI_TYPE_PREPENDED_SALT
7756 | OPTI_TYPE_RAW_HASH;
7757 dgst_pos0 = 3;
7758 dgst_pos1 = 4;
7759 dgst_pos2 = 2;
7760 dgst_pos3 = 1;
7761 break;
7762
7763 case 122: hash_type = HASH_TYPE_SHA1;
7764 salt_type = SALT_TYPE_EMBEDDED;
7765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7766 opts_type = OPTS_TYPE_PT_GENERATE_BE
7767 | OPTS_TYPE_PT_ADD80
7768 | OPTS_TYPE_PT_ADDBITS15
7769 | OPTS_TYPE_ST_HEX;
7770 kern_type = KERN_TYPE_SHA1_SLTPW;
7771 dgst_size = DGST_SIZE_4_5;
7772 parse_func = osx1_parse_hash;
7773 sort_by_digest = sort_by_digest_4_5;
7774 opti_type = OPTI_TYPE_ZERO_BYTE
7775 | OPTI_TYPE_PRECOMPUTE_INIT
7776 | OPTI_TYPE_PRECOMPUTE_MERKLE
7777 | OPTI_TYPE_EARLY_SKIP
7778 | OPTI_TYPE_NOT_ITERATED
7779 | OPTI_TYPE_PREPENDED_SALT
7780 | OPTI_TYPE_RAW_HASH;
7781 dgst_pos0 = 3;
7782 dgst_pos1 = 4;
7783 dgst_pos2 = 2;
7784 dgst_pos3 = 1;
7785 break;
7786
7787 case 124: hash_type = HASH_TYPE_SHA1;
7788 salt_type = SALT_TYPE_EMBEDDED;
7789 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7790 opts_type = OPTS_TYPE_PT_GENERATE_BE
7791 | OPTS_TYPE_PT_ADD80
7792 | OPTS_TYPE_PT_ADDBITS15;
7793 kern_type = KERN_TYPE_SHA1_SLTPW;
7794 dgst_size = DGST_SIZE_4_5;
7795 parse_func = djangosha1_parse_hash;
7796 sort_by_digest = sort_by_digest_4_5;
7797 opti_type = OPTI_TYPE_ZERO_BYTE
7798 | OPTI_TYPE_PRECOMPUTE_INIT
7799 | OPTI_TYPE_PRECOMPUTE_MERKLE
7800 | OPTI_TYPE_EARLY_SKIP
7801 | OPTI_TYPE_NOT_ITERATED
7802 | OPTI_TYPE_PREPENDED_SALT
7803 | OPTI_TYPE_RAW_HASH;
7804 dgst_pos0 = 3;
7805 dgst_pos1 = 4;
7806 dgst_pos2 = 2;
7807 dgst_pos3 = 1;
7808 break;
7809
7810 case 125: hash_type = HASH_TYPE_SHA1;
7811 salt_type = SALT_TYPE_EMBEDDED;
7812 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7813 opts_type = OPTS_TYPE_PT_GENERATE_BE
7814 | OPTS_TYPE_PT_ADD80
7815 | OPTS_TYPE_PT_ADDBITS15
7816 | OPTS_TYPE_ST_HEX;
7817 kern_type = KERN_TYPE_SHA1_SLTPW;
7818 dgst_size = DGST_SIZE_4_5;
7819 parse_func = arubaos_parse_hash;
7820 sort_by_digest = sort_by_digest_4_5;
7821 opti_type = OPTI_TYPE_ZERO_BYTE
7822 | OPTI_TYPE_PRECOMPUTE_INIT
7823 | OPTI_TYPE_PRECOMPUTE_MERKLE
7824 | OPTI_TYPE_EARLY_SKIP
7825 | OPTI_TYPE_NOT_ITERATED
7826 | OPTI_TYPE_PREPENDED_SALT
7827 | OPTI_TYPE_RAW_HASH;
7828 dgst_pos0 = 3;
7829 dgst_pos1 = 4;
7830 dgst_pos2 = 2;
7831 dgst_pos3 = 1;
7832 break;
7833
7834 case 130: hash_type = HASH_TYPE_SHA1;
7835 salt_type = SALT_TYPE_INTERN;
7836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7837 opts_type = OPTS_TYPE_PT_GENERATE_BE
7838 | OPTS_TYPE_PT_UNICODE
7839 | OPTS_TYPE_ST_ADD80
7840 | OPTS_TYPE_ST_ADDBITS15;
7841 kern_type = KERN_TYPE_SHA1_PWUSLT;
7842 dgst_size = DGST_SIZE_4_5;
7843 parse_func = sha1s_parse_hash;
7844 sort_by_digest = sort_by_digest_4_5;
7845 opti_type = OPTI_TYPE_ZERO_BYTE
7846 | OPTI_TYPE_PRECOMPUTE_INIT
7847 | OPTI_TYPE_PRECOMPUTE_MERKLE
7848 | OPTI_TYPE_EARLY_SKIP
7849 | OPTI_TYPE_NOT_ITERATED
7850 | OPTI_TYPE_APPENDED_SALT
7851 | OPTI_TYPE_RAW_HASH;
7852 dgst_pos0 = 3;
7853 dgst_pos1 = 4;
7854 dgst_pos2 = 2;
7855 dgst_pos3 = 1;
7856 break;
7857
7858 case 131: hash_type = HASH_TYPE_SHA1;
7859 salt_type = SALT_TYPE_EMBEDDED;
7860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7861 opts_type = OPTS_TYPE_PT_GENERATE_BE
7862 | OPTS_TYPE_PT_UNICODE
7863 | OPTS_TYPE_PT_UPPER
7864 | OPTS_TYPE_ST_ADD80
7865 | OPTS_TYPE_ST_ADDBITS15
7866 | OPTS_TYPE_ST_HEX;
7867 kern_type = KERN_TYPE_SHA1_PWUSLT;
7868 dgst_size = DGST_SIZE_4_5;
7869 parse_func = mssql2000_parse_hash;
7870 sort_by_digest = sort_by_digest_4_5;
7871 opti_type = OPTI_TYPE_ZERO_BYTE
7872 | OPTI_TYPE_PRECOMPUTE_INIT
7873 | OPTI_TYPE_PRECOMPUTE_MERKLE
7874 | OPTI_TYPE_EARLY_SKIP
7875 | OPTI_TYPE_NOT_ITERATED
7876 | OPTI_TYPE_APPENDED_SALT
7877 | OPTI_TYPE_RAW_HASH;
7878 dgst_pos0 = 3;
7879 dgst_pos1 = 4;
7880 dgst_pos2 = 2;
7881 dgst_pos3 = 1;
7882 break;
7883
7884 case 132: hash_type = HASH_TYPE_SHA1;
7885 salt_type = SALT_TYPE_EMBEDDED;
7886 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7887 opts_type = OPTS_TYPE_PT_GENERATE_BE
7888 | OPTS_TYPE_PT_UNICODE
7889 | OPTS_TYPE_ST_ADD80
7890 | OPTS_TYPE_ST_ADDBITS15
7891 | OPTS_TYPE_ST_HEX;
7892 kern_type = KERN_TYPE_SHA1_PWUSLT;
7893 dgst_size = DGST_SIZE_4_5;
7894 parse_func = mssql2005_parse_hash;
7895 sort_by_digest = sort_by_digest_4_5;
7896 opti_type = OPTI_TYPE_ZERO_BYTE
7897 | OPTI_TYPE_PRECOMPUTE_INIT
7898 | OPTI_TYPE_PRECOMPUTE_MERKLE
7899 | OPTI_TYPE_EARLY_SKIP
7900 | OPTI_TYPE_NOT_ITERATED
7901 | OPTI_TYPE_APPENDED_SALT
7902 | OPTI_TYPE_RAW_HASH;
7903 dgst_pos0 = 3;
7904 dgst_pos1 = 4;
7905 dgst_pos2 = 2;
7906 dgst_pos3 = 1;
7907 break;
7908
7909 case 133: hash_type = HASH_TYPE_SHA1;
7910 salt_type = SALT_TYPE_EMBEDDED;
7911 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7912 opts_type = OPTS_TYPE_PT_GENERATE_BE
7913 | OPTS_TYPE_PT_UNICODE
7914 | OPTS_TYPE_ST_ADD80
7915 | OPTS_TYPE_ST_ADDBITS15;
7916 kern_type = KERN_TYPE_SHA1_PWUSLT;
7917 dgst_size = DGST_SIZE_4_5;
7918 parse_func = peoplesoft_parse_hash;
7919 sort_by_digest = sort_by_digest_4_5;
7920 opti_type = OPTI_TYPE_ZERO_BYTE
7921 | OPTI_TYPE_PRECOMPUTE_INIT
7922 | OPTI_TYPE_PRECOMPUTE_MERKLE
7923 | OPTI_TYPE_EARLY_SKIP
7924 | OPTI_TYPE_NOT_ITERATED
7925 | OPTI_TYPE_APPENDED_SALT
7926 | OPTI_TYPE_RAW_HASH;
7927 dgst_pos0 = 3;
7928 dgst_pos1 = 4;
7929 dgst_pos2 = 2;
7930 dgst_pos3 = 1;
7931 break;
7932
7933 case 140: hash_type = HASH_TYPE_SHA1;
7934 salt_type = SALT_TYPE_INTERN;
7935 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7936 opts_type = OPTS_TYPE_PT_GENERATE_BE
7937 | OPTS_TYPE_PT_ADD80
7938 | OPTS_TYPE_PT_ADDBITS15
7939 | OPTS_TYPE_PT_UNICODE;
7940 kern_type = KERN_TYPE_SHA1_SLTPWU;
7941 dgst_size = DGST_SIZE_4_5;
7942 parse_func = sha1s_parse_hash;
7943 sort_by_digest = sort_by_digest_4_5;
7944 opti_type = OPTI_TYPE_ZERO_BYTE
7945 | OPTI_TYPE_PRECOMPUTE_INIT
7946 | OPTI_TYPE_PRECOMPUTE_MERKLE
7947 | OPTI_TYPE_EARLY_SKIP
7948 | OPTI_TYPE_NOT_ITERATED
7949 | OPTI_TYPE_PREPENDED_SALT
7950 | OPTI_TYPE_RAW_HASH;
7951 dgst_pos0 = 3;
7952 dgst_pos1 = 4;
7953 dgst_pos2 = 2;
7954 dgst_pos3 = 1;
7955 break;
7956
7957 case 141: hash_type = HASH_TYPE_SHA1;
7958 salt_type = SALT_TYPE_EMBEDDED;
7959 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7960 opts_type = OPTS_TYPE_PT_GENERATE_BE
7961 | OPTS_TYPE_PT_ADD80
7962 | OPTS_TYPE_PT_ADDBITS15
7963 | OPTS_TYPE_PT_UNICODE
7964 | OPTS_TYPE_ST_BASE64;
7965 kern_type = KERN_TYPE_SHA1_SLTPWU;
7966 dgst_size = DGST_SIZE_4_5;
7967 parse_func = episerver_parse_hash;
7968 sort_by_digest = sort_by_digest_4_5;
7969 opti_type = OPTI_TYPE_ZERO_BYTE
7970 | OPTI_TYPE_PRECOMPUTE_INIT
7971 | OPTI_TYPE_PRECOMPUTE_MERKLE
7972 | OPTI_TYPE_EARLY_SKIP
7973 | OPTI_TYPE_NOT_ITERATED
7974 | OPTI_TYPE_PREPENDED_SALT
7975 | OPTI_TYPE_RAW_HASH;
7976 dgst_pos0 = 3;
7977 dgst_pos1 = 4;
7978 dgst_pos2 = 2;
7979 dgst_pos3 = 1;
7980 break;
7981
7982 case 150: hash_type = HASH_TYPE_SHA1;
7983 salt_type = SALT_TYPE_INTERN;
7984 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7985 opts_type = OPTS_TYPE_PT_GENERATE_BE
7986 | OPTS_TYPE_ST_ADD80
7987 | OPTS_TYPE_ST_ADDBITS15;
7988 kern_type = KERN_TYPE_HMACSHA1_PW;
7989 dgst_size = DGST_SIZE_4_5;
7990 parse_func = hmacsha1_parse_hash;
7991 sort_by_digest = sort_by_digest_4_5;
7992 opti_type = OPTI_TYPE_ZERO_BYTE
7993 | OPTI_TYPE_NOT_ITERATED;
7994 dgst_pos0 = 3;
7995 dgst_pos1 = 4;
7996 dgst_pos2 = 2;
7997 dgst_pos3 = 1;
7998 break;
7999
8000 case 160: hash_type = HASH_TYPE_SHA1;
8001 salt_type = SALT_TYPE_INTERN;
8002 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8003 opts_type = OPTS_TYPE_PT_GENERATE_BE
8004 | OPTS_TYPE_PT_ADD80
8005 | OPTS_TYPE_PT_ADDBITS15;
8006 kern_type = KERN_TYPE_HMACSHA1_SLT;
8007 dgst_size = DGST_SIZE_4_5;
8008 parse_func = hmacsha1_parse_hash;
8009 sort_by_digest = sort_by_digest_4_5;
8010 opti_type = OPTI_TYPE_ZERO_BYTE
8011 | OPTI_TYPE_NOT_ITERATED;
8012 dgst_pos0 = 3;
8013 dgst_pos1 = 4;
8014 dgst_pos2 = 2;
8015 dgst_pos3 = 1;
8016 break;
8017
8018 case 190: hash_type = HASH_TYPE_SHA1;
8019 salt_type = SALT_TYPE_NONE;
8020 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8021 opts_type = OPTS_TYPE_PT_GENERATE_BE
8022 | OPTS_TYPE_PT_ADD80
8023 | OPTS_TYPE_PT_ADDBITS15;
8024 kern_type = KERN_TYPE_SHA1_LINKEDIN;
8025 dgst_size = DGST_SIZE_4_5;
8026 parse_func = sha1linkedin_parse_hash;
8027 sort_by_digest = sort_by_digest_4_5;
8028 opti_type = OPTI_TYPE_ZERO_BYTE
8029 | OPTI_TYPE_PRECOMPUTE_INIT
8030 | OPTI_TYPE_EARLY_SKIP
8031 | OPTI_TYPE_NOT_ITERATED
8032 | OPTI_TYPE_NOT_SALTED;
8033 dgst_pos0 = 0;
8034 dgst_pos1 = 4;
8035 dgst_pos2 = 3;
8036 dgst_pos3 = 2;
8037 break;
8038
8039 case 200: hash_type = HASH_TYPE_MYSQL;
8040 salt_type = SALT_TYPE_NONE;
8041 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8042 opts_type = 0;
8043 kern_type = KERN_TYPE_MYSQL;
8044 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8045 parse_func = mysql323_parse_hash;
8046 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8047 opti_type = OPTI_TYPE_ZERO_BYTE;
8048 dgst_pos0 = 0;
8049 dgst_pos1 = 1;
8050 dgst_pos2 = 2;
8051 dgst_pos3 = 3;
8052 break;
8053
8054 case 300: hash_type = HASH_TYPE_SHA1;
8055 salt_type = SALT_TYPE_NONE;
8056 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8057 opts_type = OPTS_TYPE_PT_GENERATE_BE
8058 | OPTS_TYPE_PT_ADD80
8059 | OPTS_TYPE_PT_ADDBITS15;
8060 kern_type = KERN_TYPE_MYSQL41;
8061 dgst_size = DGST_SIZE_4_5;
8062 parse_func = sha1_parse_hash;
8063 sort_by_digest = sort_by_digest_4_5;
8064 opti_type = OPTI_TYPE_ZERO_BYTE
8065 | OPTI_TYPE_PRECOMPUTE_INIT
8066 | OPTI_TYPE_PRECOMPUTE_MERKLE
8067 | OPTI_TYPE_EARLY_SKIP
8068 | OPTI_TYPE_NOT_ITERATED
8069 | OPTI_TYPE_NOT_SALTED;
8070 dgst_pos0 = 3;
8071 dgst_pos1 = 4;
8072 dgst_pos2 = 2;
8073 dgst_pos3 = 1;
8074 break;
8075
8076 case 400: hash_type = HASH_TYPE_MD5;
8077 salt_type = SALT_TYPE_EMBEDDED;
8078 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8079 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8080 kern_type = KERN_TYPE_PHPASS;
8081 dgst_size = DGST_SIZE_4_4;
8082 parse_func = phpass_parse_hash;
8083 sort_by_digest = sort_by_digest_4_4;
8084 opti_type = OPTI_TYPE_ZERO_BYTE
8085 | OPTI_TYPE_SLOW_HASH_SIMD;
8086 dgst_pos0 = 0;
8087 dgst_pos1 = 1;
8088 dgst_pos2 = 2;
8089 dgst_pos3 = 3;
8090 break;
8091
8092 case 500: hash_type = HASH_TYPE_MD5;
8093 salt_type = SALT_TYPE_EMBEDDED;
8094 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8095 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8096 kern_type = KERN_TYPE_MD5CRYPT;
8097 dgst_size = DGST_SIZE_4_4;
8098 parse_func = md5crypt_parse_hash;
8099 sort_by_digest = sort_by_digest_4_4;
8100 opti_type = OPTI_TYPE_ZERO_BYTE;
8101 dgst_pos0 = 0;
8102 dgst_pos1 = 1;
8103 dgst_pos2 = 2;
8104 dgst_pos3 = 3;
8105 break;
8106
8107 case 501: hash_type = HASH_TYPE_MD5;
8108 salt_type = SALT_TYPE_EMBEDDED;
8109 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8110 opts_type = OPTS_TYPE_PT_GENERATE_LE
8111 | OPTS_TYPE_HASH_COPY;
8112 kern_type = KERN_TYPE_MD5CRYPT;
8113 dgst_size = DGST_SIZE_4_4;
8114 parse_func = juniper_parse_hash;
8115 sort_by_digest = sort_by_digest_4_4;
8116 opti_type = OPTI_TYPE_ZERO_BYTE;
8117 dgst_pos0 = 0;
8118 dgst_pos1 = 1;
8119 dgst_pos2 = 2;
8120 dgst_pos3 = 3;
8121 break;
8122
8123 case 900: hash_type = HASH_TYPE_MD4;
8124 salt_type = SALT_TYPE_NONE;
8125 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8126 opts_type = OPTS_TYPE_PT_GENERATE_LE
8127 | OPTS_TYPE_PT_ADD80
8128 | OPTS_TYPE_PT_ADDBITS14;
8129 kern_type = KERN_TYPE_MD4;
8130 dgst_size = DGST_SIZE_4_4;
8131 parse_func = md4_parse_hash;
8132 sort_by_digest = sort_by_digest_4_4;
8133 opti_type = OPTI_TYPE_ZERO_BYTE
8134 | OPTI_TYPE_PRECOMPUTE_INIT
8135 | OPTI_TYPE_PRECOMPUTE_MERKLE
8136 | OPTI_TYPE_MEET_IN_MIDDLE
8137 | OPTI_TYPE_EARLY_SKIP
8138 | OPTI_TYPE_NOT_ITERATED
8139 | OPTI_TYPE_NOT_SALTED
8140 | OPTI_TYPE_RAW_HASH;
8141 dgst_pos0 = 0;
8142 dgst_pos1 = 3;
8143 dgst_pos2 = 2;
8144 dgst_pos3 = 1;
8145 break;
8146
8147 case 1000: hash_type = HASH_TYPE_MD4;
8148 salt_type = SALT_TYPE_NONE;
8149 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8150 opts_type = OPTS_TYPE_PT_GENERATE_LE
8151 | OPTS_TYPE_PT_ADD80
8152 | OPTS_TYPE_PT_ADDBITS14
8153 | OPTS_TYPE_PT_UNICODE;
8154 kern_type = KERN_TYPE_MD4_PWU;
8155 dgst_size = DGST_SIZE_4_4;
8156 parse_func = md4_parse_hash;
8157 sort_by_digest = sort_by_digest_4_4;
8158 opti_type = OPTI_TYPE_ZERO_BYTE
8159 | OPTI_TYPE_PRECOMPUTE_INIT
8160 | OPTI_TYPE_PRECOMPUTE_MERKLE
8161 | OPTI_TYPE_MEET_IN_MIDDLE
8162 | OPTI_TYPE_EARLY_SKIP
8163 | OPTI_TYPE_NOT_ITERATED
8164 | OPTI_TYPE_NOT_SALTED
8165 | OPTI_TYPE_RAW_HASH;
8166 dgst_pos0 = 0;
8167 dgst_pos1 = 3;
8168 dgst_pos2 = 2;
8169 dgst_pos3 = 1;
8170 break;
8171
8172 case 1100: hash_type = HASH_TYPE_MD4;
8173 salt_type = SALT_TYPE_INTERN;
8174 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8175 opts_type = OPTS_TYPE_PT_GENERATE_LE
8176 | OPTS_TYPE_PT_ADD80
8177 | OPTS_TYPE_PT_ADDBITS14
8178 | OPTS_TYPE_PT_UNICODE
8179 | OPTS_TYPE_ST_ADD80
8180 | OPTS_TYPE_ST_UNICODE
8181 | OPTS_TYPE_ST_LOWER;
8182 kern_type = KERN_TYPE_MD44_PWUSLT;
8183 dgst_size = DGST_SIZE_4_4;
8184 parse_func = dcc_parse_hash;
8185 sort_by_digest = sort_by_digest_4_4;
8186 opti_type = OPTI_TYPE_ZERO_BYTE
8187 | OPTI_TYPE_PRECOMPUTE_INIT
8188 | OPTI_TYPE_PRECOMPUTE_MERKLE
8189 | OPTI_TYPE_EARLY_SKIP
8190 | OPTI_TYPE_NOT_ITERATED;
8191 dgst_pos0 = 0;
8192 dgst_pos1 = 3;
8193 dgst_pos2 = 2;
8194 dgst_pos3 = 1;
8195 break;
8196
8197 case 1400: hash_type = HASH_TYPE_SHA256;
8198 salt_type = SALT_TYPE_NONE;
8199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8200 opts_type = OPTS_TYPE_PT_GENERATE_BE
8201 | OPTS_TYPE_PT_ADD80
8202 | OPTS_TYPE_PT_ADDBITS15;
8203 kern_type = KERN_TYPE_SHA256;
8204 dgst_size = DGST_SIZE_4_8;
8205 parse_func = sha256_parse_hash;
8206 sort_by_digest = sort_by_digest_4_8;
8207 opti_type = OPTI_TYPE_ZERO_BYTE
8208 | OPTI_TYPE_PRECOMPUTE_INIT
8209 | OPTI_TYPE_PRECOMPUTE_MERKLE
8210 | OPTI_TYPE_EARLY_SKIP
8211 | OPTI_TYPE_NOT_ITERATED
8212 | OPTI_TYPE_NOT_SALTED
8213 | OPTI_TYPE_RAW_HASH;
8214 dgst_pos0 = 3;
8215 dgst_pos1 = 7;
8216 dgst_pos2 = 2;
8217 dgst_pos3 = 6;
8218 break;
8219
8220 case 1410: hash_type = HASH_TYPE_SHA256;
8221 salt_type = SALT_TYPE_INTERN;
8222 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8223 opts_type = OPTS_TYPE_PT_GENERATE_BE
8224 | OPTS_TYPE_ST_ADD80
8225 | OPTS_TYPE_ST_ADDBITS15;
8226 kern_type = KERN_TYPE_SHA256_PWSLT;
8227 dgst_size = DGST_SIZE_4_8;
8228 parse_func = sha256s_parse_hash;
8229 sort_by_digest = sort_by_digest_4_8;
8230 opti_type = OPTI_TYPE_ZERO_BYTE
8231 | OPTI_TYPE_PRECOMPUTE_INIT
8232 | OPTI_TYPE_PRECOMPUTE_MERKLE
8233 | OPTI_TYPE_EARLY_SKIP
8234 | OPTI_TYPE_NOT_ITERATED
8235 | OPTI_TYPE_APPENDED_SALT
8236 | OPTI_TYPE_RAW_HASH;
8237 dgst_pos0 = 3;
8238 dgst_pos1 = 7;
8239 dgst_pos2 = 2;
8240 dgst_pos3 = 6;
8241 break;
8242
8243 case 1420: hash_type = HASH_TYPE_SHA256;
8244 salt_type = SALT_TYPE_INTERN;
8245 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8246 opts_type = OPTS_TYPE_PT_GENERATE_BE
8247 | OPTS_TYPE_PT_ADD80
8248 | OPTS_TYPE_PT_ADDBITS15;
8249 kern_type = KERN_TYPE_SHA256_SLTPW;
8250 dgst_size = DGST_SIZE_4_8;
8251 parse_func = sha256s_parse_hash;
8252 sort_by_digest = sort_by_digest_4_8;
8253 opti_type = OPTI_TYPE_ZERO_BYTE
8254 | OPTI_TYPE_PRECOMPUTE_INIT
8255 | OPTI_TYPE_PRECOMPUTE_MERKLE
8256 | OPTI_TYPE_EARLY_SKIP
8257 | OPTI_TYPE_NOT_ITERATED
8258 | OPTI_TYPE_PREPENDED_SALT
8259 | OPTI_TYPE_RAW_HASH;
8260 dgst_pos0 = 3;
8261 dgst_pos1 = 7;
8262 dgst_pos2 = 2;
8263 dgst_pos3 = 6;
8264 break;
8265
8266 case 1421: hash_type = HASH_TYPE_SHA256;
8267 salt_type = SALT_TYPE_EMBEDDED;
8268 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8269 opts_type = OPTS_TYPE_PT_GENERATE_BE
8270 | OPTS_TYPE_PT_ADD80
8271 | OPTS_TYPE_PT_ADDBITS15;
8272 kern_type = KERN_TYPE_SHA256_SLTPW;
8273 dgst_size = DGST_SIZE_4_8;
8274 parse_func = hmailserver_parse_hash;
8275 sort_by_digest = sort_by_digest_4_8;
8276 opti_type = OPTI_TYPE_ZERO_BYTE
8277 | OPTI_TYPE_PRECOMPUTE_INIT
8278 | OPTI_TYPE_PRECOMPUTE_MERKLE
8279 | OPTI_TYPE_EARLY_SKIP
8280 | OPTI_TYPE_NOT_ITERATED
8281 | OPTI_TYPE_PREPENDED_SALT
8282 | OPTI_TYPE_RAW_HASH;
8283 dgst_pos0 = 3;
8284 dgst_pos1 = 7;
8285 dgst_pos2 = 2;
8286 dgst_pos3 = 6;
8287 break;
8288
8289 case 1430: hash_type = HASH_TYPE_SHA256;
8290 salt_type = SALT_TYPE_INTERN;
8291 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8292 opts_type = OPTS_TYPE_PT_GENERATE_BE
8293 | OPTS_TYPE_PT_UNICODE
8294 | OPTS_TYPE_ST_ADD80
8295 | OPTS_TYPE_ST_ADDBITS15;
8296 kern_type = KERN_TYPE_SHA256_PWUSLT;
8297 dgst_size = DGST_SIZE_4_8;
8298 parse_func = sha256s_parse_hash;
8299 sort_by_digest = sort_by_digest_4_8;
8300 opti_type = OPTI_TYPE_ZERO_BYTE
8301 | OPTI_TYPE_PRECOMPUTE_INIT
8302 | OPTI_TYPE_PRECOMPUTE_MERKLE
8303 | OPTI_TYPE_EARLY_SKIP
8304 | OPTI_TYPE_NOT_ITERATED
8305 | OPTI_TYPE_APPENDED_SALT
8306 | OPTI_TYPE_RAW_HASH;
8307 dgst_pos0 = 3;
8308 dgst_pos1 = 7;
8309 dgst_pos2 = 2;
8310 dgst_pos3 = 6;
8311 break;
8312
8313 case 1440: hash_type = HASH_TYPE_SHA256;
8314 salt_type = SALT_TYPE_INTERN;
8315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8316 opts_type = OPTS_TYPE_PT_GENERATE_BE
8317 | OPTS_TYPE_PT_ADD80
8318 | OPTS_TYPE_PT_ADDBITS15
8319 | OPTS_TYPE_PT_UNICODE;
8320 kern_type = KERN_TYPE_SHA256_SLTPWU;
8321 dgst_size = DGST_SIZE_4_8;
8322 parse_func = sha256s_parse_hash;
8323 sort_by_digest = sort_by_digest_4_8;
8324 opti_type = OPTI_TYPE_ZERO_BYTE
8325 | OPTI_TYPE_PRECOMPUTE_INIT
8326 | OPTI_TYPE_PRECOMPUTE_MERKLE
8327 | OPTI_TYPE_EARLY_SKIP
8328 | OPTI_TYPE_NOT_ITERATED
8329 | OPTI_TYPE_PREPENDED_SALT
8330 | OPTI_TYPE_RAW_HASH;
8331 dgst_pos0 = 3;
8332 dgst_pos1 = 7;
8333 dgst_pos2 = 2;
8334 dgst_pos3 = 6;
8335 break;
8336
8337 case 1441: hash_type = HASH_TYPE_SHA256;
8338 salt_type = SALT_TYPE_EMBEDDED;
8339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8340 opts_type = OPTS_TYPE_PT_GENERATE_BE
8341 | OPTS_TYPE_PT_ADD80
8342 | OPTS_TYPE_PT_ADDBITS15
8343 | OPTS_TYPE_PT_UNICODE
8344 | OPTS_TYPE_ST_BASE64;
8345 kern_type = KERN_TYPE_SHA256_SLTPWU;
8346 dgst_size = DGST_SIZE_4_8;
8347 parse_func = episerver4_parse_hash;
8348 sort_by_digest = sort_by_digest_4_8;
8349 opti_type = OPTI_TYPE_ZERO_BYTE
8350 | OPTI_TYPE_PRECOMPUTE_INIT
8351 | OPTI_TYPE_PRECOMPUTE_MERKLE
8352 | OPTI_TYPE_EARLY_SKIP
8353 | OPTI_TYPE_NOT_ITERATED
8354 | OPTI_TYPE_PREPENDED_SALT
8355 | OPTI_TYPE_RAW_HASH;
8356 dgst_pos0 = 3;
8357 dgst_pos1 = 7;
8358 dgst_pos2 = 2;
8359 dgst_pos3 = 6;
8360 break;
8361
8362 case 1450: hash_type = HASH_TYPE_SHA256;
8363 salt_type = SALT_TYPE_INTERN;
8364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8365 opts_type = OPTS_TYPE_PT_GENERATE_BE
8366 | OPTS_TYPE_ST_ADD80;
8367 kern_type = KERN_TYPE_HMACSHA256_PW;
8368 dgst_size = DGST_SIZE_4_8;
8369 parse_func = hmacsha256_parse_hash;
8370 sort_by_digest = sort_by_digest_4_8;
8371 opti_type = OPTI_TYPE_ZERO_BYTE
8372 | OPTI_TYPE_NOT_ITERATED;
8373 dgst_pos0 = 3;
8374 dgst_pos1 = 7;
8375 dgst_pos2 = 2;
8376 dgst_pos3 = 6;
8377 break;
8378
8379 case 1460: hash_type = HASH_TYPE_SHA256;
8380 salt_type = SALT_TYPE_INTERN;
8381 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8382 opts_type = OPTS_TYPE_PT_GENERATE_BE
8383 | OPTS_TYPE_PT_ADD80
8384 | OPTS_TYPE_PT_ADDBITS15;
8385 kern_type = KERN_TYPE_HMACSHA256_SLT;
8386 dgst_size = DGST_SIZE_4_8;
8387 parse_func = hmacsha256_parse_hash;
8388 sort_by_digest = sort_by_digest_4_8;
8389 opti_type = OPTI_TYPE_ZERO_BYTE
8390 | OPTI_TYPE_NOT_ITERATED;
8391 dgst_pos0 = 3;
8392 dgst_pos1 = 7;
8393 dgst_pos2 = 2;
8394 dgst_pos3 = 6;
8395 break;
8396
8397 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8398 salt_type = SALT_TYPE_EMBEDDED;
8399 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8400 opts_type = OPTS_TYPE_PT_GENERATE_LE
8401 | OPTS_TYPE_PT_BITSLICE;
8402 kern_type = KERN_TYPE_DESCRYPT;
8403 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8404 parse_func = descrypt_parse_hash;
8405 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8406 opti_type = OPTI_TYPE_ZERO_BYTE
8407 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8408 dgst_pos0 = 0;
8409 dgst_pos1 = 1;
8410 dgst_pos2 = 2;
8411 dgst_pos3 = 3;
8412 break;
8413
8414 case 1600: hash_type = HASH_TYPE_MD5;
8415 salt_type = SALT_TYPE_EMBEDDED;
8416 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8417 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8418 kern_type = KERN_TYPE_APR1CRYPT;
8419 dgst_size = DGST_SIZE_4_4;
8420 parse_func = md5apr1_parse_hash;
8421 sort_by_digest = sort_by_digest_4_4;
8422 opti_type = OPTI_TYPE_ZERO_BYTE;
8423 dgst_pos0 = 0;
8424 dgst_pos1 = 1;
8425 dgst_pos2 = 2;
8426 dgst_pos3 = 3;
8427 break;
8428
8429 case 1700: hash_type = HASH_TYPE_SHA512;
8430 salt_type = SALT_TYPE_NONE;
8431 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8432 opts_type = OPTS_TYPE_PT_GENERATE_BE
8433 | OPTS_TYPE_PT_ADD80
8434 | OPTS_TYPE_PT_ADDBITS15;
8435 kern_type = KERN_TYPE_SHA512;
8436 dgst_size = DGST_SIZE_8_8;
8437 parse_func = sha512_parse_hash;
8438 sort_by_digest = sort_by_digest_8_8;
8439 opti_type = OPTI_TYPE_ZERO_BYTE
8440 | OPTI_TYPE_PRECOMPUTE_INIT
8441 | OPTI_TYPE_PRECOMPUTE_MERKLE
8442 | OPTI_TYPE_EARLY_SKIP
8443 | OPTI_TYPE_NOT_ITERATED
8444 | OPTI_TYPE_NOT_SALTED
8445 | OPTI_TYPE_USES_BITS_64
8446 | OPTI_TYPE_RAW_HASH;
8447 dgst_pos0 = 14;
8448 dgst_pos1 = 15;
8449 dgst_pos2 = 6;
8450 dgst_pos3 = 7;
8451 break;
8452
8453 case 1710: hash_type = HASH_TYPE_SHA512;
8454 salt_type = SALT_TYPE_INTERN;
8455 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8456 opts_type = OPTS_TYPE_PT_GENERATE_BE
8457 | OPTS_TYPE_ST_ADD80
8458 | OPTS_TYPE_ST_ADDBITS15;
8459 kern_type = KERN_TYPE_SHA512_PWSLT;
8460 dgst_size = DGST_SIZE_8_8;
8461 parse_func = sha512s_parse_hash;
8462 sort_by_digest = sort_by_digest_8_8;
8463 opti_type = OPTI_TYPE_ZERO_BYTE
8464 | OPTI_TYPE_PRECOMPUTE_INIT
8465 | OPTI_TYPE_PRECOMPUTE_MERKLE
8466 | OPTI_TYPE_EARLY_SKIP
8467 | OPTI_TYPE_NOT_ITERATED
8468 | OPTI_TYPE_APPENDED_SALT
8469 | OPTI_TYPE_USES_BITS_64
8470 | OPTI_TYPE_RAW_HASH;
8471 dgst_pos0 = 14;
8472 dgst_pos1 = 15;
8473 dgst_pos2 = 6;
8474 dgst_pos3 = 7;
8475 break;
8476
8477 case 1711: hash_type = HASH_TYPE_SHA512;
8478 salt_type = SALT_TYPE_EMBEDDED;
8479 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8480 opts_type = OPTS_TYPE_PT_GENERATE_BE
8481 | OPTS_TYPE_ST_ADD80
8482 | OPTS_TYPE_ST_ADDBITS15;
8483 kern_type = KERN_TYPE_SHA512_PWSLT;
8484 dgst_size = DGST_SIZE_8_8;
8485 parse_func = sha512b64s_parse_hash;
8486 sort_by_digest = sort_by_digest_8_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_APPENDED_SALT
8493 | OPTI_TYPE_USES_BITS_64
8494 | OPTI_TYPE_RAW_HASH;
8495 dgst_pos0 = 14;
8496 dgst_pos1 = 15;
8497 dgst_pos2 = 6;
8498 dgst_pos3 = 7;
8499 break;
8500
8501 case 1720: hash_type = HASH_TYPE_SHA512;
8502 salt_type = SALT_TYPE_INTERN;
8503 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8504 opts_type = OPTS_TYPE_PT_GENERATE_BE
8505 | OPTS_TYPE_PT_ADD80
8506 | OPTS_TYPE_PT_ADDBITS15;
8507 kern_type = KERN_TYPE_SHA512_SLTPW;
8508 dgst_size = DGST_SIZE_8_8;
8509 parse_func = sha512s_parse_hash;
8510 sort_by_digest = sort_by_digest_8_8;
8511 opti_type = OPTI_TYPE_ZERO_BYTE
8512 | OPTI_TYPE_PRECOMPUTE_INIT
8513 | OPTI_TYPE_PRECOMPUTE_MERKLE
8514 | OPTI_TYPE_EARLY_SKIP
8515 | OPTI_TYPE_NOT_ITERATED
8516 | OPTI_TYPE_PREPENDED_SALT
8517 | OPTI_TYPE_USES_BITS_64
8518 | OPTI_TYPE_RAW_HASH;
8519 dgst_pos0 = 14;
8520 dgst_pos1 = 15;
8521 dgst_pos2 = 6;
8522 dgst_pos3 = 7;
8523 break;
8524
8525 case 1722: hash_type = HASH_TYPE_SHA512;
8526 salt_type = SALT_TYPE_EMBEDDED;
8527 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8528 opts_type = OPTS_TYPE_PT_GENERATE_BE
8529 | OPTS_TYPE_PT_ADD80
8530 | OPTS_TYPE_PT_ADDBITS15
8531 | OPTS_TYPE_ST_HEX;
8532 kern_type = KERN_TYPE_SHA512_SLTPW;
8533 dgst_size = DGST_SIZE_8_8;
8534 parse_func = osx512_parse_hash;
8535 sort_by_digest = sort_by_digest_8_8;
8536 opti_type = OPTI_TYPE_ZERO_BYTE
8537 | OPTI_TYPE_PRECOMPUTE_INIT
8538 | OPTI_TYPE_PRECOMPUTE_MERKLE
8539 | OPTI_TYPE_EARLY_SKIP
8540 | OPTI_TYPE_NOT_ITERATED
8541 | OPTI_TYPE_PREPENDED_SALT
8542 | OPTI_TYPE_USES_BITS_64
8543 | OPTI_TYPE_RAW_HASH;
8544 dgst_pos0 = 14;
8545 dgst_pos1 = 15;
8546 dgst_pos2 = 6;
8547 dgst_pos3 = 7;
8548 break;
8549
8550 case 1730: hash_type = HASH_TYPE_SHA512;
8551 salt_type = SALT_TYPE_INTERN;
8552 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8553 opts_type = OPTS_TYPE_PT_GENERATE_BE
8554 | OPTS_TYPE_PT_UNICODE
8555 | OPTS_TYPE_ST_ADD80
8556 | OPTS_TYPE_ST_ADDBITS15;
8557 kern_type = KERN_TYPE_SHA512_PWSLTU;
8558 dgst_size = DGST_SIZE_8_8;
8559 parse_func = sha512s_parse_hash;
8560 sort_by_digest = sort_by_digest_8_8;
8561 opti_type = OPTI_TYPE_ZERO_BYTE
8562 | OPTI_TYPE_PRECOMPUTE_INIT
8563 | OPTI_TYPE_PRECOMPUTE_MERKLE
8564 | OPTI_TYPE_EARLY_SKIP
8565 | OPTI_TYPE_NOT_ITERATED
8566 | OPTI_TYPE_APPENDED_SALT
8567 | OPTI_TYPE_USES_BITS_64
8568 | OPTI_TYPE_RAW_HASH;
8569 dgst_pos0 = 14;
8570 dgst_pos1 = 15;
8571 dgst_pos2 = 6;
8572 dgst_pos3 = 7;
8573 break;
8574
8575 case 1731: hash_type = HASH_TYPE_SHA512;
8576 salt_type = SALT_TYPE_EMBEDDED;
8577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8578 opts_type = OPTS_TYPE_PT_GENERATE_BE
8579 | OPTS_TYPE_PT_UNICODE
8580 | OPTS_TYPE_ST_ADD80
8581 | OPTS_TYPE_ST_ADDBITS15
8582 | OPTS_TYPE_ST_HEX;
8583 kern_type = KERN_TYPE_SHA512_PWSLTU;
8584 dgst_size = DGST_SIZE_8_8;
8585 parse_func = mssql2012_parse_hash;
8586 sort_by_digest = sort_by_digest_8_8;
8587 opti_type = OPTI_TYPE_ZERO_BYTE
8588 | OPTI_TYPE_PRECOMPUTE_INIT
8589 | OPTI_TYPE_PRECOMPUTE_MERKLE
8590 | OPTI_TYPE_EARLY_SKIP
8591 | OPTI_TYPE_NOT_ITERATED
8592 | OPTI_TYPE_APPENDED_SALT
8593 | OPTI_TYPE_USES_BITS_64
8594 | OPTI_TYPE_RAW_HASH;
8595 dgst_pos0 = 14;
8596 dgst_pos1 = 15;
8597 dgst_pos2 = 6;
8598 dgst_pos3 = 7;
8599 break;
8600
8601 case 1740: hash_type = HASH_TYPE_SHA512;
8602 salt_type = SALT_TYPE_INTERN;
8603 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8604 opts_type = OPTS_TYPE_PT_GENERATE_BE
8605 | OPTS_TYPE_PT_ADD80
8606 | OPTS_TYPE_PT_ADDBITS15
8607 | OPTS_TYPE_PT_UNICODE;
8608 kern_type = KERN_TYPE_SHA512_SLTPWU;
8609 dgst_size = DGST_SIZE_8_8;
8610 parse_func = sha512s_parse_hash;
8611 sort_by_digest = sort_by_digest_8_8;
8612 opti_type = OPTI_TYPE_ZERO_BYTE
8613 | OPTI_TYPE_PRECOMPUTE_INIT
8614 | OPTI_TYPE_PRECOMPUTE_MERKLE
8615 | OPTI_TYPE_EARLY_SKIP
8616 | OPTI_TYPE_NOT_ITERATED
8617 | OPTI_TYPE_PREPENDED_SALT
8618 | OPTI_TYPE_USES_BITS_64
8619 | OPTI_TYPE_RAW_HASH;
8620 dgst_pos0 = 14;
8621 dgst_pos1 = 15;
8622 dgst_pos2 = 6;
8623 dgst_pos3 = 7;
8624 break;
8625
8626 case 1750: hash_type = HASH_TYPE_SHA512;
8627 salt_type = SALT_TYPE_INTERN;
8628 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8629 opts_type = OPTS_TYPE_PT_GENERATE_BE
8630 | OPTS_TYPE_ST_ADD80;
8631 kern_type = KERN_TYPE_HMACSHA512_PW;
8632 dgst_size = DGST_SIZE_8_8;
8633 parse_func = hmacsha512_parse_hash;
8634 sort_by_digest = sort_by_digest_8_8;
8635 opti_type = OPTI_TYPE_ZERO_BYTE
8636 | OPTI_TYPE_USES_BITS_64
8637 | OPTI_TYPE_NOT_ITERATED;
8638 dgst_pos0 = 14;
8639 dgst_pos1 = 15;
8640 dgst_pos2 = 6;
8641 dgst_pos3 = 7;
8642 break;
8643
8644 case 1760: hash_type = HASH_TYPE_SHA512;
8645 salt_type = SALT_TYPE_INTERN;
8646 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8647 opts_type = OPTS_TYPE_PT_GENERATE_BE
8648 | OPTS_TYPE_PT_ADD80
8649 | OPTS_TYPE_PT_ADDBITS15;
8650 kern_type = KERN_TYPE_HMACSHA512_SLT;
8651 dgst_size = DGST_SIZE_8_8;
8652 parse_func = hmacsha512_parse_hash;
8653 sort_by_digest = sort_by_digest_8_8;
8654 opti_type = OPTI_TYPE_ZERO_BYTE
8655 | OPTI_TYPE_USES_BITS_64
8656 | OPTI_TYPE_NOT_ITERATED;
8657 dgst_pos0 = 14;
8658 dgst_pos1 = 15;
8659 dgst_pos2 = 6;
8660 dgst_pos3 = 7;
8661 break;
8662
8663 case 1800: hash_type = HASH_TYPE_SHA512;
8664 salt_type = SALT_TYPE_EMBEDDED;
8665 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8666 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8667 kern_type = KERN_TYPE_SHA512CRYPT;
8668 dgst_size = DGST_SIZE_8_8;
8669 parse_func = sha512crypt_parse_hash;
8670 sort_by_digest = sort_by_digest_8_8;
8671 opti_type = OPTI_TYPE_ZERO_BYTE
8672 | OPTI_TYPE_USES_BITS_64;
8673 dgst_pos0 = 0;
8674 dgst_pos1 = 1;
8675 dgst_pos2 = 2;
8676 dgst_pos3 = 3;
8677 break;
8678
8679 case 2000: hash_type = HASH_TYPE_STDOUT;
8680 salt_type = SALT_TYPE_NONE;
8681 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8682 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8683 kern_type = 0;
8684 dgst_size = DGST_SIZE_4_4;
8685 parse_func = NULL;
8686 sort_by_digest = NULL;
8687 opti_type = 0;
8688 dgst_pos0 = 0;
8689 dgst_pos1 = 0;
8690 dgst_pos2 = 0;
8691 dgst_pos3 = 0;
8692 break;
8693
8694 case 2100: hash_type = HASH_TYPE_DCC2;
8695 salt_type = SALT_TYPE_EMBEDDED;
8696 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8697 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8698 | OPTS_TYPE_ST_LOWER
8699 | OPTS_TYPE_ST_UNICODE;
8700 kern_type = KERN_TYPE_DCC2;
8701 dgst_size = DGST_SIZE_4_4;
8702 parse_func = dcc2_parse_hash;
8703 sort_by_digest = sort_by_digest_4_4;
8704 opti_type = OPTI_TYPE_ZERO_BYTE
8705 | OPTI_TYPE_SLOW_HASH_SIMD;
8706 dgst_pos0 = 0;
8707 dgst_pos1 = 1;
8708 dgst_pos2 = 2;
8709 dgst_pos3 = 3;
8710 break;
8711
8712 case 2400: hash_type = HASH_TYPE_MD5;
8713 salt_type = SALT_TYPE_NONE;
8714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8715 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8716 kern_type = KERN_TYPE_MD5PIX;
8717 dgst_size = DGST_SIZE_4_4;
8718 parse_func = md5pix_parse_hash;
8719 sort_by_digest = sort_by_digest_4_4;
8720 opti_type = OPTI_TYPE_ZERO_BYTE
8721 | OPTI_TYPE_PRECOMPUTE_INIT
8722 | OPTI_TYPE_PRECOMPUTE_MERKLE
8723 | OPTI_TYPE_EARLY_SKIP
8724 | OPTI_TYPE_NOT_ITERATED
8725 | OPTI_TYPE_NOT_SALTED;
8726 dgst_pos0 = 0;
8727 dgst_pos1 = 3;
8728 dgst_pos2 = 2;
8729 dgst_pos3 = 1;
8730 break;
8731
8732 case 2410: hash_type = HASH_TYPE_MD5;
8733 salt_type = SALT_TYPE_INTERN;
8734 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8735 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8736 kern_type = KERN_TYPE_MD5ASA;
8737 dgst_size = DGST_SIZE_4_4;
8738 parse_func = md5asa_parse_hash;
8739 sort_by_digest = sort_by_digest_4_4;
8740 opti_type = OPTI_TYPE_ZERO_BYTE
8741 | OPTI_TYPE_PRECOMPUTE_INIT
8742 | OPTI_TYPE_PRECOMPUTE_MERKLE
8743 | OPTI_TYPE_EARLY_SKIP
8744 | OPTI_TYPE_NOT_ITERATED;
8745 dgst_pos0 = 0;
8746 dgst_pos1 = 3;
8747 dgst_pos2 = 2;
8748 dgst_pos3 = 1;
8749 break;
8750
8751 case 2500: hash_type = HASH_TYPE_WPA;
8752 salt_type = SALT_TYPE_EMBEDDED;
8753 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8754 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8755 kern_type = KERN_TYPE_WPA;
8756 dgst_size = DGST_SIZE_4_4;
8757 parse_func = wpa_parse_hash;
8758 sort_by_digest = sort_by_digest_4_4;
8759 opti_type = OPTI_TYPE_ZERO_BYTE
8760 | OPTI_TYPE_SLOW_HASH_SIMD;
8761 dgst_pos0 = 0;
8762 dgst_pos1 = 1;
8763 dgst_pos2 = 2;
8764 dgst_pos3 = 3;
8765 break;
8766
8767 case 2600: hash_type = HASH_TYPE_MD5;
8768 salt_type = SALT_TYPE_VIRTUAL;
8769 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8770 opts_type = OPTS_TYPE_PT_GENERATE_LE
8771 | OPTS_TYPE_PT_ADD80
8772 | OPTS_TYPE_PT_ADDBITS14
8773 | OPTS_TYPE_ST_ADD80;
8774 kern_type = KERN_TYPE_MD55_PWSLT1;
8775 dgst_size = DGST_SIZE_4_4;
8776 parse_func = md5md5_parse_hash;
8777 sort_by_digest = sort_by_digest_4_4;
8778 opti_type = OPTI_TYPE_ZERO_BYTE
8779 | OPTI_TYPE_PRECOMPUTE_INIT
8780 | OPTI_TYPE_PRECOMPUTE_MERKLE
8781 | OPTI_TYPE_EARLY_SKIP;
8782 dgst_pos0 = 0;
8783 dgst_pos1 = 3;
8784 dgst_pos2 = 2;
8785 dgst_pos3 = 1;
8786 break;
8787
8788 case 2611: hash_type = HASH_TYPE_MD5;
8789 salt_type = SALT_TYPE_INTERN;
8790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8791 opts_type = OPTS_TYPE_PT_GENERATE_LE
8792 | OPTS_TYPE_PT_ADD80
8793 | OPTS_TYPE_PT_ADDBITS14
8794 | OPTS_TYPE_ST_ADD80;
8795 kern_type = KERN_TYPE_MD55_PWSLT1;
8796 dgst_size = DGST_SIZE_4_4;
8797 parse_func = vb3_parse_hash;
8798 sort_by_digest = sort_by_digest_4_4;
8799 opti_type = OPTI_TYPE_ZERO_BYTE
8800 | OPTI_TYPE_PRECOMPUTE_INIT
8801 | OPTI_TYPE_PRECOMPUTE_MERKLE
8802 | OPTI_TYPE_EARLY_SKIP;
8803 dgst_pos0 = 0;
8804 dgst_pos1 = 3;
8805 dgst_pos2 = 2;
8806 dgst_pos3 = 1;
8807 break;
8808
8809 case 2612: hash_type = HASH_TYPE_MD5;
8810 salt_type = SALT_TYPE_EMBEDDED;
8811 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8812 opts_type = OPTS_TYPE_PT_GENERATE_LE
8813 | OPTS_TYPE_PT_ADD80
8814 | OPTS_TYPE_PT_ADDBITS14
8815 | OPTS_TYPE_ST_ADD80
8816 | OPTS_TYPE_ST_HEX;
8817 kern_type = KERN_TYPE_MD55_PWSLT1;
8818 dgst_size = DGST_SIZE_4_4;
8819 parse_func = phps_parse_hash;
8820 sort_by_digest = sort_by_digest_4_4;
8821 opti_type = OPTI_TYPE_ZERO_BYTE
8822 | OPTI_TYPE_PRECOMPUTE_INIT
8823 | OPTI_TYPE_PRECOMPUTE_MERKLE
8824 | OPTI_TYPE_EARLY_SKIP;
8825 dgst_pos0 = 0;
8826 dgst_pos1 = 3;
8827 dgst_pos2 = 2;
8828 dgst_pos3 = 1;
8829 break;
8830
8831 case 2711: hash_type = HASH_TYPE_MD5;
8832 salt_type = SALT_TYPE_INTERN;
8833 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8834 opts_type = OPTS_TYPE_PT_GENERATE_LE
8835 | OPTS_TYPE_PT_ADD80
8836 | OPTS_TYPE_PT_ADDBITS14
8837 | OPTS_TYPE_ST_ADD80;
8838 kern_type = KERN_TYPE_MD55_PWSLT2;
8839 dgst_size = DGST_SIZE_4_4;
8840 parse_func = vb30_parse_hash;
8841 sort_by_digest = sort_by_digest_4_4;
8842 opti_type = OPTI_TYPE_ZERO_BYTE
8843 | OPTI_TYPE_PRECOMPUTE_INIT
8844 | OPTI_TYPE_EARLY_SKIP;
8845 dgst_pos0 = 0;
8846 dgst_pos1 = 3;
8847 dgst_pos2 = 2;
8848 dgst_pos3 = 1;
8849 break;
8850
8851 case 2811: hash_type = HASH_TYPE_MD5;
8852 salt_type = SALT_TYPE_INTERN;
8853 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8854 opts_type = OPTS_TYPE_PT_GENERATE_LE
8855 | OPTS_TYPE_PT_ADD80
8856 | OPTS_TYPE_PT_ADDBITS14;
8857 kern_type = KERN_TYPE_MD55_SLTPW;
8858 dgst_size = DGST_SIZE_4_4;
8859 parse_func = ipb2_parse_hash;
8860 sort_by_digest = sort_by_digest_4_4;
8861 opti_type = OPTI_TYPE_ZERO_BYTE
8862 | OPTI_TYPE_PRECOMPUTE_INIT
8863 | OPTI_TYPE_EARLY_SKIP;
8864 dgst_pos0 = 0;
8865 dgst_pos1 = 3;
8866 dgst_pos2 = 2;
8867 dgst_pos3 = 1;
8868 break;
8869
8870 case 3000: hash_type = HASH_TYPE_LM;
8871 salt_type = SALT_TYPE_NONE;
8872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8873 opts_type = OPTS_TYPE_PT_GENERATE_LE
8874 | OPTS_TYPE_PT_UPPER
8875 | OPTS_TYPE_PT_BITSLICE;
8876 kern_type = KERN_TYPE_LM;
8877 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8878 parse_func = lm_parse_hash;
8879 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8880 opti_type = OPTI_TYPE_ZERO_BYTE
8881 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8882 dgst_pos0 = 0;
8883 dgst_pos1 = 1;
8884 dgst_pos2 = 2;
8885 dgst_pos3 = 3;
8886 break;
8887
8888 case 3100: hash_type = HASH_TYPE_ORACLEH;
8889 salt_type = SALT_TYPE_INTERN;
8890 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8891 opts_type = OPTS_TYPE_PT_GENERATE_LE
8892 | OPTS_TYPE_PT_UPPER
8893 | OPTS_TYPE_ST_UPPER;
8894 kern_type = KERN_TYPE_ORACLEH;
8895 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8896 parse_func = oracleh_parse_hash;
8897 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8898 opti_type = OPTI_TYPE_ZERO_BYTE;
8899 dgst_pos0 = 0;
8900 dgst_pos1 = 1;
8901 dgst_pos2 = 2;
8902 dgst_pos3 = 3;
8903 break;
8904
8905 case 3200: hash_type = HASH_TYPE_BCRYPT;
8906 salt_type = SALT_TYPE_EMBEDDED;
8907 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8908 opts_type = OPTS_TYPE_PT_GENERATE_LE
8909 | OPTS_TYPE_ST_GENERATE_LE;
8910 kern_type = KERN_TYPE_BCRYPT;
8911 dgst_size = DGST_SIZE_4_6;
8912 parse_func = bcrypt_parse_hash;
8913 sort_by_digest = sort_by_digest_4_6;
8914 opti_type = OPTI_TYPE_ZERO_BYTE;
8915 dgst_pos0 = 0;
8916 dgst_pos1 = 1;
8917 dgst_pos2 = 2;
8918 dgst_pos3 = 3;
8919 break;
8920
8921 case 3710: hash_type = HASH_TYPE_MD5;
8922 salt_type = SALT_TYPE_INTERN;
8923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8924 opts_type = OPTS_TYPE_PT_GENERATE_LE
8925 | OPTS_TYPE_PT_ADD80
8926 | OPTS_TYPE_PT_ADDBITS14;
8927 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8928 dgst_size = DGST_SIZE_4_4;
8929 parse_func = md5s_parse_hash;
8930 sort_by_digest = sort_by_digest_4_4;
8931 opti_type = OPTI_TYPE_ZERO_BYTE
8932 | OPTI_TYPE_PRECOMPUTE_INIT
8933 | OPTI_TYPE_PRECOMPUTE_MERKLE
8934 | OPTI_TYPE_EARLY_SKIP;
8935 dgst_pos0 = 0;
8936 dgst_pos1 = 3;
8937 dgst_pos2 = 2;
8938 dgst_pos3 = 1;
8939 break;
8940
8941 case 3711: hash_type = HASH_TYPE_MD5;
8942 salt_type = SALT_TYPE_EMBEDDED;
8943 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8944 opts_type = OPTS_TYPE_PT_GENERATE_LE
8945 | OPTS_TYPE_PT_ADD80
8946 | OPTS_TYPE_PT_ADDBITS14;
8947 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8948 dgst_size = DGST_SIZE_4_4;
8949 parse_func = mediawiki_b_parse_hash;
8950 sort_by_digest = sort_by_digest_4_4;
8951 opti_type = OPTI_TYPE_ZERO_BYTE
8952 | OPTI_TYPE_PRECOMPUTE_INIT
8953 | OPTI_TYPE_PRECOMPUTE_MERKLE
8954 | OPTI_TYPE_EARLY_SKIP;
8955 dgst_pos0 = 0;
8956 dgst_pos1 = 3;
8957 dgst_pos2 = 2;
8958 dgst_pos3 = 1;
8959 break;
8960
8961 case 3800: hash_type = HASH_TYPE_MD5;
8962 salt_type = SALT_TYPE_INTERN;
8963 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8964 opts_type = OPTS_TYPE_PT_GENERATE_LE
8965 | OPTS_TYPE_ST_ADDBITS14;
8966 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8967 dgst_size = DGST_SIZE_4_4;
8968 parse_func = md5s_parse_hash;
8969 sort_by_digest = sort_by_digest_4_4;
8970 opti_type = OPTI_TYPE_ZERO_BYTE
8971 | OPTI_TYPE_PRECOMPUTE_INIT
8972 | OPTI_TYPE_PRECOMPUTE_MERKLE
8973 | OPTI_TYPE_EARLY_SKIP
8974 | OPTI_TYPE_NOT_ITERATED
8975 | OPTI_TYPE_RAW_HASH;
8976 dgst_pos0 = 0;
8977 dgst_pos1 = 3;
8978 dgst_pos2 = 2;
8979 dgst_pos3 = 1;
8980 break;
8981
8982 case 4300: hash_type = HASH_TYPE_MD5;
8983 salt_type = SALT_TYPE_VIRTUAL;
8984 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8985 opts_type = OPTS_TYPE_PT_GENERATE_LE
8986 | OPTS_TYPE_PT_ADD80
8987 | OPTS_TYPE_PT_ADDBITS14
8988 | OPTS_TYPE_ST_ADD80;
8989 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8990 dgst_size = DGST_SIZE_4_4;
8991 parse_func = md5md5_parse_hash;
8992 sort_by_digest = sort_by_digest_4_4;
8993 opti_type = OPTI_TYPE_ZERO_BYTE
8994 | OPTI_TYPE_PRECOMPUTE_INIT
8995 | OPTI_TYPE_PRECOMPUTE_MERKLE
8996 | OPTI_TYPE_EARLY_SKIP;
8997 dgst_pos0 = 0;
8998 dgst_pos1 = 3;
8999 dgst_pos2 = 2;
9000 dgst_pos3 = 1;
9001 break;
9002
9003
9004 case 4400: hash_type = HASH_TYPE_MD5;
9005 salt_type = SALT_TYPE_NONE;
9006 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9007 opts_type = OPTS_TYPE_PT_GENERATE_BE
9008 | OPTS_TYPE_PT_ADD80
9009 | OPTS_TYPE_PT_ADDBITS15;
9010 kern_type = KERN_TYPE_MD5_SHA1;
9011 dgst_size = DGST_SIZE_4_4;
9012 parse_func = md5_parse_hash;
9013 sort_by_digest = sort_by_digest_4_4;
9014 opti_type = OPTI_TYPE_ZERO_BYTE
9015 | OPTI_TYPE_PRECOMPUTE_INIT
9016 | OPTI_TYPE_PRECOMPUTE_MERKLE
9017 | OPTI_TYPE_EARLY_SKIP
9018 | OPTI_TYPE_NOT_ITERATED
9019 | OPTI_TYPE_NOT_SALTED
9020 | OPTI_TYPE_RAW_HASH;
9021 dgst_pos0 = 0;
9022 dgst_pos1 = 3;
9023 dgst_pos2 = 2;
9024 dgst_pos3 = 1;
9025 break;
9026
9027 case 4500: hash_type = HASH_TYPE_SHA1;
9028 salt_type = SALT_TYPE_NONE;
9029 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9030 opts_type = OPTS_TYPE_PT_GENERATE_BE
9031 | OPTS_TYPE_PT_ADD80
9032 | OPTS_TYPE_PT_ADDBITS15;
9033 kern_type = KERN_TYPE_SHA11;
9034 dgst_size = DGST_SIZE_4_5;
9035 parse_func = sha1_parse_hash;
9036 sort_by_digest = sort_by_digest_4_5;
9037 opti_type = OPTI_TYPE_ZERO_BYTE
9038 | OPTI_TYPE_PRECOMPUTE_INIT
9039 | OPTI_TYPE_PRECOMPUTE_MERKLE
9040 | OPTI_TYPE_EARLY_SKIP
9041 | OPTI_TYPE_NOT_SALTED;
9042 dgst_pos0 = 3;
9043 dgst_pos1 = 4;
9044 dgst_pos2 = 2;
9045 dgst_pos3 = 1;
9046 break;
9047
9048 case 4700: hash_type = HASH_TYPE_SHA1;
9049 salt_type = SALT_TYPE_NONE;
9050 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9051 opts_type = OPTS_TYPE_PT_GENERATE_LE
9052 | OPTS_TYPE_PT_ADD80
9053 | OPTS_TYPE_PT_ADDBITS14;
9054 kern_type = KERN_TYPE_SHA1_MD5;
9055 dgst_size = DGST_SIZE_4_5;
9056 parse_func = sha1_parse_hash;
9057 sort_by_digest = sort_by_digest_4_5;
9058 opti_type = OPTI_TYPE_ZERO_BYTE
9059 | OPTI_TYPE_PRECOMPUTE_INIT
9060 | OPTI_TYPE_PRECOMPUTE_MERKLE
9061 | OPTI_TYPE_EARLY_SKIP
9062 | OPTI_TYPE_NOT_ITERATED
9063 | OPTI_TYPE_NOT_SALTED
9064 | OPTI_TYPE_RAW_HASH;
9065 dgst_pos0 = 3;
9066 dgst_pos1 = 4;
9067 dgst_pos2 = 2;
9068 dgst_pos3 = 1;
9069 break;
9070
9071 case 4800: hash_type = HASH_TYPE_MD5;
9072 salt_type = SALT_TYPE_EMBEDDED;
9073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9074 opts_type = OPTS_TYPE_PT_GENERATE_LE
9075 | OPTS_TYPE_PT_ADDBITS14;
9076 kern_type = KERN_TYPE_MD5_CHAP;
9077 dgst_size = DGST_SIZE_4_4;
9078 parse_func = chap_parse_hash;
9079 sort_by_digest = sort_by_digest_4_4;
9080 opti_type = OPTI_TYPE_ZERO_BYTE
9081 | OPTI_TYPE_PRECOMPUTE_INIT
9082 | OPTI_TYPE_PRECOMPUTE_MERKLE
9083 | OPTI_TYPE_MEET_IN_MIDDLE
9084 | OPTI_TYPE_EARLY_SKIP
9085 | OPTI_TYPE_NOT_ITERATED
9086 | OPTI_TYPE_RAW_HASH;
9087 dgst_pos0 = 0;
9088 dgst_pos1 = 3;
9089 dgst_pos2 = 2;
9090 dgst_pos3 = 1;
9091 break;
9092
9093 case 4900: hash_type = HASH_TYPE_SHA1;
9094 salt_type = SALT_TYPE_INTERN;
9095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9096 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9097 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9098 dgst_size = DGST_SIZE_4_5;
9099 parse_func = sha1s_parse_hash;
9100 sort_by_digest = sort_by_digest_4_5;
9101 opti_type = OPTI_TYPE_ZERO_BYTE
9102 | OPTI_TYPE_PRECOMPUTE_INIT
9103 | OPTI_TYPE_PRECOMPUTE_MERKLE
9104 | OPTI_TYPE_EARLY_SKIP;
9105 dgst_pos0 = 3;
9106 dgst_pos1 = 4;
9107 dgst_pos2 = 2;
9108 dgst_pos3 = 1;
9109 break;
9110
9111 case 5000: hash_type = HASH_TYPE_KECCAK;
9112 salt_type = SALT_TYPE_EMBEDDED;
9113 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9114 opts_type = OPTS_TYPE_PT_GENERATE_LE
9115 | OPTS_TYPE_PT_ADD01;
9116 kern_type = KERN_TYPE_KECCAK;
9117 dgst_size = DGST_SIZE_8_25;
9118 parse_func = keccak_parse_hash;
9119 sort_by_digest = sort_by_digest_8_25;
9120 opti_type = OPTI_TYPE_ZERO_BYTE
9121 | OPTI_TYPE_USES_BITS_64
9122 | OPTI_TYPE_RAW_HASH;
9123 dgst_pos0 = 2;
9124 dgst_pos1 = 3;
9125 dgst_pos2 = 4;
9126 dgst_pos3 = 5;
9127 break;
9128
9129 case 5100: hash_type = HASH_TYPE_MD5H;
9130 salt_type = SALT_TYPE_NONE;
9131 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9132 opts_type = OPTS_TYPE_PT_GENERATE_LE
9133 | OPTS_TYPE_PT_ADD80
9134 | OPTS_TYPE_PT_ADDBITS14;
9135 kern_type = KERN_TYPE_MD5H;
9136 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9137 parse_func = md5half_parse_hash;
9138 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9139 opti_type = OPTI_TYPE_ZERO_BYTE
9140 | OPTI_TYPE_RAW_HASH;
9141 dgst_pos0 = 0;
9142 dgst_pos1 = 1;
9143 dgst_pos2 = 2;
9144 dgst_pos3 = 3;
9145 break;
9146
9147 case 5200: hash_type = HASH_TYPE_SHA256;
9148 salt_type = SALT_TYPE_EMBEDDED;
9149 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9150 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9151 kern_type = KERN_TYPE_PSAFE3;
9152 dgst_size = DGST_SIZE_4_8;
9153 parse_func = psafe3_parse_hash;
9154 sort_by_digest = sort_by_digest_4_8;
9155 opti_type = OPTI_TYPE_ZERO_BYTE;
9156 dgst_pos0 = 0;
9157 dgst_pos1 = 1;
9158 dgst_pos2 = 2;
9159 dgst_pos3 = 3;
9160 break;
9161
9162 case 5300: hash_type = HASH_TYPE_MD5;
9163 salt_type = SALT_TYPE_EMBEDDED;
9164 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9165 opts_type = OPTS_TYPE_PT_GENERATE_LE
9166 | OPTS_TYPE_ST_ADD80;
9167 kern_type = KERN_TYPE_IKEPSK_MD5;
9168 dgst_size = DGST_SIZE_4_4;
9169 parse_func = ikepsk_md5_parse_hash;
9170 sort_by_digest = sort_by_digest_4_4;
9171 opti_type = OPTI_TYPE_ZERO_BYTE;
9172 dgst_pos0 = 0;
9173 dgst_pos1 = 3;
9174 dgst_pos2 = 2;
9175 dgst_pos3 = 1;
9176 break;
9177
9178 case 5400: hash_type = HASH_TYPE_SHA1;
9179 salt_type = SALT_TYPE_EMBEDDED;
9180 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9181 opts_type = OPTS_TYPE_PT_GENERATE_BE
9182 | OPTS_TYPE_ST_ADD80;
9183 kern_type = KERN_TYPE_IKEPSK_SHA1;
9184 dgst_size = DGST_SIZE_4_5;
9185 parse_func = ikepsk_sha1_parse_hash;
9186 sort_by_digest = sort_by_digest_4_5;
9187 opti_type = OPTI_TYPE_ZERO_BYTE;
9188 dgst_pos0 = 3;
9189 dgst_pos1 = 4;
9190 dgst_pos2 = 2;
9191 dgst_pos3 = 1;
9192 break;
9193
9194 case 5500: hash_type = HASH_TYPE_NETNTLM;
9195 salt_type = SALT_TYPE_EMBEDDED;
9196 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9197 opts_type = OPTS_TYPE_PT_GENERATE_LE
9198 | OPTS_TYPE_PT_ADD80
9199 | OPTS_TYPE_PT_ADDBITS14
9200 | OPTS_TYPE_PT_UNICODE
9201 | OPTS_TYPE_ST_HEX;
9202 kern_type = KERN_TYPE_NETNTLMv1;
9203 dgst_size = DGST_SIZE_4_4;
9204 parse_func = netntlmv1_parse_hash;
9205 sort_by_digest = sort_by_digest_4_4;
9206 opti_type = OPTI_TYPE_ZERO_BYTE
9207 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9208 dgst_pos0 = 0;
9209 dgst_pos1 = 1;
9210 dgst_pos2 = 2;
9211 dgst_pos3 = 3;
9212 break;
9213
9214 case 5600: hash_type = HASH_TYPE_MD5;
9215 salt_type = SALT_TYPE_EMBEDDED;
9216 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9217 opts_type = OPTS_TYPE_PT_GENERATE_LE
9218 | OPTS_TYPE_PT_ADD80
9219 | OPTS_TYPE_PT_ADDBITS14
9220 | OPTS_TYPE_PT_UNICODE;
9221 kern_type = KERN_TYPE_NETNTLMv2;
9222 dgst_size = DGST_SIZE_4_4;
9223 parse_func = netntlmv2_parse_hash;
9224 sort_by_digest = sort_by_digest_4_4;
9225 opti_type = OPTI_TYPE_ZERO_BYTE;
9226 dgst_pos0 = 0;
9227 dgst_pos1 = 3;
9228 dgst_pos2 = 2;
9229 dgst_pos3 = 1;
9230 break;
9231
9232 case 5700: hash_type = HASH_TYPE_SHA256;
9233 salt_type = SALT_TYPE_NONE;
9234 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9235 opts_type = OPTS_TYPE_PT_GENERATE_BE
9236 | OPTS_TYPE_PT_ADD80
9237 | OPTS_TYPE_PT_ADDBITS15;
9238 kern_type = KERN_TYPE_SHA256;
9239 dgst_size = DGST_SIZE_4_8;
9240 parse_func = cisco4_parse_hash;
9241 sort_by_digest = sort_by_digest_4_8;
9242 opti_type = OPTI_TYPE_ZERO_BYTE
9243 | OPTI_TYPE_PRECOMPUTE_INIT
9244 | OPTI_TYPE_PRECOMPUTE_MERKLE
9245 | OPTI_TYPE_EARLY_SKIP
9246 | OPTI_TYPE_NOT_ITERATED
9247 | OPTI_TYPE_NOT_SALTED
9248 | OPTI_TYPE_RAW_HASH;
9249 dgst_pos0 = 3;
9250 dgst_pos1 = 7;
9251 dgst_pos2 = 2;
9252 dgst_pos3 = 6;
9253 break;
9254
9255 case 5800: hash_type = HASH_TYPE_SHA1;
9256 salt_type = SALT_TYPE_INTERN;
9257 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9258 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9259 | OPTS_TYPE_ST_ADD80;
9260 kern_type = KERN_TYPE_ANDROIDPIN;
9261 dgst_size = DGST_SIZE_4_5;
9262 parse_func = androidpin_parse_hash;
9263 sort_by_digest = sort_by_digest_4_5;
9264 opti_type = OPTI_TYPE_ZERO_BYTE;
9265 dgst_pos0 = 0;
9266 dgst_pos1 = 1;
9267 dgst_pos2 = 2;
9268 dgst_pos3 = 3;
9269 break;
9270
9271 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9272 salt_type = SALT_TYPE_NONE;
9273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9274 opts_type = OPTS_TYPE_PT_GENERATE_LE
9275 | OPTS_TYPE_PT_ADD80;
9276 kern_type = KERN_TYPE_RIPEMD160;
9277 dgst_size = DGST_SIZE_4_5;
9278 parse_func = ripemd160_parse_hash;
9279 sort_by_digest = sort_by_digest_4_5;
9280 opti_type = OPTI_TYPE_ZERO_BYTE;
9281 dgst_pos0 = 0;
9282 dgst_pos1 = 1;
9283 dgst_pos2 = 2;
9284 dgst_pos3 = 3;
9285 break;
9286
9287 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9288 salt_type = SALT_TYPE_NONE;
9289 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9290 opts_type = OPTS_TYPE_PT_GENERATE_BE
9291 | OPTS_TYPE_PT_ADD80;
9292 kern_type = KERN_TYPE_WHIRLPOOL;
9293 dgst_size = DGST_SIZE_4_16;
9294 parse_func = whirlpool_parse_hash;
9295 sort_by_digest = sort_by_digest_4_16;
9296 opti_type = OPTI_TYPE_ZERO_BYTE;
9297 dgst_pos0 = 0;
9298 dgst_pos1 = 1;
9299 dgst_pos2 = 2;
9300 dgst_pos3 = 3;
9301 break;
9302
9303 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9304 salt_type = SALT_TYPE_EMBEDDED;
9305 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9306 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9307 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9308 dgst_size = DGST_SIZE_4_5;
9309 parse_func = truecrypt_parse_hash_2k;
9310 sort_by_digest = sort_by_digest_4_5;
9311 opti_type = OPTI_TYPE_ZERO_BYTE;
9312 dgst_pos0 = 0;
9313 dgst_pos1 = 1;
9314 dgst_pos2 = 2;
9315 dgst_pos3 = 3;
9316 break;
9317
9318 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9319 salt_type = SALT_TYPE_EMBEDDED;
9320 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9321 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9322 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9323 dgst_size = DGST_SIZE_4_5;
9324 parse_func = truecrypt_parse_hash_2k;
9325 sort_by_digest = sort_by_digest_4_5;
9326 opti_type = OPTI_TYPE_ZERO_BYTE;
9327 dgst_pos0 = 0;
9328 dgst_pos1 = 1;
9329 dgst_pos2 = 2;
9330 dgst_pos3 = 3;
9331 break;
9332
9333 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9334 salt_type = SALT_TYPE_EMBEDDED;
9335 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9336 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9337 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9338 dgst_size = DGST_SIZE_4_5;
9339 parse_func = truecrypt_parse_hash_2k;
9340 sort_by_digest = sort_by_digest_4_5;
9341 opti_type = OPTI_TYPE_ZERO_BYTE;
9342 dgst_pos0 = 0;
9343 dgst_pos1 = 1;
9344 dgst_pos2 = 2;
9345 dgst_pos3 = 3;
9346 break;
9347
9348 case 6221: hash_type = HASH_TYPE_SHA512;
9349 salt_type = SALT_TYPE_EMBEDDED;
9350 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9351 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9352 kern_type = KERN_TYPE_TCSHA512_XTS512;
9353 dgst_size = DGST_SIZE_8_8;
9354 parse_func = truecrypt_parse_hash_1k;
9355 sort_by_digest = sort_by_digest_8_8;
9356 opti_type = OPTI_TYPE_ZERO_BYTE
9357 | OPTI_TYPE_USES_BITS_64;
9358 dgst_pos0 = 0;
9359 dgst_pos1 = 1;
9360 dgst_pos2 = 2;
9361 dgst_pos3 = 3;
9362 break;
9363
9364 case 6222: hash_type = HASH_TYPE_SHA512;
9365 salt_type = SALT_TYPE_EMBEDDED;
9366 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9367 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9368 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9369 dgst_size = DGST_SIZE_8_8;
9370 parse_func = truecrypt_parse_hash_1k;
9371 sort_by_digest = sort_by_digest_8_8;
9372 opti_type = OPTI_TYPE_ZERO_BYTE
9373 | OPTI_TYPE_USES_BITS_64;
9374 dgst_pos0 = 0;
9375 dgst_pos1 = 1;
9376 dgst_pos2 = 2;
9377 dgst_pos3 = 3;
9378 break;
9379
9380 case 6223: hash_type = HASH_TYPE_SHA512;
9381 salt_type = SALT_TYPE_EMBEDDED;
9382 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9383 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9384 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9385 dgst_size = DGST_SIZE_8_8;
9386 parse_func = truecrypt_parse_hash_1k;
9387 sort_by_digest = sort_by_digest_8_8;
9388 opti_type = OPTI_TYPE_ZERO_BYTE
9389 | OPTI_TYPE_USES_BITS_64;
9390 dgst_pos0 = 0;
9391 dgst_pos1 = 1;
9392 dgst_pos2 = 2;
9393 dgst_pos3 = 3;
9394 break;
9395
9396 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9397 salt_type = SALT_TYPE_EMBEDDED;
9398 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9399 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9400 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9401 dgst_size = DGST_SIZE_4_8;
9402 parse_func = truecrypt_parse_hash_1k;
9403 sort_by_digest = sort_by_digest_4_8;
9404 opti_type = OPTI_TYPE_ZERO_BYTE;
9405 dgst_pos0 = 0;
9406 dgst_pos1 = 1;
9407 dgst_pos2 = 2;
9408 dgst_pos3 = 3;
9409 break;
9410
9411 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9412 salt_type = SALT_TYPE_EMBEDDED;
9413 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9414 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9415 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9416 dgst_size = DGST_SIZE_4_8;
9417 parse_func = truecrypt_parse_hash_1k;
9418 sort_by_digest = sort_by_digest_4_8;
9419 opti_type = OPTI_TYPE_ZERO_BYTE;
9420 dgst_pos0 = 0;
9421 dgst_pos1 = 1;
9422 dgst_pos2 = 2;
9423 dgst_pos3 = 3;
9424 break;
9425
9426 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9427 salt_type = SALT_TYPE_EMBEDDED;
9428 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9429 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9430 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9431 dgst_size = DGST_SIZE_4_8;
9432 parse_func = truecrypt_parse_hash_1k;
9433 sort_by_digest = sort_by_digest_4_8;
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 6241: 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_1k;
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 6242: 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_1k;
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 6243: 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_1k;
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 6300: hash_type = HASH_TYPE_MD5;
9487 salt_type = SALT_TYPE_EMBEDDED;
9488 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9489 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9490 kern_type = KERN_TYPE_MD5AIX;
9491 dgst_size = DGST_SIZE_4_4;
9492 parse_func = md5aix_parse_hash;
9493 sort_by_digest = sort_by_digest_4_4;
9494 opti_type = OPTI_TYPE_ZERO_BYTE;
9495 dgst_pos0 = 0;
9496 dgst_pos1 = 1;
9497 dgst_pos2 = 2;
9498 dgst_pos3 = 3;
9499 break;
9500
9501 case 6400: hash_type = HASH_TYPE_SHA256;
9502 salt_type = SALT_TYPE_EMBEDDED;
9503 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9504 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9505 kern_type = KERN_TYPE_SHA256AIX;
9506 dgst_size = DGST_SIZE_4_8;
9507 parse_func = sha256aix_parse_hash;
9508 sort_by_digest = sort_by_digest_4_8;
9509 opti_type = OPTI_TYPE_ZERO_BYTE;
9510 dgst_pos0 = 0;
9511 dgst_pos1 = 1;
9512 dgst_pos2 = 2;
9513 dgst_pos3 = 3;
9514 break;
9515
9516 case 6500: hash_type = HASH_TYPE_SHA512;
9517 salt_type = SALT_TYPE_EMBEDDED;
9518 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9519 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9520 kern_type = KERN_TYPE_SHA512AIX;
9521 dgst_size = DGST_SIZE_8_8;
9522 parse_func = sha512aix_parse_hash;
9523 sort_by_digest = sort_by_digest_8_8;
9524 opti_type = OPTI_TYPE_ZERO_BYTE
9525 | OPTI_TYPE_USES_BITS_64;
9526 dgst_pos0 = 0;
9527 dgst_pos1 = 1;
9528 dgst_pos2 = 2;
9529 dgst_pos3 = 3;
9530 break;
9531
9532 case 6600: hash_type = HASH_TYPE_AES;
9533 salt_type = SALT_TYPE_EMBEDDED;
9534 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9535 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9536 kern_type = KERN_TYPE_AGILEKEY;
9537 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9538 parse_func = agilekey_parse_hash;
9539 sort_by_digest = sort_by_digest_4_5;
9540 opti_type = OPTI_TYPE_ZERO_BYTE;
9541 dgst_pos0 = 0;
9542 dgst_pos1 = 1;
9543 dgst_pos2 = 2;
9544 dgst_pos3 = 3;
9545 break;
9546
9547 case 6700: hash_type = HASH_TYPE_SHA1;
9548 salt_type = SALT_TYPE_EMBEDDED;
9549 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9550 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9551 kern_type = KERN_TYPE_SHA1AIX;
9552 dgst_size = DGST_SIZE_4_5;
9553 parse_func = sha1aix_parse_hash;
9554 sort_by_digest = sort_by_digest_4_5;
9555 opti_type = OPTI_TYPE_ZERO_BYTE;
9556 dgst_pos0 = 0;
9557 dgst_pos1 = 1;
9558 dgst_pos2 = 2;
9559 dgst_pos3 = 3;
9560 break;
9561
9562 case 6800: hash_type = HASH_TYPE_AES;
9563 salt_type = SALT_TYPE_EMBEDDED;
9564 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9565 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9566 kern_type = KERN_TYPE_LASTPASS;
9567 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9568 parse_func = lastpass_parse_hash;
9569 sort_by_digest = sort_by_digest_4_8;
9570 opti_type = OPTI_TYPE_ZERO_BYTE;
9571 dgst_pos0 = 0;
9572 dgst_pos1 = 1;
9573 dgst_pos2 = 2;
9574 dgst_pos3 = 3;
9575 break;
9576
9577 case 6900: hash_type = HASH_TYPE_GOST;
9578 salt_type = SALT_TYPE_NONE;
9579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9580 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9581 kern_type = KERN_TYPE_GOST;
9582 dgst_size = DGST_SIZE_4_8;
9583 parse_func = gost_parse_hash;
9584 sort_by_digest = sort_by_digest_4_8;
9585 opti_type = OPTI_TYPE_ZERO_BYTE;
9586 dgst_pos0 = 0;
9587 dgst_pos1 = 1;
9588 dgst_pos2 = 2;
9589 dgst_pos3 = 3;
9590 break;
9591
9592 case 7100: hash_type = HASH_TYPE_SHA512;
9593 salt_type = SALT_TYPE_EMBEDDED;
9594 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9595 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9596 kern_type = KERN_TYPE_PBKDF2_SHA512;
9597 dgst_size = DGST_SIZE_8_16;
9598 parse_func = sha512osx_parse_hash;
9599 sort_by_digest = sort_by_digest_8_16;
9600 opti_type = OPTI_TYPE_ZERO_BYTE
9601 | OPTI_TYPE_USES_BITS_64
9602 | OPTI_TYPE_SLOW_HASH_SIMD;
9603 dgst_pos0 = 0;
9604 dgst_pos1 = 1;
9605 dgst_pos2 = 2;
9606 dgst_pos3 = 3;
9607 break;
9608
9609 case 7200: hash_type = HASH_TYPE_SHA512;
9610 salt_type = SALT_TYPE_EMBEDDED;
9611 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9612 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9613 kern_type = KERN_TYPE_PBKDF2_SHA512;
9614 dgst_size = DGST_SIZE_8_16;
9615 parse_func = sha512grub_parse_hash;
9616 sort_by_digest = sort_by_digest_8_16;
9617 opti_type = OPTI_TYPE_ZERO_BYTE
9618 | OPTI_TYPE_USES_BITS_64
9619 | OPTI_TYPE_SLOW_HASH_SIMD;
9620 dgst_pos0 = 0;
9621 dgst_pos1 = 1;
9622 dgst_pos2 = 2;
9623 dgst_pos3 = 3;
9624 break;
9625
9626 case 7300: hash_type = HASH_TYPE_SHA1;
9627 salt_type = SALT_TYPE_EMBEDDED;
9628 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9629 opts_type = OPTS_TYPE_PT_GENERATE_BE
9630 | OPTS_TYPE_ST_ADD80
9631 | OPTS_TYPE_ST_ADDBITS15;
9632 kern_type = KERN_TYPE_RAKP;
9633 dgst_size = DGST_SIZE_4_5;
9634 parse_func = rakp_parse_hash;
9635 sort_by_digest = sort_by_digest_4_5;
9636 opti_type = OPTI_TYPE_ZERO_BYTE
9637 | OPTI_TYPE_NOT_ITERATED;
9638 dgst_pos0 = 3;
9639 dgst_pos1 = 4;
9640 dgst_pos2 = 2;
9641 dgst_pos3 = 1;
9642 break;
9643
9644 case 7400: hash_type = HASH_TYPE_SHA256;
9645 salt_type = SALT_TYPE_EMBEDDED;
9646 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9647 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9648 kern_type = KERN_TYPE_SHA256CRYPT;
9649 dgst_size = DGST_SIZE_4_8;
9650 parse_func = sha256crypt_parse_hash;
9651 sort_by_digest = sort_by_digest_4_8;
9652 opti_type = OPTI_TYPE_ZERO_BYTE;
9653 dgst_pos0 = 0;
9654 dgst_pos1 = 1;
9655 dgst_pos2 = 2;
9656 dgst_pos3 = 3;
9657 break;
9658
9659 case 7500: hash_type = HASH_TYPE_KRB5PA;
9660 salt_type = SALT_TYPE_EMBEDDED;
9661 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9662 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9663 kern_type = KERN_TYPE_KRB5PA;
9664 dgst_size = DGST_SIZE_4_4;
9665 parse_func = krb5pa_parse_hash;
9666 sort_by_digest = sort_by_digest_4_4;
9667 opti_type = OPTI_TYPE_ZERO_BYTE
9668 | OPTI_TYPE_NOT_ITERATED;
9669 dgst_pos0 = 0;
9670 dgst_pos1 = 1;
9671 dgst_pos2 = 2;
9672 dgst_pos3 = 3;
9673 break;
9674
9675 case 7600: hash_type = HASH_TYPE_SHA1;
9676 salt_type = SALT_TYPE_INTERN;
9677 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9678 opts_type = OPTS_TYPE_PT_GENERATE_BE
9679 | OPTS_TYPE_PT_ADD80
9680 | OPTS_TYPE_PT_ADDBITS15;
9681 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9682 dgst_size = DGST_SIZE_4_5;
9683 parse_func = redmine_parse_hash;
9684 sort_by_digest = sort_by_digest_4_5;
9685 opti_type = OPTI_TYPE_ZERO_BYTE
9686 | OPTI_TYPE_PRECOMPUTE_INIT
9687 | OPTI_TYPE_EARLY_SKIP
9688 | OPTI_TYPE_NOT_ITERATED
9689 | OPTI_TYPE_PREPENDED_SALT;
9690 dgst_pos0 = 3;
9691 dgst_pos1 = 4;
9692 dgst_pos2 = 2;
9693 dgst_pos3 = 1;
9694 break;
9695
9696 case 7700: hash_type = HASH_TYPE_SAPB;
9697 salt_type = SALT_TYPE_EMBEDDED;
9698 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9699 opts_type = OPTS_TYPE_PT_GENERATE_LE
9700 | OPTS_TYPE_PT_UPPER
9701 | OPTS_TYPE_ST_UPPER;
9702 kern_type = KERN_TYPE_SAPB;
9703 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9704 parse_func = sapb_parse_hash;
9705 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9706 opti_type = OPTI_TYPE_ZERO_BYTE
9707 | OPTI_TYPE_PRECOMPUTE_INIT
9708 | OPTI_TYPE_NOT_ITERATED;
9709 dgst_pos0 = 0;
9710 dgst_pos1 = 1;
9711 dgst_pos2 = 2;
9712 dgst_pos3 = 3;
9713 break;
9714
9715 case 7800: hash_type = HASH_TYPE_SAPG;
9716 salt_type = SALT_TYPE_EMBEDDED;
9717 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9718 opts_type = OPTS_TYPE_PT_GENERATE_BE
9719 | OPTS_TYPE_ST_ADD80
9720 | OPTS_TYPE_ST_UPPER;
9721 kern_type = KERN_TYPE_SAPG;
9722 dgst_size = DGST_SIZE_4_5;
9723 parse_func = sapg_parse_hash;
9724 sort_by_digest = sort_by_digest_4_5;
9725 opti_type = OPTI_TYPE_ZERO_BYTE
9726 | OPTI_TYPE_PRECOMPUTE_INIT
9727 | OPTI_TYPE_NOT_ITERATED;
9728 dgst_pos0 = 3;
9729 dgst_pos1 = 4;
9730 dgst_pos2 = 2;
9731 dgst_pos3 = 1;
9732 break;
9733
9734 case 7900: hash_type = HASH_TYPE_SHA512;
9735 salt_type = SALT_TYPE_EMBEDDED;
9736 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9737 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9738 kern_type = KERN_TYPE_DRUPAL7;
9739 dgst_size = DGST_SIZE_8_8;
9740 parse_func = drupal7_parse_hash;
9741 sort_by_digest = sort_by_digest_8_8;
9742 opti_type = OPTI_TYPE_ZERO_BYTE
9743 | OPTI_TYPE_USES_BITS_64;
9744 dgst_pos0 = 0;
9745 dgst_pos1 = 1;
9746 dgst_pos2 = 2;
9747 dgst_pos3 = 3;
9748 break;
9749
9750 case 8000: hash_type = HASH_TYPE_SHA256;
9751 salt_type = SALT_TYPE_EMBEDDED;
9752 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9753 opts_type = OPTS_TYPE_PT_GENERATE_BE
9754 | OPTS_TYPE_PT_UNICODE
9755 | OPTS_TYPE_ST_ADD80
9756 | OPTS_TYPE_ST_HEX;
9757 kern_type = KERN_TYPE_SYBASEASE;
9758 dgst_size = DGST_SIZE_4_8;
9759 parse_func = sybasease_parse_hash;
9760 sort_by_digest = sort_by_digest_4_8;
9761 opti_type = OPTI_TYPE_ZERO_BYTE
9762 | OPTI_TYPE_PRECOMPUTE_INIT
9763 | OPTI_TYPE_EARLY_SKIP
9764 | OPTI_TYPE_NOT_ITERATED
9765 | OPTI_TYPE_RAW_HASH;
9766 dgst_pos0 = 3;
9767 dgst_pos1 = 7;
9768 dgst_pos2 = 2;
9769 dgst_pos3 = 6;
9770 break;
9771
9772 case 8100: hash_type = HASH_TYPE_SHA1;
9773 salt_type = SALT_TYPE_EMBEDDED;
9774 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9775 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9776 kern_type = KERN_TYPE_NETSCALER;
9777 dgst_size = DGST_SIZE_4_5;
9778 parse_func = netscaler_parse_hash;
9779 sort_by_digest = sort_by_digest_4_5;
9780 opti_type = OPTI_TYPE_ZERO_BYTE
9781 | OPTI_TYPE_PRECOMPUTE_INIT
9782 | OPTI_TYPE_PRECOMPUTE_MERKLE
9783 | OPTI_TYPE_EARLY_SKIP
9784 | OPTI_TYPE_NOT_ITERATED
9785 | OPTI_TYPE_PREPENDED_SALT
9786 | OPTI_TYPE_RAW_HASH;
9787 dgst_pos0 = 3;
9788 dgst_pos1 = 4;
9789 dgst_pos2 = 2;
9790 dgst_pos3 = 1;
9791 break;
9792
9793 case 8200: hash_type = HASH_TYPE_SHA256;
9794 salt_type = SALT_TYPE_EMBEDDED;
9795 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9796 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9797 kern_type = KERN_TYPE_CLOUDKEY;
9798 dgst_size = DGST_SIZE_4_8;
9799 parse_func = cloudkey_parse_hash;
9800 sort_by_digest = sort_by_digest_4_8;
9801 opti_type = OPTI_TYPE_ZERO_BYTE;
9802 dgst_pos0 = 0;
9803 dgst_pos1 = 1;
9804 dgst_pos2 = 2;
9805 dgst_pos3 = 3;
9806 break;
9807
9808 case 8300: hash_type = HASH_TYPE_SHA1;
9809 salt_type = SALT_TYPE_EMBEDDED;
9810 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9811 opts_type = OPTS_TYPE_PT_GENERATE_BE
9812 | OPTS_TYPE_ST_HEX
9813 | OPTS_TYPE_ST_ADD80;
9814 kern_type = KERN_TYPE_NSEC3;
9815 dgst_size = DGST_SIZE_4_5;
9816 parse_func = nsec3_parse_hash;
9817 sort_by_digest = sort_by_digest_4_5;
9818 opti_type = OPTI_TYPE_ZERO_BYTE;
9819 dgst_pos0 = 3;
9820 dgst_pos1 = 4;
9821 dgst_pos2 = 2;
9822 dgst_pos3 = 1;
9823 break;
9824
9825 case 8400: hash_type = HASH_TYPE_SHA1;
9826 salt_type = SALT_TYPE_INTERN;
9827 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9828 opts_type = OPTS_TYPE_PT_GENERATE_BE
9829 | OPTS_TYPE_PT_ADD80
9830 | OPTS_TYPE_PT_ADDBITS15;
9831 kern_type = KERN_TYPE_WBB3;
9832 dgst_size = DGST_SIZE_4_5;
9833 parse_func = wbb3_parse_hash;
9834 sort_by_digest = sort_by_digest_4_5;
9835 opti_type = OPTI_TYPE_ZERO_BYTE
9836 | OPTI_TYPE_PRECOMPUTE_INIT
9837 | OPTI_TYPE_NOT_ITERATED;
9838 dgst_pos0 = 3;
9839 dgst_pos1 = 4;
9840 dgst_pos2 = 2;
9841 dgst_pos3 = 1;
9842 break;
9843
9844 case 8500: hash_type = HASH_TYPE_DESRACF;
9845 salt_type = SALT_TYPE_EMBEDDED;
9846 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9847 opts_type = OPTS_TYPE_PT_GENERATE_LE
9848 | OPTS_TYPE_ST_UPPER;
9849 kern_type = KERN_TYPE_RACF;
9850 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9851 parse_func = racf_parse_hash;
9852 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9853 opti_type = OPTI_TYPE_ZERO_BYTE
9854 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9855 dgst_pos0 = 0;
9856 dgst_pos1 = 1;
9857 dgst_pos2 = 2;
9858 dgst_pos3 = 3;
9859 break;
9860
9861 case 8600: hash_type = HASH_TYPE_LOTUS5;
9862 salt_type = SALT_TYPE_NONE;
9863 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9864 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9865 kern_type = KERN_TYPE_LOTUS5;
9866 dgst_size = DGST_SIZE_4_4;
9867 parse_func = lotus5_parse_hash;
9868 sort_by_digest = sort_by_digest_4_4;
9869 opti_type = OPTI_TYPE_EARLY_SKIP
9870 | OPTI_TYPE_NOT_ITERATED
9871 | OPTI_TYPE_NOT_SALTED
9872 | OPTI_TYPE_RAW_HASH;
9873 dgst_pos0 = 0;
9874 dgst_pos1 = 1;
9875 dgst_pos2 = 2;
9876 dgst_pos3 = 3;
9877 break;
9878
9879 case 8700: hash_type = HASH_TYPE_LOTUS6;
9880 salt_type = SALT_TYPE_EMBEDDED;
9881 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9882 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9883 kern_type = KERN_TYPE_LOTUS6;
9884 dgst_size = DGST_SIZE_4_4;
9885 parse_func = lotus6_parse_hash;
9886 sort_by_digest = sort_by_digest_4_4;
9887 opti_type = OPTI_TYPE_EARLY_SKIP
9888 | OPTI_TYPE_NOT_ITERATED
9889 | OPTI_TYPE_RAW_HASH;
9890 dgst_pos0 = 0;
9891 dgst_pos1 = 1;
9892 dgst_pos2 = 2;
9893 dgst_pos3 = 3;
9894 break;
9895
9896 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9897 salt_type = SALT_TYPE_EMBEDDED;
9898 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9899 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9900 kern_type = KERN_TYPE_ANDROIDFDE;
9901 dgst_size = DGST_SIZE_4_4;
9902 parse_func = androidfde_parse_hash;
9903 sort_by_digest = sort_by_digest_4_4;
9904 opti_type = OPTI_TYPE_ZERO_BYTE;
9905 dgst_pos0 = 0;
9906 dgst_pos1 = 1;
9907 dgst_pos2 = 2;
9908 dgst_pos3 = 3;
9909 break;
9910
9911 case 8900: hash_type = HASH_TYPE_SCRYPT;
9912 salt_type = SALT_TYPE_EMBEDDED;
9913 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9914 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9915 kern_type = KERN_TYPE_SCRYPT;
9916 dgst_size = DGST_SIZE_4_8;
9917 parse_func = scrypt_parse_hash;
9918 sort_by_digest = sort_by_digest_4_8;
9919 opti_type = OPTI_TYPE_ZERO_BYTE;
9920 dgst_pos0 = 0;
9921 dgst_pos1 = 1;
9922 dgst_pos2 = 2;
9923 dgst_pos3 = 3;
9924 break;
9925
9926 case 9000: hash_type = HASH_TYPE_SHA1;
9927 salt_type = SALT_TYPE_EMBEDDED;
9928 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9929 opts_type = OPTS_TYPE_PT_GENERATE_LE
9930 | OPTS_TYPE_ST_GENERATE_LE;
9931 kern_type = KERN_TYPE_PSAFE2;
9932 dgst_size = DGST_SIZE_4_5;
9933 parse_func = psafe2_parse_hash;
9934 sort_by_digest = sort_by_digest_4_5;
9935 opti_type = OPTI_TYPE_ZERO_BYTE;
9936 dgst_pos0 = 0;
9937 dgst_pos1 = 1;
9938 dgst_pos2 = 2;
9939 dgst_pos3 = 3;
9940 break;
9941
9942 case 9100: hash_type = HASH_TYPE_LOTUS8;
9943 salt_type = SALT_TYPE_EMBEDDED;
9944 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9945 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9946 kern_type = KERN_TYPE_LOTUS8;
9947 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9948 parse_func = lotus8_parse_hash;
9949 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9950 opti_type = OPTI_TYPE_ZERO_BYTE;
9951 dgst_pos0 = 0;
9952 dgst_pos1 = 1;
9953 dgst_pos2 = 2;
9954 dgst_pos3 = 3;
9955 break;
9956
9957 case 9200: hash_type = HASH_TYPE_SHA256;
9958 salt_type = SALT_TYPE_EMBEDDED;
9959 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9960 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9961 kern_type = KERN_TYPE_PBKDF2_SHA256;
9962 dgst_size = DGST_SIZE_4_32;
9963 parse_func = cisco8_parse_hash;
9964 sort_by_digest = sort_by_digest_4_32;
9965 opti_type = OPTI_TYPE_ZERO_BYTE
9966 | OPTI_TYPE_SLOW_HASH_SIMD;
9967 dgst_pos0 = 0;
9968 dgst_pos1 = 1;
9969 dgst_pos2 = 2;
9970 dgst_pos3 = 3;
9971 break;
9972
9973 case 9300: hash_type = HASH_TYPE_SCRYPT;
9974 salt_type = SALT_TYPE_EMBEDDED;
9975 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9976 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9977 kern_type = KERN_TYPE_SCRYPT;
9978 dgst_size = DGST_SIZE_4_8;
9979 parse_func = cisco9_parse_hash;
9980 sort_by_digest = sort_by_digest_4_8;
9981 opti_type = OPTI_TYPE_ZERO_BYTE;
9982 dgst_pos0 = 0;
9983 dgst_pos1 = 1;
9984 dgst_pos2 = 2;
9985 dgst_pos3 = 3;
9986 break;
9987
9988 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9989 salt_type = SALT_TYPE_EMBEDDED;
9990 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9991 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9992 kern_type = KERN_TYPE_OFFICE2007;
9993 dgst_size = DGST_SIZE_4_4;
9994 parse_func = office2007_parse_hash;
9995 sort_by_digest = sort_by_digest_4_4;
9996 opti_type = OPTI_TYPE_ZERO_BYTE;
9997 dgst_pos0 = 0;
9998 dgst_pos1 = 1;
9999 dgst_pos2 = 2;
10000 dgst_pos3 = 3;
10001 break;
10002
10003 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10004 salt_type = SALT_TYPE_EMBEDDED;
10005 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10006 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10007 kern_type = KERN_TYPE_OFFICE2010;
10008 dgst_size = DGST_SIZE_4_4;
10009 parse_func = office2010_parse_hash;
10010 sort_by_digest = sort_by_digest_4_4;
10011 opti_type = OPTI_TYPE_ZERO_BYTE;
10012 dgst_pos0 = 0;
10013 dgst_pos1 = 1;
10014 dgst_pos2 = 2;
10015 dgst_pos3 = 3;
10016 break;
10017
10018 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10019 salt_type = SALT_TYPE_EMBEDDED;
10020 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10021 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10022 kern_type = KERN_TYPE_OFFICE2013;
10023 dgst_size = DGST_SIZE_4_4;
10024 parse_func = office2013_parse_hash;
10025 sort_by_digest = sort_by_digest_4_4;
10026 opti_type = OPTI_TYPE_ZERO_BYTE;
10027 dgst_pos0 = 0;
10028 dgst_pos1 = 1;
10029 dgst_pos2 = 2;
10030 dgst_pos3 = 3;
10031 break;
10032
10033 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10034 salt_type = SALT_TYPE_EMBEDDED;
10035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10036 opts_type = OPTS_TYPE_PT_GENERATE_LE
10037 | OPTS_TYPE_PT_ADD80
10038 | OPTS_TYPE_PT_UNICODE;
10039 kern_type = KERN_TYPE_OLDOFFICE01;
10040 dgst_size = DGST_SIZE_4_4;
10041 parse_func = oldoffice01_parse_hash;
10042 sort_by_digest = sort_by_digest_4_4;
10043 opti_type = OPTI_TYPE_ZERO_BYTE
10044 | OPTI_TYPE_PRECOMPUTE_INIT
10045 | OPTI_TYPE_NOT_ITERATED;
10046 dgst_pos0 = 0;
10047 dgst_pos1 = 1;
10048 dgst_pos2 = 2;
10049 dgst_pos3 = 3;
10050 break;
10051
10052 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10053 salt_type = SALT_TYPE_EMBEDDED;
10054 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10055 opts_type = OPTS_TYPE_PT_GENERATE_LE
10056 | OPTS_TYPE_PT_ADD80;
10057 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10058 dgst_size = DGST_SIZE_4_4;
10059 parse_func = oldoffice01cm1_parse_hash;
10060 sort_by_digest = sort_by_digest_4_4;
10061 opti_type = OPTI_TYPE_ZERO_BYTE
10062 | OPTI_TYPE_PRECOMPUTE_INIT
10063 | OPTI_TYPE_NOT_ITERATED;
10064 dgst_pos0 = 0;
10065 dgst_pos1 = 1;
10066 dgst_pos2 = 2;
10067 dgst_pos3 = 3;
10068 break;
10069
10070 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10071 salt_type = SALT_TYPE_EMBEDDED;
10072 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10073 opts_type = OPTS_TYPE_PT_GENERATE_LE
10074 | OPTS_TYPE_PT_ADD80
10075 | OPTS_TYPE_PT_UNICODE
10076 | OPTS_TYPE_PT_NEVERCRACK;
10077 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10078 dgst_size = DGST_SIZE_4_4;
10079 parse_func = oldoffice01cm2_parse_hash;
10080 sort_by_digest = sort_by_digest_4_4;
10081 opti_type = OPTI_TYPE_ZERO_BYTE
10082 | OPTI_TYPE_PRECOMPUTE_INIT
10083 | OPTI_TYPE_NOT_ITERATED;
10084 dgst_pos0 = 0;
10085 dgst_pos1 = 1;
10086 dgst_pos2 = 2;
10087 dgst_pos3 = 3;
10088 break;
10089
10090 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10091 salt_type = SALT_TYPE_EMBEDDED;
10092 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10093 opts_type = OPTS_TYPE_PT_GENERATE_BE
10094 | OPTS_TYPE_PT_ADD80
10095 | OPTS_TYPE_PT_UNICODE;
10096 kern_type = KERN_TYPE_OLDOFFICE34;
10097 dgst_size = DGST_SIZE_4_4;
10098 parse_func = oldoffice34_parse_hash;
10099 sort_by_digest = sort_by_digest_4_4;
10100 opti_type = OPTI_TYPE_ZERO_BYTE
10101 | OPTI_TYPE_PRECOMPUTE_INIT
10102 | OPTI_TYPE_NOT_ITERATED;
10103 dgst_pos0 = 0;
10104 dgst_pos1 = 1;
10105 dgst_pos2 = 2;
10106 dgst_pos3 = 3;
10107 break;
10108
10109 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10110 salt_type = SALT_TYPE_EMBEDDED;
10111 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10112 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10113 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10114 dgst_size = DGST_SIZE_4_4;
10115 parse_func = oldoffice34cm1_parse_hash;
10116 sort_by_digest = sort_by_digest_4_4;
10117 opti_type = OPTI_TYPE_ZERO_BYTE
10118 | OPTI_TYPE_PRECOMPUTE_INIT
10119 | OPTI_TYPE_NOT_ITERATED;
10120 dgst_pos0 = 0;
10121 dgst_pos1 = 1;
10122 dgst_pos2 = 2;
10123 dgst_pos3 = 3;
10124 break;
10125
10126 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10127 salt_type = SALT_TYPE_EMBEDDED;
10128 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10129 opts_type = OPTS_TYPE_PT_GENERATE_BE
10130 | OPTS_TYPE_PT_ADD80
10131 | OPTS_TYPE_PT_UNICODE
10132 | OPTS_TYPE_PT_NEVERCRACK;
10133 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10134 dgst_size = DGST_SIZE_4_4;
10135 parse_func = oldoffice34cm2_parse_hash;
10136 sort_by_digest = sort_by_digest_4_4;
10137 opti_type = OPTI_TYPE_ZERO_BYTE
10138 | OPTI_TYPE_PRECOMPUTE_INIT
10139 | OPTI_TYPE_NOT_ITERATED;
10140 dgst_pos0 = 0;
10141 dgst_pos1 = 1;
10142 dgst_pos2 = 2;
10143 dgst_pos3 = 3;
10144 break;
10145
10146 case 9900: hash_type = HASH_TYPE_MD5;
10147 salt_type = SALT_TYPE_NONE;
10148 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10149 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10150 kern_type = KERN_TYPE_RADMIN2;
10151 dgst_size = DGST_SIZE_4_4;
10152 parse_func = radmin2_parse_hash;
10153 sort_by_digest = sort_by_digest_4_4;
10154 opti_type = OPTI_TYPE_ZERO_BYTE
10155 | OPTI_TYPE_PRECOMPUTE_INIT
10156 | OPTI_TYPE_EARLY_SKIP
10157 | OPTI_TYPE_NOT_ITERATED
10158 | OPTI_TYPE_NOT_SALTED;
10159 dgst_pos0 = 0;
10160 dgst_pos1 = 3;
10161 dgst_pos2 = 2;
10162 dgst_pos3 = 1;
10163 break;
10164
10165 case 10000: hash_type = HASH_TYPE_SHA256;
10166 salt_type = SALT_TYPE_EMBEDDED;
10167 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10168 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10169 kern_type = KERN_TYPE_PBKDF2_SHA256;
10170 dgst_size = DGST_SIZE_4_32;
10171 parse_func = djangopbkdf2_parse_hash;
10172 sort_by_digest = sort_by_digest_4_32;
10173 opti_type = OPTI_TYPE_ZERO_BYTE
10174 | OPTI_TYPE_SLOW_HASH_SIMD;
10175 dgst_pos0 = 0;
10176 dgst_pos1 = 1;
10177 dgst_pos2 = 2;
10178 dgst_pos3 = 3;
10179 break;
10180
10181 case 10100: hash_type = HASH_TYPE_SIPHASH;
10182 salt_type = SALT_TYPE_EMBEDDED;
10183 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10184 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10185 kern_type = KERN_TYPE_SIPHASH;
10186 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10187 parse_func = siphash_parse_hash;
10188 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10189 opti_type = OPTI_TYPE_ZERO_BYTE
10190 | OPTI_TYPE_NOT_ITERATED
10191 | OPTI_TYPE_RAW_HASH;
10192 dgst_pos0 = 0;
10193 dgst_pos1 = 1;
10194 dgst_pos2 = 2;
10195 dgst_pos3 = 3;
10196 break;
10197
10198 case 10200: hash_type = HASH_TYPE_MD5;
10199 salt_type = SALT_TYPE_EMBEDDED;
10200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10201 opts_type = OPTS_TYPE_PT_GENERATE_LE
10202 | OPTS_TYPE_ST_ADD80
10203 | OPTS_TYPE_ST_ADDBITS14;
10204 kern_type = KERN_TYPE_HMACMD5_PW;
10205 dgst_size = DGST_SIZE_4_4;
10206 parse_func = crammd5_parse_hash;
10207 sort_by_digest = sort_by_digest_4_4;
10208 opti_type = OPTI_TYPE_ZERO_BYTE
10209 | OPTI_TYPE_NOT_ITERATED;
10210 dgst_pos0 = 0;
10211 dgst_pos1 = 3;
10212 dgst_pos2 = 2;
10213 dgst_pos3 = 1;
10214 break;
10215
10216 case 10300: hash_type = HASH_TYPE_SHA1;
10217 salt_type = SALT_TYPE_EMBEDDED;
10218 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10219 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10220 kern_type = KERN_TYPE_SAPH_SHA1;
10221 dgst_size = DGST_SIZE_4_5;
10222 parse_func = saph_sha1_parse_hash;
10223 sort_by_digest = sort_by_digest_4_5;
10224 opti_type = OPTI_TYPE_ZERO_BYTE;
10225 dgst_pos0 = 0;
10226 dgst_pos1 = 1;
10227 dgst_pos2 = 2;
10228 dgst_pos3 = 3;
10229 break;
10230
10231 case 10400: hash_type = HASH_TYPE_PDFU16;
10232 salt_type = SALT_TYPE_EMBEDDED;
10233 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10234 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10235 kern_type = KERN_TYPE_PDF11;
10236 dgst_size = DGST_SIZE_4_4;
10237 parse_func = pdf11_parse_hash;
10238 sort_by_digest = sort_by_digest_4_4;
10239 opti_type = OPTI_TYPE_ZERO_BYTE
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 10410: hash_type = HASH_TYPE_PDFU16;
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_PDF11CM1;
10252 dgst_size = DGST_SIZE_4_4;
10253 parse_func = pdf11cm1_parse_hash;
10254 sort_by_digest = sort_by_digest_4_4;
10255 opti_type = OPTI_TYPE_ZERO_BYTE
10256 | OPTI_TYPE_NOT_ITERATED;
10257 dgst_pos0 = 0;
10258 dgst_pos1 = 1;
10259 dgst_pos2 = 2;
10260 dgst_pos3 = 3;
10261 break;
10262
10263 case 10420: hash_type = HASH_TYPE_PDFU16;
10264 salt_type = SALT_TYPE_EMBEDDED;
10265 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10266 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10267 kern_type = KERN_TYPE_PDF11CM2;
10268 dgst_size = DGST_SIZE_4_4;
10269 parse_func = pdf11cm2_parse_hash;
10270 sort_by_digest = sort_by_digest_4_4;
10271 opti_type = OPTI_TYPE_ZERO_BYTE
10272 | OPTI_TYPE_NOT_ITERATED;
10273 dgst_pos0 = 0;
10274 dgst_pos1 = 1;
10275 dgst_pos2 = 2;
10276 dgst_pos3 = 3;
10277 break;
10278
10279 case 10500: hash_type = HASH_TYPE_PDFU16;
10280 salt_type = SALT_TYPE_EMBEDDED;
10281 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10282 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10283 kern_type = KERN_TYPE_PDF14;
10284 dgst_size = DGST_SIZE_4_4;
10285 parse_func = pdf14_parse_hash;
10286 sort_by_digest = sort_by_digest_4_4;
10287 opti_type = OPTI_TYPE_ZERO_BYTE
10288 | OPTI_TYPE_NOT_ITERATED;
10289 dgst_pos0 = 0;
10290 dgst_pos1 = 1;
10291 dgst_pos2 = 2;
10292 dgst_pos3 = 3;
10293 break;
10294
10295 case 10600: hash_type = HASH_TYPE_SHA256;
10296 salt_type = SALT_TYPE_EMBEDDED;
10297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10298 opts_type = OPTS_TYPE_PT_GENERATE_BE
10299 | OPTS_TYPE_ST_ADD80
10300 | OPTS_TYPE_ST_ADDBITS15
10301 | OPTS_TYPE_HASH_COPY;
10302 kern_type = KERN_TYPE_SHA256_PWSLT;
10303 dgst_size = DGST_SIZE_4_8;
10304 parse_func = pdf17l3_parse_hash;
10305 sort_by_digest = sort_by_digest_4_8;
10306 opti_type = OPTI_TYPE_ZERO_BYTE
10307 | OPTI_TYPE_PRECOMPUTE_INIT
10308 | OPTI_TYPE_PRECOMPUTE_MERKLE
10309 | OPTI_TYPE_EARLY_SKIP
10310 | OPTI_TYPE_NOT_ITERATED
10311 | OPTI_TYPE_APPENDED_SALT
10312 | OPTI_TYPE_RAW_HASH;
10313 dgst_pos0 = 3;
10314 dgst_pos1 = 7;
10315 dgst_pos2 = 2;
10316 dgst_pos3 = 6;
10317 break;
10318
10319 case 10700: hash_type = HASH_TYPE_PDFU32;
10320 salt_type = SALT_TYPE_EMBEDDED;
10321 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10322 opts_type = OPTS_TYPE_PT_GENERATE_LE
10323 | OPTS_TYPE_HASH_COPY;
10324 kern_type = KERN_TYPE_PDF17L8;
10325 dgst_size = DGST_SIZE_4_8;
10326 parse_func = pdf17l8_parse_hash;
10327 sort_by_digest = sort_by_digest_4_8;
10328 opti_type = OPTI_TYPE_ZERO_BYTE
10329 | OPTI_TYPE_NOT_ITERATED;
10330 dgst_pos0 = 0;
10331 dgst_pos1 = 1;
10332 dgst_pos2 = 2;
10333 dgst_pos3 = 3;
10334 break;
10335
10336 case 10800: hash_type = HASH_TYPE_SHA384;
10337 salt_type = SALT_TYPE_NONE;
10338 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10339 opts_type = OPTS_TYPE_PT_GENERATE_BE
10340 | OPTS_TYPE_PT_ADD80
10341 | OPTS_TYPE_PT_ADDBITS15;
10342 kern_type = KERN_TYPE_SHA384;
10343 dgst_size = DGST_SIZE_8_8;
10344 parse_func = sha384_parse_hash;
10345 sort_by_digest = sort_by_digest_8_8;
10346 opti_type = OPTI_TYPE_ZERO_BYTE
10347 | OPTI_TYPE_PRECOMPUTE_INIT
10348 | OPTI_TYPE_PRECOMPUTE_MERKLE
10349 | OPTI_TYPE_EARLY_SKIP
10350 | OPTI_TYPE_NOT_ITERATED
10351 | OPTI_TYPE_NOT_SALTED
10352 | OPTI_TYPE_USES_BITS_64
10353 | OPTI_TYPE_RAW_HASH;
10354 dgst_pos0 = 6;
10355 dgst_pos1 = 7;
10356 dgst_pos2 = 4;
10357 dgst_pos3 = 5;
10358 break;
10359
10360 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10361 salt_type = SALT_TYPE_EMBEDDED;
10362 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10363 opts_type = OPTS_TYPE_PT_GENERATE_LE
10364 | OPTS_TYPE_ST_BASE64
10365 | OPTS_TYPE_HASH_COPY;
10366 kern_type = KERN_TYPE_PBKDF2_SHA256;
10367 dgst_size = DGST_SIZE_4_32;
10368 parse_func = pbkdf2_sha256_parse_hash;
10369 sort_by_digest = sort_by_digest_4_32;
10370 opti_type = OPTI_TYPE_ZERO_BYTE
10371 | OPTI_TYPE_SLOW_HASH_SIMD;
10372 dgst_pos0 = 0;
10373 dgst_pos1 = 1;
10374 dgst_pos2 = 2;
10375 dgst_pos3 = 3;
10376 break;
10377
10378 case 11000: hash_type = HASH_TYPE_MD5;
10379 salt_type = SALT_TYPE_INTERN;
10380 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10381 opts_type = OPTS_TYPE_PT_GENERATE_LE
10382 | OPTS_TYPE_PT_ADD80;
10383 kern_type = KERN_TYPE_PRESTASHOP;
10384 dgst_size = DGST_SIZE_4_4;
10385 parse_func = prestashop_parse_hash;
10386 sort_by_digest = sort_by_digest_4_4;
10387 opti_type = OPTI_TYPE_ZERO_BYTE
10388 | OPTI_TYPE_PRECOMPUTE_INIT
10389 | OPTI_TYPE_NOT_ITERATED
10390 | OPTI_TYPE_PREPENDED_SALT;
10391 dgst_pos0 = 0;
10392 dgst_pos1 = 3;
10393 dgst_pos2 = 2;
10394 dgst_pos3 = 1;
10395 break;
10396
10397 case 11100: hash_type = HASH_TYPE_MD5;
10398 salt_type = SALT_TYPE_EMBEDDED;
10399 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10400 opts_type = OPTS_TYPE_PT_GENERATE_LE
10401 | OPTS_TYPE_ST_ADD80;
10402 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10403 dgst_size = DGST_SIZE_4_4;
10404 parse_func = postgresql_auth_parse_hash;
10405 sort_by_digest = sort_by_digest_4_4;
10406 opti_type = OPTI_TYPE_ZERO_BYTE
10407 | OPTI_TYPE_PRECOMPUTE_INIT
10408 | OPTI_TYPE_PRECOMPUTE_MERKLE
10409 | OPTI_TYPE_EARLY_SKIP;
10410 dgst_pos0 = 0;
10411 dgst_pos1 = 3;
10412 dgst_pos2 = 2;
10413 dgst_pos3 = 1;
10414 break;
10415
10416 case 11200: hash_type = HASH_TYPE_SHA1;
10417 salt_type = SALT_TYPE_EMBEDDED;
10418 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10419 opts_type = OPTS_TYPE_PT_GENERATE_BE
10420 | OPTS_TYPE_PT_ADD80
10421 | OPTS_TYPE_ST_HEX;
10422 kern_type = KERN_TYPE_MYSQL_AUTH;
10423 dgst_size = DGST_SIZE_4_5;
10424 parse_func = mysql_auth_parse_hash;
10425 sort_by_digest = sort_by_digest_4_5;
10426 opti_type = OPTI_TYPE_ZERO_BYTE
10427 | OPTI_TYPE_EARLY_SKIP;
10428 dgst_pos0 = 3;
10429 dgst_pos1 = 4;
10430 dgst_pos2 = 2;
10431 dgst_pos3 = 1;
10432 break;
10433
10434 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10435 salt_type = SALT_TYPE_EMBEDDED;
10436 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10437 opts_type = OPTS_TYPE_PT_GENERATE_LE
10438 | OPTS_TYPE_ST_HEX
10439 | OPTS_TYPE_ST_ADD80;
10440 kern_type = KERN_TYPE_BITCOIN_WALLET;
10441 dgst_size = DGST_SIZE_4_4;
10442 parse_func = bitcoin_wallet_parse_hash;
10443 sort_by_digest = sort_by_digest_4_4;
10444 opti_type = OPTI_TYPE_ZERO_BYTE;
10445 dgst_pos0 = 0;
10446 dgst_pos1 = 1;
10447 dgst_pos2 = 2;
10448 dgst_pos3 = 3;
10449 break;
10450
10451 case 11400: hash_type = HASH_TYPE_MD5;
10452 salt_type = SALT_TYPE_EMBEDDED;
10453 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10454 opts_type = OPTS_TYPE_PT_GENERATE_LE
10455 | OPTS_TYPE_PT_ADD80
10456 | OPTS_TYPE_HASH_COPY;
10457 kern_type = KERN_TYPE_SIP_AUTH;
10458 dgst_size = DGST_SIZE_4_4;
10459 parse_func = sip_auth_parse_hash;
10460 sort_by_digest = sort_by_digest_4_4;
10461 opti_type = OPTI_TYPE_ZERO_BYTE;
10462 dgst_pos0 = 0;
10463 dgst_pos1 = 3;
10464 dgst_pos2 = 2;
10465 dgst_pos3 = 1;
10466 break;
10467
10468 case 11500: hash_type = HASH_TYPE_CRC32;
10469 salt_type = SALT_TYPE_INTERN;
10470 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10471 opts_type = OPTS_TYPE_PT_GENERATE_LE
10472 | OPTS_TYPE_ST_GENERATE_LE
10473 | OPTS_TYPE_ST_HEX;
10474 kern_type = KERN_TYPE_CRC32;
10475 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10476 parse_func = crc32_parse_hash;
10477 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10478 opti_type = OPTI_TYPE_ZERO_BYTE;
10479 dgst_pos0 = 0;
10480 dgst_pos1 = 1;
10481 dgst_pos2 = 2;
10482 dgst_pos3 = 3;
10483 break;
10484
10485 case 11600: hash_type = HASH_TYPE_AES;
10486 salt_type = SALT_TYPE_EMBEDDED;
10487 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10488 opts_type = OPTS_TYPE_PT_GENERATE_LE
10489 | OPTS_TYPE_PT_NEVERCRACK;
10490 kern_type = KERN_TYPE_SEVEN_ZIP;
10491 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10492 parse_func = seven_zip_parse_hash;
10493 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10494 opti_type = OPTI_TYPE_ZERO_BYTE;
10495 dgst_pos0 = 0;
10496 dgst_pos1 = 1;
10497 dgst_pos2 = 2;
10498 dgst_pos3 = 3;
10499 break;
10500
10501 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10502 salt_type = SALT_TYPE_NONE;
10503 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10504 opts_type = OPTS_TYPE_PT_GENERATE_LE
10505 | OPTS_TYPE_PT_ADD01;
10506 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10507 dgst_size = DGST_SIZE_4_8;
10508 parse_func = gost2012sbog_256_parse_hash;
10509 sort_by_digest = sort_by_digest_4_8;
10510 opti_type = OPTI_TYPE_ZERO_BYTE;
10511 dgst_pos0 = 0;
10512 dgst_pos1 = 1;
10513 dgst_pos2 = 2;
10514 dgst_pos3 = 3;
10515 break;
10516
10517 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10518 salt_type = SALT_TYPE_NONE;
10519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10520 opts_type = OPTS_TYPE_PT_GENERATE_LE
10521 | OPTS_TYPE_PT_ADD01;
10522 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10523 dgst_size = DGST_SIZE_4_16;
10524 parse_func = gost2012sbog_512_parse_hash;
10525 sort_by_digest = sort_by_digest_4_16;
10526 opti_type = OPTI_TYPE_ZERO_BYTE;
10527 dgst_pos0 = 0;
10528 dgst_pos1 = 1;
10529 dgst_pos2 = 2;
10530 dgst_pos3 = 3;
10531 break;
10532
10533 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10534 salt_type = SALT_TYPE_EMBEDDED;
10535 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10536 opts_type = OPTS_TYPE_PT_GENERATE_LE
10537 | OPTS_TYPE_ST_BASE64
10538 | OPTS_TYPE_HASH_COPY;
10539 kern_type = KERN_TYPE_PBKDF2_MD5;
10540 dgst_size = DGST_SIZE_4_32;
10541 parse_func = pbkdf2_md5_parse_hash;
10542 sort_by_digest = sort_by_digest_4_32;
10543 opti_type = OPTI_TYPE_ZERO_BYTE
10544 | OPTI_TYPE_SLOW_HASH_SIMD;
10545 dgst_pos0 = 0;
10546 dgst_pos1 = 1;
10547 dgst_pos2 = 2;
10548 dgst_pos3 = 3;
10549 break;
10550
10551 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10552 salt_type = SALT_TYPE_EMBEDDED;
10553 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10554 opts_type = OPTS_TYPE_PT_GENERATE_LE
10555 | OPTS_TYPE_ST_BASE64
10556 | OPTS_TYPE_HASH_COPY;
10557 kern_type = KERN_TYPE_PBKDF2_SHA1;
10558 dgst_size = DGST_SIZE_4_32;
10559 parse_func = pbkdf2_sha1_parse_hash;
10560 sort_by_digest = sort_by_digest_4_32;
10561 opti_type = OPTI_TYPE_ZERO_BYTE
10562 | OPTI_TYPE_SLOW_HASH_SIMD;
10563 dgst_pos0 = 0;
10564 dgst_pos1 = 1;
10565 dgst_pos2 = 2;
10566 dgst_pos3 = 3;
10567 break;
10568
10569 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10570 salt_type = SALT_TYPE_EMBEDDED;
10571 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10572 opts_type = OPTS_TYPE_PT_GENERATE_LE
10573 | OPTS_TYPE_ST_BASE64
10574 | OPTS_TYPE_HASH_COPY;
10575 kern_type = KERN_TYPE_PBKDF2_SHA512;
10576 dgst_size = DGST_SIZE_8_16;
10577 parse_func = pbkdf2_sha512_parse_hash;
10578 sort_by_digest = sort_by_digest_8_16;
10579 opti_type = OPTI_TYPE_ZERO_BYTE
10580 | OPTI_TYPE_USES_BITS_64
10581 | OPTI_TYPE_SLOW_HASH_SIMD;
10582 dgst_pos0 = 0;
10583 dgst_pos1 = 1;
10584 dgst_pos2 = 2;
10585 dgst_pos3 = 3;
10586 break;
10587
10588 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10589 salt_type = SALT_TYPE_EMBEDDED;
10590 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10591 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10592 kern_type = KERN_TYPE_ECRYPTFS;
10593 dgst_size = DGST_SIZE_8_8;
10594 parse_func = ecryptfs_parse_hash;
10595 sort_by_digest = sort_by_digest_8_8;
10596 opti_type = OPTI_TYPE_ZERO_BYTE
10597 | OPTI_TYPE_USES_BITS_64;
10598 dgst_pos0 = 0;
10599 dgst_pos1 = 1;
10600 dgst_pos2 = 2;
10601 dgst_pos3 = 3;
10602 break;
10603
10604 case 12300: hash_type = HASH_TYPE_ORACLET;
10605 salt_type = SALT_TYPE_EMBEDDED;
10606 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10607 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10608 kern_type = KERN_TYPE_ORACLET;
10609 dgst_size = DGST_SIZE_8_16;
10610 parse_func = oraclet_parse_hash;
10611 sort_by_digest = sort_by_digest_8_16;
10612 opti_type = OPTI_TYPE_ZERO_BYTE
10613 | OPTI_TYPE_USES_BITS_64;
10614 dgst_pos0 = 0;
10615 dgst_pos1 = 1;
10616 dgst_pos2 = 2;
10617 dgst_pos3 = 3;
10618 break;
10619
10620 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10621 salt_type = SALT_TYPE_EMBEDDED;
10622 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10623 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10624 kern_type = KERN_TYPE_BSDICRYPT;
10625 dgst_size = DGST_SIZE_4_4;
10626 parse_func = bsdicrypt_parse_hash;
10627 sort_by_digest = sort_by_digest_4_4;
10628 opti_type = OPTI_TYPE_ZERO_BYTE
10629 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10630 dgst_pos0 = 0;
10631 dgst_pos1 = 1;
10632 dgst_pos2 = 2;
10633 dgst_pos3 = 3;
10634 break;
10635
10636 case 12500: hash_type = HASH_TYPE_RAR3HP;
10637 salt_type = SALT_TYPE_EMBEDDED;
10638 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10639 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10640 kern_type = KERN_TYPE_RAR3;
10641 dgst_size = DGST_SIZE_4_4;
10642 parse_func = rar3hp_parse_hash;
10643 sort_by_digest = sort_by_digest_4_4;
10644 opti_type = OPTI_TYPE_ZERO_BYTE;
10645 dgst_pos0 = 0;
10646 dgst_pos1 = 1;
10647 dgst_pos2 = 2;
10648 dgst_pos3 = 3;
10649 break;
10650
10651 case 12600: hash_type = HASH_TYPE_SHA256;
10652 salt_type = SALT_TYPE_INTERN;
10653 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10654 opts_type = OPTS_TYPE_PT_GENERATE_BE
10655 | OPTS_TYPE_PT_ADD80;
10656 kern_type = KERN_TYPE_CF10;
10657 dgst_size = DGST_SIZE_4_8;
10658 parse_func = cf10_parse_hash;
10659 sort_by_digest = sort_by_digest_4_8;
10660 opti_type = OPTI_TYPE_ZERO_BYTE
10661 | OPTI_TYPE_PRECOMPUTE_INIT
10662 | OPTI_TYPE_EARLY_SKIP
10663 | OPTI_TYPE_NOT_ITERATED;
10664 dgst_pos0 = 3;
10665 dgst_pos1 = 7;
10666 dgst_pos2 = 2;
10667 dgst_pos3 = 6;
10668 break;
10669
10670 case 12700: hash_type = HASH_TYPE_AES;
10671 salt_type = SALT_TYPE_EMBEDDED;
10672 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10673 opts_type = OPTS_TYPE_PT_GENERATE_LE
10674 | OPTS_TYPE_HASH_COPY;
10675 kern_type = KERN_TYPE_MYWALLET;
10676 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10677 parse_func = mywallet_parse_hash;
10678 sort_by_digest = sort_by_digest_4_5;
10679 opti_type = OPTI_TYPE_ZERO_BYTE;
10680 dgst_pos0 = 0;
10681 dgst_pos1 = 1;
10682 dgst_pos2 = 2;
10683 dgst_pos3 = 3;
10684 break;
10685
10686 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10687 salt_type = SALT_TYPE_EMBEDDED;
10688 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10689 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10690 kern_type = KERN_TYPE_MS_DRSR;
10691 dgst_size = DGST_SIZE_4_8;
10692 parse_func = ms_drsr_parse_hash;
10693 sort_by_digest = sort_by_digest_4_8;
10694 opti_type = OPTI_TYPE_ZERO_BYTE;
10695 dgst_pos0 = 0;
10696 dgst_pos1 = 1;
10697 dgst_pos2 = 2;
10698 dgst_pos3 = 3;
10699 break;
10700
10701 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10702 salt_type = SALT_TYPE_EMBEDDED;
10703 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10704 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10705 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10706 dgst_size = DGST_SIZE_4_8;
10707 parse_func = androidfde_samsung_parse_hash;
10708 sort_by_digest = sort_by_digest_4_8;
10709 opti_type = OPTI_TYPE_ZERO_BYTE;
10710 dgst_pos0 = 0;
10711 dgst_pos1 = 1;
10712 dgst_pos2 = 2;
10713 dgst_pos3 = 3;
10714 break;
10715
10716 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10717 salt_type = SALT_TYPE_EMBEDDED;
10718 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10719 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10720 kern_type = KERN_TYPE_RAR5;
10721 dgst_size = DGST_SIZE_4_4;
10722 parse_func = rar5_parse_hash;
10723 sort_by_digest = sort_by_digest_4_4;
10724 opti_type = OPTI_TYPE_ZERO_BYTE;
10725 dgst_pos0 = 0;
10726 dgst_pos1 = 1;
10727 dgst_pos2 = 2;
10728 dgst_pos3 = 3;
10729 break;
10730
10731 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10732 salt_type = SALT_TYPE_EMBEDDED;
10733 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10734 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10735 kern_type = KERN_TYPE_KRB5TGS;
10736 dgst_size = DGST_SIZE_4_4;
10737 parse_func = krb5tgs_parse_hash;
10738 sort_by_digest = sort_by_digest_4_4;
10739 opti_type = OPTI_TYPE_ZERO_BYTE
10740 | OPTI_TYPE_NOT_ITERATED;
10741 dgst_pos0 = 0;
10742 dgst_pos1 = 1;
10743 dgst_pos2 = 2;
10744 dgst_pos3 = 3;
10745 break;
10746
10747 case 13200: hash_type = HASH_TYPE_AES;
10748 salt_type = SALT_TYPE_EMBEDDED;
10749 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10750 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10751 kern_type = KERN_TYPE_AXCRYPT;
10752 dgst_size = DGST_SIZE_4_4;
10753 parse_func = axcrypt_parse_hash;
10754 sort_by_digest = sort_by_digest_4_4;
10755 opti_type = OPTI_TYPE_ZERO_BYTE;
10756 dgst_pos0 = 0;
10757 dgst_pos1 = 1;
10758 dgst_pos2 = 2;
10759 dgst_pos3 = 3;
10760 break;
10761
10762 case 13300: hash_type = HASH_TYPE_SHA1;
10763 salt_type = SALT_TYPE_NONE;
10764 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10765 opts_type = OPTS_TYPE_PT_GENERATE_BE
10766 | OPTS_TYPE_PT_ADD80
10767 | OPTS_TYPE_PT_ADDBITS15;
10768 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10769 dgst_size = DGST_SIZE_4_5;
10770 parse_func = sha1axcrypt_parse_hash;
10771 sort_by_digest = sort_by_digest_4_5;
10772 opti_type = OPTI_TYPE_ZERO_BYTE
10773 | OPTI_TYPE_PRECOMPUTE_INIT
10774 | OPTI_TYPE_EARLY_SKIP
10775 | OPTI_TYPE_NOT_ITERATED
10776 | OPTI_TYPE_NOT_SALTED;
10777 dgst_pos0 = 0;
10778 dgst_pos1 = 4;
10779 dgst_pos2 = 3;
10780 dgst_pos3 = 2;
10781 break;
10782
10783 case 13400: hash_type = HASH_TYPE_AES;
10784 salt_type = SALT_TYPE_EMBEDDED;
10785 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10786 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10787 kern_type = KERN_TYPE_KEEPASS;
10788 dgst_size = DGST_SIZE_4_4;
10789 parse_func = keepass_parse_hash;
10790 sort_by_digest = sort_by_digest_4_4;
10791 opti_type = OPTI_TYPE_ZERO_BYTE;
10792 dgst_pos0 = 0;
10793 dgst_pos1 = 1;
10794 dgst_pos2 = 2;
10795 dgst_pos3 = 3;
10796 break;
10797
10798 case 13500: hash_type = HASH_TYPE_SHA1;
10799 salt_type = SALT_TYPE_EMBEDDED;
10800 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10801 opts_type = OPTS_TYPE_PT_GENERATE_BE
10802 | OPTS_TYPE_PT_UNICODE
10803 | OPTS_TYPE_PT_ADD80;
10804 kern_type = KERN_TYPE_PSTOKEN;
10805 dgst_size = DGST_SIZE_4_5;
10806 parse_func = pstoken_parse_hash;
10807 sort_by_digest = sort_by_digest_4_5;
10808 opti_type = OPTI_TYPE_ZERO_BYTE
10809 | OPTI_TYPE_PRECOMPUTE_INIT
10810 | OPTI_TYPE_EARLY_SKIP
10811 | OPTI_TYPE_NOT_ITERATED
10812 | OPTI_TYPE_PREPENDED_SALT
10813 | OPTI_TYPE_RAW_HASH;
10814 dgst_pos0 = 3;
10815 dgst_pos1 = 4;
10816 dgst_pos2 = 2;
10817 dgst_pos3 = 1;
10818 break;
10819
10820 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10821 salt_type = SALT_TYPE_EMBEDDED;
10822 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10823 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10824 kern_type = KERN_TYPE_ZIP2;
10825 dgst_size = DGST_SIZE_4_4;
10826 parse_func = zip2_parse_hash;
10827 sort_by_digest = sort_by_digest_4_4;
10828 opti_type = OPTI_TYPE_ZERO_BYTE;
10829 dgst_pos0 = 0;
10830 dgst_pos1 = 1;
10831 dgst_pos2 = 2;
10832 dgst_pos3 = 3;
10833 break;
10834
10835 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10836 salt_type = SALT_TYPE_EMBEDDED;
10837 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10838 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10839 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10840 dgst_size = DGST_SIZE_4_5;
10841 parse_func = veracrypt_parse_hash_655331;
10842 sort_by_digest = sort_by_digest_4_5;
10843 opti_type = OPTI_TYPE_ZERO_BYTE;
10844 dgst_pos0 = 0;
10845 dgst_pos1 = 1;
10846 dgst_pos2 = 2;
10847 dgst_pos3 = 3;
10848 break;
10849
10850 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10851 salt_type = SALT_TYPE_EMBEDDED;
10852 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10853 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10854 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10855 dgst_size = DGST_SIZE_4_5;
10856 parse_func = veracrypt_parse_hash_655331;
10857 sort_by_digest = sort_by_digest_4_5;
10858 opti_type = OPTI_TYPE_ZERO_BYTE;
10859 dgst_pos0 = 0;
10860 dgst_pos1 = 1;
10861 dgst_pos2 = 2;
10862 dgst_pos3 = 3;
10863 break;
10864
10865 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10866 salt_type = SALT_TYPE_EMBEDDED;
10867 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10868 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10869 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10870 dgst_size = DGST_SIZE_4_5;
10871 parse_func = veracrypt_parse_hash_655331;
10872 sort_by_digest = sort_by_digest_4_5;
10873 opti_type = OPTI_TYPE_ZERO_BYTE;
10874 dgst_pos0 = 0;
10875 dgst_pos1 = 1;
10876 dgst_pos2 = 2;
10877 dgst_pos3 = 3;
10878 break;
10879
10880 case 13721: hash_type = HASH_TYPE_SHA512;
10881 salt_type = SALT_TYPE_EMBEDDED;
10882 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10883 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10884 kern_type = KERN_TYPE_TCSHA512_XTS512;
10885 dgst_size = DGST_SIZE_8_8;
10886 parse_func = veracrypt_parse_hash_500000;
10887 sort_by_digest = sort_by_digest_8_8;
10888 opti_type = OPTI_TYPE_ZERO_BYTE
10889 | OPTI_TYPE_USES_BITS_64;
10890 dgst_pos0 = 0;
10891 dgst_pos1 = 1;
10892 dgst_pos2 = 2;
10893 dgst_pos3 = 3;
10894 break;
10895
10896 case 13722: hash_type = HASH_TYPE_SHA512;
10897 salt_type = SALT_TYPE_EMBEDDED;
10898 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10899 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10900 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10901 dgst_size = DGST_SIZE_8_8;
10902 parse_func = veracrypt_parse_hash_500000;
10903 sort_by_digest = sort_by_digest_8_8;
10904 opti_type = OPTI_TYPE_ZERO_BYTE
10905 | OPTI_TYPE_USES_BITS_64;
10906 dgst_pos0 = 0;
10907 dgst_pos1 = 1;
10908 dgst_pos2 = 2;
10909 dgst_pos3 = 3;
10910 break;
10911
10912 case 13723: hash_type = HASH_TYPE_SHA512;
10913 salt_type = SALT_TYPE_EMBEDDED;
10914 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10915 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10916 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10917 dgst_size = DGST_SIZE_8_8;
10918 parse_func = veracrypt_parse_hash_500000;
10919 sort_by_digest = sort_by_digest_8_8;
10920 opti_type = OPTI_TYPE_ZERO_BYTE
10921 | OPTI_TYPE_USES_BITS_64;
10922 dgst_pos0 = 0;
10923 dgst_pos1 = 1;
10924 dgst_pos2 = 2;
10925 dgst_pos3 = 3;
10926 break;
10927
10928 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10929 salt_type = SALT_TYPE_EMBEDDED;
10930 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10931 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10932 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10933 dgst_size = DGST_SIZE_4_8;
10934 parse_func = veracrypt_parse_hash_500000;
10935 sort_by_digest = sort_by_digest_4_8;
10936 opti_type = OPTI_TYPE_ZERO_BYTE;
10937 dgst_pos0 = 0;
10938 dgst_pos1 = 1;
10939 dgst_pos2 = 2;
10940 dgst_pos3 = 3;
10941 break;
10942
10943 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10944 salt_type = SALT_TYPE_EMBEDDED;
10945 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10946 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10947 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10948 dgst_size = DGST_SIZE_4_8;
10949 parse_func = veracrypt_parse_hash_500000;
10950 sort_by_digest = sort_by_digest_4_8;
10951 opti_type = OPTI_TYPE_ZERO_BYTE;
10952 dgst_pos0 = 0;
10953 dgst_pos1 = 1;
10954 dgst_pos2 = 2;
10955 dgst_pos3 = 3;
10956 break;
10957
10958 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS1536;
10963 dgst_size = DGST_SIZE_4_8;
10964 parse_func = veracrypt_parse_hash_500000;
10965 sort_by_digest = sort_by_digest_4_8;
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 13741: 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_327661;
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 13742: 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_327661;
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 13743: 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_327661;
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 13751: hash_type = HASH_TYPE_SHA256;
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_VCSHA256_XTS512;
11023 dgst_size = DGST_SIZE_4_8;
11024 parse_func = veracrypt_parse_hash_500000;
11025 sort_by_digest = sort_by_digest_4_8;
11026 opti_type = OPTI_TYPE_ZERO_BYTE;
11027 dgst_pos0 = 0;
11028 dgst_pos1 = 1;
11029 dgst_pos2 = 2;
11030 dgst_pos3 = 3;
11031 break;
11032
11033 case 13752: hash_type = HASH_TYPE_SHA256;
11034 salt_type = SALT_TYPE_EMBEDDED;
11035 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11036 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11037 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11038 dgst_size = DGST_SIZE_4_8;
11039 parse_func = veracrypt_parse_hash_500000;
11040 sort_by_digest = sort_by_digest_4_8;
11041 opti_type = OPTI_TYPE_ZERO_BYTE;
11042 dgst_pos0 = 0;
11043 dgst_pos1 = 1;
11044 dgst_pos2 = 2;
11045 dgst_pos3 = 3;
11046 break;
11047
11048 case 13753: hash_type = HASH_TYPE_SHA256;
11049 salt_type = SALT_TYPE_EMBEDDED;
11050 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11051 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11052 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11053 dgst_size = DGST_SIZE_4_8;
11054 parse_func = veracrypt_parse_hash_500000;
11055 sort_by_digest = sort_by_digest_4_8;
11056 opti_type = OPTI_TYPE_ZERO_BYTE;
11057 dgst_pos0 = 0;
11058 dgst_pos1 = 1;
11059 dgst_pos2 = 2;
11060 dgst_pos3 = 3;
11061 break;
11062
11063 case 13761: hash_type = HASH_TYPE_SHA256;
11064 salt_type = SALT_TYPE_EMBEDDED;
11065 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11066 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11067 kern_type = KERN_TYPE_VCSHA256_XTS512;
11068 dgst_size = DGST_SIZE_4_8;
11069 parse_func = veracrypt_parse_hash_200000;
11070 sort_by_digest = sort_by_digest_4_8;
11071 opti_type = OPTI_TYPE_ZERO_BYTE;
11072 dgst_pos0 = 0;
11073 dgst_pos1 = 1;
11074 dgst_pos2 = 2;
11075 dgst_pos3 = 3;
11076 break;
11077
11078 case 13762: hash_type = HASH_TYPE_SHA256;
11079 salt_type = SALT_TYPE_EMBEDDED;
11080 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11081 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11082 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11083 dgst_size = DGST_SIZE_4_8;
11084 parse_func = veracrypt_parse_hash_200000;
11085 sort_by_digest = sort_by_digest_4_8;
11086 opti_type = OPTI_TYPE_ZERO_BYTE;
11087 dgst_pos0 = 0;
11088 dgst_pos1 = 1;
11089 dgst_pos2 = 2;
11090 dgst_pos3 = 3;
11091 break;
11092
11093 case 13763: hash_type = HASH_TYPE_SHA256;
11094 salt_type = SALT_TYPE_EMBEDDED;
11095 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11096 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11097 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11098 dgst_size = DGST_SIZE_4_8;
11099 parse_func = veracrypt_parse_hash_200000;
11100 sort_by_digest = sort_by_digest_4_8;
11101 opti_type = OPTI_TYPE_ZERO_BYTE;
11102 dgst_pos0 = 0;
11103 dgst_pos1 = 1;
11104 dgst_pos2 = 2;
11105 dgst_pos3 = 3;
11106 break;
11107
11108 case 13800: hash_type = HASH_TYPE_SHA256;
11109 salt_type = SALT_TYPE_EMBEDDED;
11110 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11111 opts_type = OPTS_TYPE_PT_GENERATE_BE
11112 | OPTS_TYPE_PT_UNICODE;
11113 kern_type = KERN_TYPE_WIN8PHONE;
11114 dgst_size = DGST_SIZE_4_8;
11115 parse_func = win8phone_parse_hash;
11116 sort_by_digest = sort_by_digest_4_8;
11117 opti_type = OPTI_TYPE_ZERO_BYTE
11118 | OPTI_TYPE_PRECOMPUTE_INIT
11119 | OPTI_TYPE_EARLY_SKIP
11120 | OPTI_TYPE_NOT_ITERATED
11121 | OPTI_TYPE_RAW_HASH;
11122 dgst_pos0 = 3;
11123 dgst_pos1 = 7;
11124 dgst_pos2 = 2;
11125 dgst_pos3 = 6;
11126 break;
11127
11128 default: usage_mini_print (PROGNAME); return (-1);
11129 }
11130
11131 /**
11132 * parser
11133 */
11134
11135 data.parse_func = parse_func;
11136
11137 /**
11138 * misc stuff
11139 */
11140
11141 if (hex_salt)
11142 {
11143 if (salt_type == SALT_TYPE_INTERN)
11144 {
11145 opts_type |= OPTS_TYPE_ST_HEX;
11146 }
11147 else
11148 {
11149 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11150
11151 return (-1);
11152 }
11153 }
11154
11155 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11156 | (salt_type == SALT_TYPE_EXTERN)
11157 | (salt_type == SALT_TYPE_EMBEDDED)
11158 | (salt_type == SALT_TYPE_VIRTUAL));
11159
11160 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11161
11162 data.hash_type = hash_type;
11163 data.attack_mode = attack_mode;
11164 data.attack_kern = attack_kern;
11165 data.attack_exec = attack_exec;
11166 data.kern_type = kern_type;
11167 data.opts_type = opts_type;
11168 data.dgst_size = dgst_size;
11169 data.salt_type = salt_type;
11170 data.isSalted = isSalted;
11171 data.sort_by_digest = sort_by_digest;
11172 data.dgst_pos0 = dgst_pos0;
11173 data.dgst_pos1 = dgst_pos1;
11174 data.dgst_pos2 = dgst_pos2;
11175 data.dgst_pos3 = dgst_pos3;
11176
11177 esalt_size = 0;
11178
11179 switch (hash_mode)
11180 {
11181 case 2500: esalt_size = sizeof (wpa_t); break;
11182 case 5300: esalt_size = sizeof (ikepsk_t); break;
11183 case 5400: esalt_size = sizeof (ikepsk_t); break;
11184 case 5500: esalt_size = sizeof (netntlm_t); break;
11185 case 5600: esalt_size = sizeof (netntlm_t); break;
11186 case 6211: esalt_size = sizeof (tc_t); break;
11187 case 6212: esalt_size = sizeof (tc_t); break;
11188 case 6213: esalt_size = sizeof (tc_t); break;
11189 case 6221: esalt_size = sizeof (tc_t); break;
11190 case 6222: esalt_size = sizeof (tc_t); break;
11191 case 6223: esalt_size = sizeof (tc_t); break;
11192 case 6231: esalt_size = sizeof (tc_t); break;
11193 case 6232: esalt_size = sizeof (tc_t); break;
11194 case 6233: esalt_size = sizeof (tc_t); break;
11195 case 6241: esalt_size = sizeof (tc_t); break;
11196 case 6242: esalt_size = sizeof (tc_t); break;
11197 case 6243: esalt_size = sizeof (tc_t); break;
11198 case 6600: esalt_size = sizeof (agilekey_t); break;
11199 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11200 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11201 case 7300: esalt_size = sizeof (rakp_t); break;
11202 case 7500: esalt_size = sizeof (krb5pa_t); break;
11203 case 8200: esalt_size = sizeof (cloudkey_t); break;
11204 case 8800: esalt_size = sizeof (androidfde_t); break;
11205 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11206 case 9400: esalt_size = sizeof (office2007_t); break;
11207 case 9500: esalt_size = sizeof (office2010_t); break;
11208 case 9600: esalt_size = sizeof (office2013_t); break;
11209 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11210 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11211 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11212 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11213 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11214 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11215 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11216 case 10200: esalt_size = sizeof (cram_md5_t); break;
11217 case 10400: esalt_size = sizeof (pdf_t); break;
11218 case 10410: esalt_size = sizeof (pdf_t); break;
11219 case 10420: esalt_size = sizeof (pdf_t); break;
11220 case 10500: esalt_size = sizeof (pdf_t); break;
11221 case 10600: esalt_size = sizeof (pdf_t); break;
11222 case 10700: esalt_size = sizeof (pdf_t); break;
11223 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11224 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11225 case 11400: esalt_size = sizeof (sip_t); break;
11226 case 11600: esalt_size = sizeof (seven_zip_t); break;
11227 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11228 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11229 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11230 case 13000: esalt_size = sizeof (rar5_t); break;
11231 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11232 case 13400: esalt_size = sizeof (keepass_t); break;
11233 case 13500: esalt_size = sizeof (pstoken_t); break;
11234 case 13600: esalt_size = sizeof (zip2_t); break;
11235 case 13711: esalt_size = sizeof (tc_t); break;
11236 case 13712: esalt_size = sizeof (tc_t); break;
11237 case 13713: esalt_size = sizeof (tc_t); break;
11238 case 13721: esalt_size = sizeof (tc_t); break;
11239 case 13722: esalt_size = sizeof (tc_t); break;
11240 case 13723: esalt_size = sizeof (tc_t); break;
11241 case 13731: esalt_size = sizeof (tc_t); break;
11242 case 13732: esalt_size = sizeof (tc_t); break;
11243 case 13733: esalt_size = sizeof (tc_t); break;
11244 case 13741: esalt_size = sizeof (tc_t); break;
11245 case 13742: esalt_size = sizeof (tc_t); break;
11246 case 13743: esalt_size = sizeof (tc_t); break;
11247 case 13751: esalt_size = sizeof (tc_t); break;
11248 case 13752: esalt_size = sizeof (tc_t); break;
11249 case 13753: esalt_size = sizeof (tc_t); break;
11250 case 13761: esalt_size = sizeof (tc_t); break;
11251 case 13762: esalt_size = sizeof (tc_t); break;
11252 case 13763: esalt_size = sizeof (tc_t); break;
11253 case 13800: esalt_size = sizeof (win8phone_t); break;
11254 }
11255
11256 data.esalt_size = esalt_size;
11257
11258 /**
11259 * choose dictionary parser
11260 */
11261
11262 if (hash_type == HASH_TYPE_LM)
11263 {
11264 get_next_word_func = get_next_word_lm;
11265 }
11266 else if (opts_type & OPTS_TYPE_PT_UPPER)
11267 {
11268 get_next_word_func = get_next_word_uc;
11269 }
11270 else
11271 {
11272 get_next_word_func = get_next_word_std;
11273 }
11274
11275 /**
11276 * dictstat
11277 */
11278
11279 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11280
11281 #ifdef _POSIX
11282 size_t dictstat_nmemb = 0;
11283 #endif
11284
11285 #ifdef _WIN
11286 uint dictstat_nmemb = 0;
11287 #endif
11288
11289 char dictstat[256] = { 0 };
11290
11291 FILE *dictstat_fp = NULL;
11292
11293 if (keyspace == 0)
11294 {
11295 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11296
11297 dictstat_fp = fopen (dictstat, "rb");
11298
11299 if (dictstat_fp)
11300 {
11301 #ifdef _POSIX
11302 struct stat tmpstat;
11303
11304 fstat (fileno (dictstat_fp), &tmpstat);
11305 #endif
11306
11307 #ifdef _WIN
11308 struct stat64 tmpstat;
11309
11310 _fstat64 (fileno (dictstat_fp), &tmpstat);
11311 #endif
11312
11313 if (tmpstat.st_mtime < COMPTIME)
11314 {
11315 /* with v0.15 the format changed so we have to ensure user is using a good version
11316 since there is no version-header in the dictstat file */
11317
11318 fclose (dictstat_fp);
11319
11320 unlink (dictstat);
11321 }
11322 else
11323 {
11324 while (!feof (dictstat_fp))
11325 {
11326 dictstat_t d;
11327
11328 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11329
11330 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11331
11332 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11333 {
11334 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11335
11336 return -1;
11337 }
11338 }
11339
11340 fclose (dictstat_fp);
11341 }
11342 }
11343 }
11344
11345 /**
11346 * potfile
11347 */
11348
11349 char potfile[256] = { 0 };
11350
11351 if (potfile_path == NULL)
11352 {
11353 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11354 }
11355 else
11356 {
11357 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11358 }
11359
11360 data.pot_fp = NULL;
11361
11362 FILE *out_fp = NULL;
11363 FILE *pot_fp = NULL;
11364
11365 if (show == 1 || left == 1)
11366 {
11367 pot_fp = fopen (potfile, "rb");
11368
11369 if (pot_fp == NULL)
11370 {
11371 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11372
11373 return (-1);
11374 }
11375
11376 if (outfile != NULL)
11377 {
11378 if ((out_fp = fopen (outfile, "ab")) == NULL)
11379 {
11380 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11381
11382 fclose (pot_fp);
11383
11384 return (-1);
11385 }
11386 }
11387 else
11388 {
11389 out_fp = stdout;
11390 }
11391 }
11392 else
11393 {
11394 if (potfile_disable == 0)
11395 {
11396 pot_fp = fopen (potfile, "ab");
11397
11398 if (pot_fp == NULL)
11399 {
11400 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11401
11402 return (-1);
11403 }
11404
11405 data.pot_fp = pot_fp;
11406 }
11407 }
11408
11409 pot_t *pot = NULL;
11410
11411 uint pot_cnt = 0;
11412 uint pot_avail = 0;
11413
11414 if (show == 1 || left == 1)
11415 {
11416 SUPPRESS_OUTPUT = 1;
11417
11418 pot_avail = count_lines (pot_fp);
11419
11420 rewind (pot_fp);
11421
11422 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11423
11424 uint pot_hashes_avail = 0;
11425
11426 uint line_num = 0;
11427
11428 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11429
11430 while (!feof (pot_fp))
11431 {
11432 line_num++;
11433
11434 int line_len = fgetl (pot_fp, line_buf);
11435
11436 if (line_len == 0) continue;
11437
11438 char *plain_buf = line_buf + line_len;
11439
11440 pot_t *pot_ptr = &pot[pot_cnt];
11441
11442 hash_t *hashes_buf = &pot_ptr->hash;
11443
11444 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11445 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11446
11447 if (pot_cnt == pot_hashes_avail)
11448 {
11449 uint pos = 0;
11450
11451 for (pos = 0; pos < INCR_POT; pos++)
11452 {
11453 if ((pot_cnt + pos) >= pot_avail) break;
11454
11455 pot_t *tmp_pot = &pot[pot_cnt + pos];
11456
11457 hash_t *tmp_hash = &tmp_pot->hash;
11458
11459 tmp_hash->digest = mymalloc (dgst_size);
11460
11461 if (isSalted)
11462 {
11463 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11464 }
11465
11466 if (esalt_size)
11467 {
11468 tmp_hash->esalt = mymalloc (esalt_size);
11469 }
11470
11471 pot_hashes_avail++;
11472 }
11473 }
11474
11475 int plain_len = 0;
11476
11477 int parser_status;
11478
11479 int iter = MAX_CUT_TRIES;
11480
11481 do
11482 {
11483 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11484 {
11485 if (line_buf[i] == ':')
11486 {
11487 line_len--;
11488
11489 break;
11490 }
11491 }
11492
11493 if (data.hash_mode != 2500)
11494 {
11495 parser_status = parse_func (line_buf, line_len, hashes_buf);
11496 }
11497 else
11498 {
11499 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11500
11501 if (line_len > max_salt_size)
11502 {
11503 parser_status = PARSER_GLOBAL_LENGTH;
11504 }
11505 else
11506 {
11507 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11508
11509 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11510
11511 hashes_buf->salt->salt_len = line_len;
11512
11513 parser_status = PARSER_OK;
11514 }
11515 }
11516
11517 // if NOT parsed without error, we add the ":" to the plain
11518
11519 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11520 {
11521 plain_len++;
11522 plain_buf--;
11523 }
11524
11525 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11526
11527 if (parser_status < PARSER_GLOBAL_ZERO)
11528 {
11529 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11530
11531 continue;
11532 }
11533
11534 if (plain_len >= 255) continue;
11535
11536 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11537
11538 pot_ptr->plain_len = plain_len;
11539
11540 pot_cnt++;
11541 }
11542
11543 myfree (line_buf);
11544
11545 fclose (pot_fp);
11546
11547 SUPPRESS_OUTPUT = 0;
11548
11549 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11550 }
11551
11552 /**
11553 * word len
11554 */
11555
11556 uint pw_min = PW_MIN;
11557 uint pw_max = PW_MAX;
11558
11559 switch (hash_mode)
11560 {
11561 case 125: if (pw_max > 32) pw_max = 32;
11562 break;
11563 case 400: if (pw_max > 40) pw_max = 40;
11564 break;
11565 case 500: if (pw_max > 16) pw_max = 16;
11566 break;
11567 case 1500: if (pw_max > 8) pw_max = 8;
11568 break;
11569 case 1600: if (pw_max > 16) pw_max = 16;
11570 break;
11571 case 1800: if (pw_max > 16) pw_max = 16;
11572 break;
11573 case 2100: if (pw_max > 16) pw_max = 16;
11574 break;
11575 case 2500: if (pw_min < 8) pw_min = 8;
11576 break;
11577 case 3000: if (pw_max > 7) pw_max = 7;
11578 break;
11579 case 5200: if (pw_max > 24) pw_max = 24;
11580 break;
11581 case 5800: if (pw_max > 16) pw_max = 16;
11582 break;
11583 case 6300: if (pw_max > 16) pw_max = 16;
11584 break;
11585 case 7400: if (pw_max > 16) pw_max = 16;
11586 break;
11587 case 7700: if (pw_max > 8) pw_max = 8;
11588 break;
11589 case 7900: if (pw_max > 48) pw_max = 48;
11590 break;
11591 case 8500: if (pw_max > 8) pw_max = 8;
11592 break;
11593 case 8600: if (pw_max > 16) pw_max = 16;
11594 break;
11595 case 9710: pw_min = 5;
11596 pw_max = 5;
11597 break;
11598 case 9810: pw_min = 5;
11599 pw_max = 5;
11600 break;
11601 case 10410: pw_min = 5;
11602 pw_max = 5;
11603 break;
11604 case 10300: if (pw_max < 3) pw_min = 3;
11605 if (pw_max > 40) pw_max = 40;
11606 break;
11607 case 10500: if (pw_max < 3) pw_min = 3;
11608 if (pw_max > 40) pw_max = 40;
11609 break;
11610 case 10700: if (pw_max > 16) pw_max = 16;
11611 break;
11612 case 11300: if (pw_max > 40) pw_max = 40;
11613 break;
11614 case 11600: if (pw_max > 32) pw_max = 32;
11615 break;
11616 case 12500: if (pw_max > 20) pw_max = 20;
11617 break;
11618 case 12800: if (pw_max > 24) pw_max = 24;
11619 break;
11620 }
11621
11622 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11623 {
11624 switch (attack_kern)
11625 {
11626 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11627 break;
11628 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11629 break;
11630 }
11631 }
11632
11633 /**
11634 * charsets : keep them together for more easy maintainnce
11635 */
11636
11637 cs_t mp_sys[6] = { { { 0 }, 0 } };
11638 cs_t mp_usr[4] = { { { 0 }, 0 } };
11639
11640 mp_setup_sys (mp_sys);
11641
11642 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11643 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11644 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11645 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11646
11647 /**
11648 * load hashes, part I: find input mode, count hashes
11649 */
11650
11651 uint hashlist_mode = 0;
11652 uint hashlist_format = HLFMT_HASHCAT;
11653
11654 uint hashes_avail = 0;
11655
11656 if ((benchmark == 0) && (stdout_flag == 0))
11657 {
11658 struct stat f;
11659
11660 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11661
11662 if ((hash_mode == 2500) ||
11663 (hash_mode == 5200) ||
11664 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11665 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11666 (hash_mode == 9000))
11667 {
11668 hashlist_mode = HL_MODE_ARG;
11669
11670 char *hashfile = myargv[optind];
11671
11672 data.hashfile = hashfile;
11673
11674 logfile_top_var_string ("target", hashfile);
11675 }
11676
11677 if (hashlist_mode == HL_MODE_ARG)
11678 {
11679 if (hash_mode == 2500)
11680 {
11681 struct stat st;
11682
11683 if (stat (data.hashfile, &st) == -1)
11684 {
11685 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11686
11687 return (-1);
11688 }
11689
11690 hashes_avail = st.st_size / sizeof (hccap_t);
11691 }
11692 else
11693 {
11694 hashes_avail = 1;
11695 }
11696 }
11697 else if (hashlist_mode == HL_MODE_FILE)
11698 {
11699 char *hashfile = myargv[optind];
11700
11701 data.hashfile = hashfile;
11702
11703 logfile_top_var_string ("target", hashfile);
11704
11705 FILE *fp = NULL;
11706
11707 if ((fp = fopen (hashfile, "rb")) == NULL)
11708 {
11709 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11710
11711 return (-1);
11712 }
11713
11714 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11715
11716 hashes_avail = count_lines (fp);
11717
11718 rewind (fp);
11719
11720 if (hashes_avail == 0)
11721 {
11722 log_error ("ERROR: hashfile is empty or corrupt");
11723
11724 fclose (fp);
11725
11726 return (-1);
11727 }
11728
11729 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11730
11731 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11732 {
11733 log_error ("ERROR: remove not supported in native hashfile-format mode");
11734
11735 fclose (fp);
11736
11737 return (-1);
11738 }
11739
11740 fclose (fp);
11741 }
11742 }
11743 else
11744 {
11745 hashlist_mode = HL_MODE_ARG;
11746
11747 hashes_avail = 1;
11748 }
11749
11750 if (hash_mode == 3000) hashes_avail *= 2;
11751
11752 data.hashlist_mode = hashlist_mode;
11753 data.hashlist_format = hashlist_format;
11754
11755 logfile_top_uint (hashlist_mode);
11756 logfile_top_uint (hashlist_format);
11757
11758 /**
11759 * load hashes, part II: allocate required memory, set pointers
11760 */
11761
11762 hash_t *hashes_buf = NULL;
11763 void *digests_buf = NULL;
11764 salt_t *salts_buf = NULL;
11765 void *esalts_buf = NULL;
11766
11767 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11768
11769 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11770
11771 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11772 {
11773 u32 hash_pos;
11774
11775 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11776 {
11777 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11778
11779 hashes_buf[hash_pos].hash_info = hash_info;
11780
11781 if (username && (remove || show || left))
11782 {
11783 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11784 }
11785
11786 if (benchmark)
11787 {
11788 hash_info->orighash = (char *) mymalloc (256);
11789 }
11790 }
11791 }
11792
11793 if (isSalted)
11794 {
11795 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11796
11797 if (esalt_size)
11798 {
11799 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11800 }
11801 }
11802 else
11803 {
11804 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11805 }
11806
11807 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11808 {
11809 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11810
11811 if (isSalted)
11812 {
11813 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11814
11815 if (esalt_size)
11816 {
11817 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11818 }
11819 }
11820 else
11821 {
11822 hashes_buf[hash_pos].salt = &salts_buf[0];
11823 }
11824 }
11825
11826 /**
11827 * load hashes, part III: parse hashes or generate them if benchmark
11828 */
11829
11830 uint hashes_cnt = 0;
11831
11832 if (benchmark == 0)
11833 {
11834 if (keyspace == 1)
11835 {
11836 // useless to read hash file for keyspace, cheat a little bit w/ optind
11837 }
11838 else if (stdout_flag == 1)
11839 {
11840 // useless to read hash file for stdout, cheat a little bit w/ optind
11841 }
11842 else if (hashes_avail == 0)
11843 {
11844 }
11845 else if (hashlist_mode == HL_MODE_ARG)
11846 {
11847 char *input_buf = myargv[optind];
11848
11849 uint input_len = strlen (input_buf);
11850
11851 logfile_top_var_string ("target", input_buf);
11852
11853 char *hash_buf = NULL;
11854 int hash_len = 0;
11855
11856 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11857
11858 bool hash_fmt_error = 0;
11859
11860 if (hash_len < 1) hash_fmt_error = 1;
11861 if (hash_buf == NULL) hash_fmt_error = 1;
11862
11863 if (hash_fmt_error)
11864 {
11865 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11866 }
11867 else
11868 {
11869 if (opts_type & OPTS_TYPE_HASH_COPY)
11870 {
11871 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11872
11873 hash_info_tmp->orighash = mystrdup (hash_buf);
11874 }
11875
11876 if (isSalted)
11877 {
11878 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11879 }
11880
11881 int parser_status = PARSER_OK;
11882
11883 if (hash_mode == 2500)
11884 {
11885 if (hash_len == 0)
11886 {
11887 log_error ("ERROR: hccap file not specified");
11888
11889 return (-1);
11890 }
11891
11892 hashlist_mode = HL_MODE_FILE;
11893
11894 data.hashlist_mode = hashlist_mode;
11895
11896 FILE *fp = fopen (hash_buf, "rb");
11897
11898 if (fp == NULL)
11899 {
11900 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11901
11902 return (-1);
11903 }
11904
11905 if (hashes_avail < 1)
11906 {
11907 log_error ("ERROR: hccap file is empty or corrupt");
11908
11909 fclose (fp);
11910
11911 return (-1);
11912 }
11913
11914 uint hccap_size = sizeof (hccap_t);
11915
11916 char *in = (char *) mymalloc (hccap_size);
11917
11918 while (!feof (fp))
11919 {
11920 int n = fread (in, hccap_size, 1, fp);
11921
11922 if (n != 1)
11923 {
11924 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11925
11926 break;
11927 }
11928
11929 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11930
11931 if (parser_status != PARSER_OK)
11932 {
11933 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11934
11935 continue;
11936 }
11937
11938 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11939
11940 if ((show == 1) || (left == 1))
11941 {
11942 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11943
11944 char *salt_ptr = (char *) tmp_salt->salt_buf;
11945
11946 int cur_pos = tmp_salt->salt_len;
11947 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11948
11949 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11950
11951 // do the appending task
11952
11953 snprintf (salt_ptr + cur_pos,
11954 rem_len,
11955 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11956 wpa->orig_mac1[0],
11957 wpa->orig_mac1[1],
11958 wpa->orig_mac1[2],
11959 wpa->orig_mac1[3],
11960 wpa->orig_mac1[4],
11961 wpa->orig_mac1[5],
11962 wpa->orig_mac2[0],
11963 wpa->orig_mac2[1],
11964 wpa->orig_mac2[2],
11965 wpa->orig_mac2[3],
11966 wpa->orig_mac2[4],
11967 wpa->orig_mac2[5]);
11968
11969 // memset () the remaining part of the salt
11970
11971 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11972 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11973
11974 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11975
11976 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11977 }
11978
11979 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);
11980 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);
11981
11982 hashes_cnt++;
11983 }
11984
11985 fclose (fp);
11986
11987 myfree (in);
11988 }
11989 else if (hash_mode == 3000)
11990 {
11991 if (hash_len == 32)
11992 {
11993 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11994
11995 hash_t *lm_hash_left = NULL;
11996
11997 if (parser_status == PARSER_OK)
11998 {
11999 lm_hash_left = &hashes_buf[hashes_cnt];
12000
12001 hashes_cnt++;
12002 }
12003 else
12004 {
12005 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12006 }
12007
12008 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12009
12010 hash_t *lm_hash_right = NULL;
12011
12012 if (parser_status == PARSER_OK)
12013 {
12014 lm_hash_right = &hashes_buf[hashes_cnt];
12015
12016 hashes_cnt++;
12017 }
12018 else
12019 {
12020 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12021 }
12022
12023 // show / left
12024
12025 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12026 {
12027 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);
12028 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);
12029 }
12030 }
12031 else
12032 {
12033 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12034
12035 if (parser_status == PARSER_OK)
12036 {
12037 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12038 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12039 }
12040
12041 if (parser_status == PARSER_OK)
12042 {
12043 hashes_cnt++;
12044 }
12045 else
12046 {
12047 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12048 }
12049 }
12050 }
12051 else
12052 {
12053 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12054
12055 if (parser_status == PARSER_OK)
12056 {
12057 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12058 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12059 }
12060
12061 if (parser_status == PARSER_OK)
12062 {
12063 hashes_cnt++;
12064 }
12065 else
12066 {
12067 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12068 }
12069 }
12070 }
12071 }
12072 else if (hashlist_mode == HL_MODE_FILE)
12073 {
12074 char *hashfile = data.hashfile;
12075
12076 FILE *fp;
12077
12078 if ((fp = fopen (hashfile, "rb")) == NULL)
12079 {
12080 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12081
12082 return (-1);
12083 }
12084
12085 uint line_num = 0;
12086
12087 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12088
12089 while (!feof (fp))
12090 {
12091 line_num++;
12092
12093 int line_len = fgetl (fp, line_buf);
12094
12095 if (line_len == 0) continue;
12096
12097 char *hash_buf = NULL;
12098 int hash_len = 0;
12099
12100 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12101
12102 bool hash_fmt_error = 0;
12103
12104 if (hash_len < 1) hash_fmt_error = 1;
12105 if (hash_buf == NULL) hash_fmt_error = 1;
12106
12107 if (hash_fmt_error)
12108 {
12109 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12110
12111 continue;
12112 }
12113
12114 if (username)
12115 {
12116 char *user_buf = NULL;
12117 int user_len = 0;
12118
12119 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12120
12121 if (remove || show)
12122 {
12123 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12124
12125 *user = (user_t *) mymalloc (sizeof (user_t));
12126
12127 user_t *user_ptr = *user;
12128
12129 if (user_buf != NULL)
12130 {
12131 user_ptr->user_name = mystrdup (user_buf);
12132 }
12133 else
12134 {
12135 user_ptr->user_name = mystrdup ("");
12136 }
12137
12138 user_ptr->user_len = user_len;
12139 }
12140 }
12141
12142 if (opts_type & OPTS_TYPE_HASH_COPY)
12143 {
12144 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12145
12146 hash_info_tmp->orighash = mystrdup (hash_buf);
12147 }
12148
12149 if (isSalted)
12150 {
12151 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12152 }
12153
12154 if (hash_mode == 3000)
12155 {
12156 if (hash_len == 32)
12157 {
12158 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12159
12160 if (parser_status < PARSER_GLOBAL_ZERO)
12161 {
12162 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12163
12164 continue;
12165 }
12166
12167 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12168
12169 hashes_cnt++;
12170
12171 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12172
12173 if (parser_status < PARSER_GLOBAL_ZERO)
12174 {
12175 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12176
12177 continue;
12178 }
12179
12180 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12181
12182 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);
12183
12184 hashes_cnt++;
12185
12186 // show / left
12187
12188 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);
12189 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);
12190 }
12191 else
12192 {
12193 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12194
12195 if (parser_status < PARSER_GLOBAL_ZERO)
12196 {
12197 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12198
12199 continue;
12200 }
12201
12202 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);
12203
12204 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12205 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12206
12207 hashes_cnt++;
12208 }
12209 }
12210 else
12211 {
12212 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12213
12214 if (parser_status < PARSER_GLOBAL_ZERO)
12215 {
12216 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12217
12218 continue;
12219 }
12220
12221 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);
12222
12223 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12224 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12225
12226 hashes_cnt++;
12227 }
12228 }
12229
12230 myfree (line_buf);
12231
12232 fclose (fp);
12233
12234 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12235
12236 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12237 }
12238 }
12239 else
12240 {
12241 if (isSalted)
12242 {
12243 hashes_buf[0].salt->salt_len = 8;
12244
12245 // special salt handling
12246
12247 switch (hash_mode)
12248 {
12249 case 1500: hashes_buf[0].salt->salt_len = 2;
12250 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12251 break;
12252 case 1731: hashes_buf[0].salt->salt_len = 4;
12253 break;
12254 case 2410: hashes_buf[0].salt->salt_len = 4;
12255 break;
12256 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12257 break;
12258 case 3100: hashes_buf[0].salt->salt_len = 1;
12259 break;
12260 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12261 break;
12262 case 5800: hashes_buf[0].salt->salt_len = 16;
12263 break;
12264 case 6800: hashes_buf[0].salt->salt_len = 32;
12265 break;
12266 case 8400: hashes_buf[0].salt->salt_len = 40;
12267 break;
12268 case 8800: hashes_buf[0].salt->salt_len = 16;
12269 break;
12270 case 8900: hashes_buf[0].salt->salt_len = 16;
12271 hashes_buf[0].salt->scrypt_N = 1024;
12272 hashes_buf[0].salt->scrypt_r = 1;
12273 hashes_buf[0].salt->scrypt_p = 1;
12274 break;
12275 case 9100: hashes_buf[0].salt->salt_len = 16;
12276 break;
12277 case 9300: hashes_buf[0].salt->salt_len = 14;
12278 hashes_buf[0].salt->scrypt_N = 16384;
12279 hashes_buf[0].salt->scrypt_r = 1;
12280 hashes_buf[0].salt->scrypt_p = 1;
12281 break;
12282 case 9400: hashes_buf[0].salt->salt_len = 16;
12283 break;
12284 case 9500: hashes_buf[0].salt->salt_len = 16;
12285 break;
12286 case 9600: hashes_buf[0].salt->salt_len = 16;
12287 break;
12288 case 9700: hashes_buf[0].salt->salt_len = 16;
12289 break;
12290 case 9710: hashes_buf[0].salt->salt_len = 16;
12291 break;
12292 case 9720: hashes_buf[0].salt->salt_len = 16;
12293 break;
12294 case 9800: hashes_buf[0].salt->salt_len = 16;
12295 break;
12296 case 9810: hashes_buf[0].salt->salt_len = 16;
12297 break;
12298 case 9820: hashes_buf[0].salt->salt_len = 16;
12299 break;
12300 case 10300: hashes_buf[0].salt->salt_len = 12;
12301 break;
12302 case 11500: hashes_buf[0].salt->salt_len = 4;
12303 break;
12304 case 11600: hashes_buf[0].salt->salt_len = 4;
12305 break;
12306 case 12400: hashes_buf[0].salt->salt_len = 4;
12307 break;
12308 case 12500: hashes_buf[0].salt->salt_len = 8;
12309 break;
12310 case 12600: hashes_buf[0].salt->salt_len = 64;
12311 break;
12312 }
12313
12314 // special esalt handling
12315
12316 switch (hash_mode)
12317 {
12318 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12319 break;
12320 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12321 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12322 break;
12323 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12324 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12325 break;
12326 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12327 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12328 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12329 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12330 break;
12331 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12332 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12333 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12334 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12335 break;
12336 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12337 break;
12338 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12339 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12340 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12341 break;
12342 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12343 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12344 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12345 break;
12346 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12347 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12348 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12349 break;
12350 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12351 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12352 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12353 break;
12354 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12355 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12356 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12357 break;
12358 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12359 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12360 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12361 break;
12362 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12363 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12364 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12365 break;
12366 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12367 break;
12368 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12369 break;
12370 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12371 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12372 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12373 break;
12374 }
12375 }
12376
12377 // set hashfile
12378
12379 switch (hash_mode)
12380 {
12381 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12382 break;
12383 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12384 break;
12385 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12386 break;
12387 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12388 break;
12389 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12390 break;
12391 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12392 break;
12393 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12394 break;
12395 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12396 break;
12397 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12398 break;
12399 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12400 break;
12401 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12402 break;
12403 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12404 break;
12405 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12406 break;
12407 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12408 break;
12409 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12410 break;
12411 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12412 break;
12413 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12414 break;
12415 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12416 break;
12417 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12418 break;
12419 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12420 break;
12421 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12422 break;
12423 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12424 break;
12425 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12426 break;
12427 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12428 break;
12429 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12430 break;
12431 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12432 break;
12433 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12434 break;
12435 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12436 break;
12437 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12438 break;
12439 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12440 break;
12441 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12442 break;
12443 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12444 break;
12445 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12446 break;
12447 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12448 break;
12449 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12450 break;
12451 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12452 break;
12453 }
12454
12455 // set default iterations
12456
12457 switch (hash_mode)
12458 {
12459 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12460 break;
12461 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12462 break;
12463 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12464 break;
12465 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12466 break;
12467 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12468 break;
12469 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12470 break;
12471 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12472 break;
12473 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12474 break;
12475 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12476 break;
12477 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12478 break;
12479 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12480 break;
12481 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12482 break;
12483 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12484 break;
12485 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12486 break;
12487 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12488 break;
12489 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12490 break;
12491 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12492 break;
12493 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12494 break;
12495 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12496 break;
12497 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12498 break;
12499 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12500 break;
12501 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12502 break;
12503 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12504 break;
12505 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12506 break;
12507 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12508 break;
12509 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12510 break;
12511 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12512 break;
12513 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12514 break;
12515 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12516 break;
12517 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12518 break;
12519 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12520 break;
12521 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12522 break;
12523 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12524 break;
12525 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12526 break;
12527 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12528 break;
12529 case 8900: hashes_buf[0].salt->salt_iter = 1;
12530 break;
12531 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12532 break;
12533 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12534 break;
12535 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12536 break;
12537 case 9300: hashes_buf[0].salt->salt_iter = 1;
12538 break;
12539 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12540 break;
12541 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12542 break;
12543 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12544 break;
12545 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12546 break;
12547 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12548 break;
12549 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12550 break;
12551 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12552 break;
12553 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12554 break;
12555 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12556 break;
12557 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12558 break;
12559 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12560 break;
12561 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12562 break;
12563 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12564 break;
12565 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12566 break;
12567 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12568 break;
12569 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12570 break;
12571 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12572 break;
12573 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12574 break;
12575 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12576 break;
12577 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12578 break;
12579 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12580 break;
12581 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12582 break;
12583 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12584 break;
12585 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12586 break;
12587 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12588 break;
12589 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12590 break;
12591 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12592 break;
12593 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12594 break;
12595 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12596 break;
12597 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12598 break;
12599 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12600 break;
12601 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12602 break;
12603 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12604 break;
12605 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12606 break;
12607 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12608 break;
12609 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12610 break;
12611 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12612 break;
12613 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12614 break;
12615 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12616 break;
12617 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12618 break;
12619 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12620 break;
12621 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12622 break;
12623 }
12624
12625 hashes_cnt = 1;
12626 }
12627
12628 if (show == 1 || left == 1)
12629 {
12630 for (uint i = 0; i < pot_cnt; i++)
12631 {
12632 pot_t *pot_ptr = &pot[i];
12633
12634 hash_t *hashes_buf = &pot_ptr->hash;
12635
12636 local_free (hashes_buf->digest);
12637
12638 if (isSalted)
12639 {
12640 local_free (hashes_buf->salt);
12641 }
12642 }
12643
12644 local_free (pot);
12645
12646 if (data.quiet == 0) log_info_nn ("");
12647
12648 return (0);
12649 }
12650
12651 if ((keyspace == 0) && (stdout_flag == 0))
12652 {
12653 if (hashes_cnt == 0)
12654 {
12655 log_error ("ERROR: No hashes loaded");
12656
12657 return (-1);
12658 }
12659 }
12660
12661 /**
12662 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12663 */
12664
12665 if (data.outfile != NULL)
12666 {
12667 if (data.hashfile != NULL)
12668 {
12669 #ifdef _POSIX
12670 struct stat tmpstat_outfile;
12671 struct stat tmpstat_hashfile;
12672 #endif
12673
12674 #ifdef _WIN
12675 struct stat64 tmpstat_outfile;
12676 struct stat64 tmpstat_hashfile;
12677 #endif
12678
12679 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12680
12681 if (tmp_outfile_fp)
12682 {
12683 #ifdef _POSIX
12684 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12685 #endif
12686
12687 #ifdef _WIN
12688 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12689 #endif
12690
12691 fclose (tmp_outfile_fp);
12692 }
12693
12694 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12695
12696 if (tmp_hashfile_fp)
12697 {
12698 #ifdef _POSIX
12699 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12700 #endif
12701
12702 #ifdef _WIN
12703 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12704 #endif
12705
12706 fclose (tmp_hashfile_fp);
12707 }
12708
12709 if (tmp_outfile_fp && tmp_outfile_fp)
12710 {
12711 tmpstat_outfile.st_mode = 0;
12712 tmpstat_outfile.st_nlink = 0;
12713 tmpstat_outfile.st_uid = 0;
12714 tmpstat_outfile.st_gid = 0;
12715 tmpstat_outfile.st_rdev = 0;
12716 tmpstat_outfile.st_atime = 0;
12717
12718 tmpstat_hashfile.st_mode = 0;
12719 tmpstat_hashfile.st_nlink = 0;
12720 tmpstat_hashfile.st_uid = 0;
12721 tmpstat_hashfile.st_gid = 0;
12722 tmpstat_hashfile.st_rdev = 0;
12723 tmpstat_hashfile.st_atime = 0;
12724
12725 #ifdef _POSIX
12726 tmpstat_outfile.st_blksize = 0;
12727 tmpstat_outfile.st_blocks = 0;
12728
12729 tmpstat_hashfile.st_blksize = 0;
12730 tmpstat_hashfile.st_blocks = 0;
12731 #endif
12732
12733 #ifdef _POSIX
12734 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12735 {
12736 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12737
12738 return (-1);
12739 }
12740 #endif
12741
12742 #ifdef _WIN
12743 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12744 {
12745 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12746
12747 return (-1);
12748 }
12749 #endif
12750 }
12751 }
12752 }
12753
12754 /**
12755 * Remove duplicates
12756 */
12757
12758 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12759
12760 if (isSalted)
12761 {
12762 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12763 }
12764 else
12765 {
12766 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12767 }
12768
12769 uint hashes_cnt_orig = hashes_cnt;
12770
12771 hashes_cnt = 1;
12772
12773 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12774 {
12775 if (isSalted)
12776 {
12777 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12778 {
12779 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12780 }
12781 }
12782 else
12783 {
12784 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12785 }
12786
12787 if (hashes_pos > hashes_cnt)
12788 {
12789 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12790 }
12791
12792 hashes_cnt++;
12793 }
12794
12795 /**
12796 * Potfile removes
12797 */
12798
12799 uint potfile_remove_cracks = 0;
12800
12801 if (potfile_disable == 0)
12802 {
12803 hash_t hash_buf;
12804
12805 hash_buf.digest = mymalloc (dgst_size);
12806 hash_buf.salt = NULL;
12807 hash_buf.esalt = NULL;
12808 hash_buf.hash_info = NULL;
12809 hash_buf.cracked = 0;
12810
12811 if (isSalted)
12812 {
12813 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12814 }
12815
12816 if (esalt_size)
12817 {
12818 hash_buf.esalt = mymalloc (esalt_size);
12819 }
12820
12821 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12822
12823 // no solution for these special hash types (for instane because they use hashfile in output etc)
12824 if ((hash_mode != 5200) &&
12825 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12826 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12827 (hash_mode != 9000))
12828 {
12829 FILE *fp = fopen (potfile, "rb");
12830
12831 if (fp != NULL)
12832 {
12833 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12834
12835 // to be safe work with a copy (because of line_len loop, i etc)
12836 // moved up here because it's easier to handle continue case
12837 // it's just 64kb
12838
12839 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12840
12841 while (!feof (fp))
12842 {
12843 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12844
12845 if (ptr == NULL) break;
12846
12847 int line_len = strlen (line_buf);
12848
12849 if (line_len == 0) continue;
12850
12851 int iter = MAX_CUT_TRIES;
12852
12853 for (int i = line_len - 1; i && iter; i--, line_len--)
12854 {
12855 if (line_buf[i] != ':') continue;
12856
12857 if (isSalted)
12858 {
12859 memset (hash_buf.salt, 0, sizeof (salt_t));
12860 }
12861
12862 hash_t *found = NULL;
12863
12864 if (hash_mode == 6800)
12865 {
12866 if (i < 64) // 64 = 16 * uint in salt_buf[]
12867 {
12868 // manipulate salt_buf
12869 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12870
12871 hash_buf.salt->salt_len = i;
12872
12873 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12874 }
12875 }
12876 else if (hash_mode == 2500)
12877 {
12878 if (i < 64) // 64 = 16 * uint in salt_buf[]
12879 {
12880 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12881 // manipulate salt_buf
12882
12883 memcpy (line_buf_cpy, line_buf, i);
12884
12885 char *mac2_pos = strrchr (line_buf_cpy, ':');
12886
12887 if (mac2_pos == NULL) continue;
12888
12889 mac2_pos[0] = 0;
12890 mac2_pos++;
12891
12892 if (strlen (mac2_pos) != 12) continue;
12893
12894 char *mac1_pos = strrchr (line_buf_cpy, ':');
12895
12896 if (mac1_pos == NULL) continue;
12897
12898 mac1_pos[0] = 0;
12899 mac1_pos++;
12900
12901 if (strlen (mac1_pos) != 12) continue;
12902
12903 uint essid_length = mac1_pos - line_buf_cpy - 1;
12904
12905 // here we need the ESSID
12906 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12907
12908 hash_buf.salt->salt_len = essid_length;
12909
12910 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12911
12912 if (found)
12913 {
12914 wpa_t *wpa = (wpa_t *) found->esalt;
12915
12916 // compare hex string(s) vs binary MAC address(es)
12917
12918 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12919 {
12920 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12921 {
12922 found = NULL;
12923
12924 break;
12925 }
12926 }
12927
12928 // early skip ;)
12929 if (!found) continue;
12930
12931 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12932 {
12933 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12934 {
12935 found = NULL;
12936
12937 break;
12938 }
12939 }
12940 }
12941 }
12942 }
12943 else
12944 {
12945 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12946
12947 if (parser_status == PARSER_OK)
12948 {
12949 if (isSalted)
12950 {
12951 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12952 }
12953 else
12954 {
12955 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12956 }
12957 }
12958 }
12959
12960 if (found == NULL) continue;
12961
12962 if (!found->cracked) potfile_remove_cracks++;
12963
12964 found->cracked = 1;
12965
12966 if (found) break;
12967
12968 iter--;
12969 }
12970 }
12971
12972 myfree (line_buf_cpy);
12973
12974 myfree (line_buf);
12975
12976 fclose (fp);
12977 }
12978 }
12979
12980 if (esalt_size)
12981 {
12982 local_free (hash_buf.esalt);
12983 }
12984
12985 if (isSalted)
12986 {
12987 local_free (hash_buf.salt);
12988 }
12989
12990 local_free (hash_buf.digest);
12991 }
12992
12993 /**
12994 * Now generate all the buffers required for later
12995 */
12996
12997 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12998
12999 salt_t *salts_buf_new = NULL;
13000 void *esalts_buf_new = NULL;
13001
13002 if (isSalted)
13003 {
13004 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13005
13006 if (esalt_size)
13007 {
13008 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13009 }
13010 }
13011 else
13012 {
13013 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13014 }
13015
13016 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13017
13018 uint digests_cnt = hashes_cnt;
13019 uint digests_done = 0;
13020
13021 size_t size_digests = digests_cnt * dgst_size;
13022 size_t size_shown = digests_cnt * sizeof (uint);
13023
13024 uint *digests_shown = (uint *) mymalloc (size_shown);
13025 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13026
13027 uint salts_cnt = 0;
13028 uint salts_done = 0;
13029
13030 hashinfo_t **hash_info = NULL;
13031
13032 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13033 {
13034 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13035
13036 if (username && (remove || show))
13037 {
13038 uint user_pos;
13039
13040 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13041 {
13042 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13043
13044 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13045 }
13046 }
13047 }
13048
13049 uint *salts_shown = (uint *) mymalloc (size_shown);
13050
13051 salt_t *salt_buf;
13052
13053 {
13054 // copied from inner loop
13055
13056 salt_buf = &salts_buf_new[salts_cnt];
13057
13058 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13059
13060 if (esalt_size)
13061 {
13062 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13063 }
13064
13065 salt_buf->digests_cnt = 0;
13066 salt_buf->digests_done = 0;
13067 salt_buf->digests_offset = 0;
13068
13069 salts_cnt++;
13070 }
13071
13072 if (hashes_buf[0].cracked == 1)
13073 {
13074 digests_shown[0] = 1;
13075
13076 digests_done++;
13077
13078 salt_buf->digests_done++;
13079 }
13080
13081 salt_buf->digests_cnt++;
13082
13083 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13084
13085 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13086 {
13087 hash_info[0] = hashes_buf[0].hash_info;
13088 }
13089
13090 // copy from inner loop
13091
13092 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13093 {
13094 if (isSalted)
13095 {
13096 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13097 {
13098 salt_buf = &salts_buf_new[salts_cnt];
13099
13100 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13101
13102 if (esalt_size)
13103 {
13104 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13105 }
13106
13107 salt_buf->digests_cnt = 0;
13108 salt_buf->digests_done = 0;
13109 salt_buf->digests_offset = hashes_pos;
13110
13111 salts_cnt++;
13112 }
13113 }
13114
13115 if (hashes_buf[hashes_pos].cracked == 1)
13116 {
13117 digests_shown[hashes_pos] = 1;
13118
13119 digests_done++;
13120
13121 salt_buf->digests_done++;
13122 }
13123
13124 salt_buf->digests_cnt++;
13125
13126 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13127
13128 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13129 {
13130 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13131 }
13132 }
13133
13134 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13135 {
13136 salt_t *salt_buf = &salts_buf_new[salt_pos];
13137
13138 if (salt_buf->digests_done == salt_buf->digests_cnt)
13139 {
13140 salts_shown[salt_pos] = 1;
13141
13142 salts_done++;
13143 }
13144
13145 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13146 }
13147
13148 local_free (digests_buf);
13149 local_free (salts_buf);
13150 local_free (esalts_buf);
13151
13152 digests_buf = digests_buf_new;
13153 salts_buf = salts_buf_new;
13154 esalts_buf = esalts_buf_new;
13155
13156 local_free (hashes_buf);
13157
13158 /**
13159 * special modification not set from parser
13160 */
13161
13162 switch (hash_mode)
13163 {
13164 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13165 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13166 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13167 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13168 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13169 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13170 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13171 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13172 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13173 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13174 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13175 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13176 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13177 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13178 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13179 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13180 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13181 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13182 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13183 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13184 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13185 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13186 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13187 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13188 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13189 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13190 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13191 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13192 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13193 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13194 }
13195
13196 if (truecrypt_keyfiles)
13197 {
13198 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13199
13200 char *keyfiles = strdup (truecrypt_keyfiles);
13201
13202 char *keyfile = strtok (keyfiles, ",");
13203
13204 do
13205 {
13206 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13207
13208 } while ((keyfile = strtok (NULL, ",")) != NULL);
13209
13210 free (keyfiles);
13211 }
13212
13213 if (veracrypt_keyfiles)
13214 {
13215 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13216
13217 char *keyfiles = strdup (veracrypt_keyfiles);
13218
13219 char *keyfile = strtok (keyfiles, ",");
13220
13221 do
13222 {
13223 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13224
13225 } while ((keyfile = strtok (NULL, ",")) != NULL);
13226
13227 free (keyfiles);
13228 }
13229
13230 data.digests_cnt = digests_cnt;
13231 data.digests_done = digests_done;
13232 data.digests_buf = digests_buf;
13233 data.digests_shown = digests_shown;
13234 data.digests_shown_tmp = digests_shown_tmp;
13235
13236 data.salts_cnt = salts_cnt;
13237 data.salts_done = salts_done;
13238 data.salts_buf = salts_buf;
13239 data.salts_shown = salts_shown;
13240
13241 data.esalts_buf = esalts_buf;
13242 data.hash_info = hash_info;
13243
13244 /**
13245 * Automatic Optimizers
13246 */
13247
13248 if (salts_cnt == 1)
13249 opti_type |= OPTI_TYPE_SINGLE_SALT;
13250
13251 if (digests_cnt == 1)
13252 opti_type |= OPTI_TYPE_SINGLE_HASH;
13253
13254 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13255 opti_type |= OPTI_TYPE_NOT_ITERATED;
13256
13257 if (attack_mode == ATTACK_MODE_BF)
13258 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13259
13260 data.opti_type = opti_type;
13261
13262 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13263 {
13264 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13265 {
13266 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13267 {
13268 if (opts_type & OPTS_TYPE_ST_ADD80)
13269 {
13270 opts_type &= ~OPTS_TYPE_ST_ADD80;
13271 opts_type |= OPTS_TYPE_PT_ADD80;
13272 }
13273
13274 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13275 {
13276 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13277 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13278 }
13279
13280 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13281 {
13282 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13283 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13284 }
13285 }
13286 }
13287 }
13288
13289 /**
13290 * Some algorithm, like descrypt, can benefit from JIT compilation
13291 */
13292
13293 int force_jit_compilation = -1;
13294
13295 if (hash_mode == 8900)
13296 {
13297 force_jit_compilation = 8900;
13298 }
13299 else if (hash_mode == 9300)
13300 {
13301 force_jit_compilation = 8900;
13302 }
13303 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13304 {
13305 force_jit_compilation = 1500;
13306 }
13307
13308 /**
13309 * generate bitmap tables
13310 */
13311
13312 const uint bitmap_shift1 = 5;
13313 const uint bitmap_shift2 = 13;
13314
13315 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13316
13317 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13318 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13319 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13320 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13321 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13322 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13323 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13324 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13325
13326 uint bitmap_bits;
13327 uint bitmap_nums;
13328 uint bitmap_mask;
13329 uint bitmap_size;
13330
13331 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13332 {
13333 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13334
13335 bitmap_nums = 1 << bitmap_bits;
13336
13337 bitmap_mask = bitmap_nums - 1;
13338
13339 bitmap_size = bitmap_nums * sizeof (uint);
13340
13341 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13342
13343 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;
13344 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;
13345
13346 break;
13347 }
13348
13349 bitmap_nums = 1 << bitmap_bits;
13350
13351 bitmap_mask = bitmap_nums - 1;
13352
13353 bitmap_size = bitmap_nums * sizeof (uint);
13354
13355 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);
13356 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);
13357
13358 /**
13359 * prepare quick rule
13360 */
13361
13362 data.rule_buf_l = rule_buf_l;
13363 data.rule_buf_r = rule_buf_r;
13364
13365 int rule_len_l = (int) strlen (rule_buf_l);
13366 int rule_len_r = (int) strlen (rule_buf_r);
13367
13368 data.rule_len_l = rule_len_l;
13369 data.rule_len_r = rule_len_r;
13370
13371 /**
13372 * load rules
13373 */
13374
13375 uint *all_kernel_rules_cnt = NULL;
13376
13377 kernel_rule_t **all_kernel_rules_buf = NULL;
13378
13379 if (rp_files_cnt)
13380 {
13381 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13382
13383 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13384 }
13385
13386 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13387
13388 int rule_len = 0;
13389
13390 for (uint i = 0; i < rp_files_cnt; i++)
13391 {
13392 uint kernel_rules_avail = 0;
13393
13394 uint kernel_rules_cnt = 0;
13395
13396 kernel_rule_t *kernel_rules_buf = NULL;
13397
13398 char *rp_file = rp_files[i];
13399
13400 char in[BLOCK_SIZE] = { 0 };
13401 char out[BLOCK_SIZE] = { 0 };
13402
13403 FILE *fp = NULL;
13404
13405 uint rule_line = 0;
13406
13407 if ((fp = fopen (rp_file, "rb")) == NULL)
13408 {
13409 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13410
13411 return (-1);
13412 }
13413
13414 while (!feof (fp))
13415 {
13416 memset (rule_buf, 0, HCBUFSIZ);
13417
13418 rule_len = fgetl (fp, rule_buf);
13419
13420 rule_line++;
13421
13422 if (rule_len == 0) continue;
13423
13424 if (rule_buf[0] == '#') continue;
13425
13426 if (kernel_rules_avail == kernel_rules_cnt)
13427 {
13428 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13429
13430 kernel_rules_avail += INCR_RULES;
13431 }
13432
13433 memset (in, 0, BLOCK_SIZE);
13434 memset (out, 0, BLOCK_SIZE);
13435
13436 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13437
13438 if (result == -1)
13439 {
13440 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13441
13442 continue;
13443 }
13444
13445 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13446 {
13447 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13448
13449 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13450
13451 continue;
13452 }
13453
13454 /* its so slow
13455 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13456 {
13457 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13458
13459 continue;
13460 }
13461 */
13462
13463 kernel_rules_cnt++;
13464 }
13465
13466 fclose (fp);
13467
13468 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13469
13470 all_kernel_rules_buf[i] = kernel_rules_buf;
13471 }
13472
13473 /**
13474 * merge rules or automatic rule generator
13475 */
13476
13477 uint kernel_rules_cnt = 0;
13478
13479 kernel_rule_t *kernel_rules_buf = NULL;
13480
13481 if (attack_mode == ATTACK_MODE_STRAIGHT)
13482 {
13483 if (rp_files_cnt)
13484 {
13485 kernel_rules_cnt = 1;
13486
13487 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13488
13489 repeats[0] = kernel_rules_cnt;
13490
13491 for (uint i = 0; i < rp_files_cnt; i++)
13492 {
13493 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13494
13495 repeats[i + 1] = kernel_rules_cnt;
13496 }
13497
13498 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13499
13500 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13501
13502 for (uint i = 0; i < kernel_rules_cnt; i++)
13503 {
13504 uint out_pos = 0;
13505
13506 kernel_rule_t *out = &kernel_rules_buf[i];
13507
13508 for (uint j = 0; j < rp_files_cnt; j++)
13509 {
13510 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13511 uint in_pos;
13512
13513 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13514
13515 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13516 {
13517 if (out_pos == RULES_MAX - 1)
13518 {
13519 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13520
13521 break;
13522 }
13523
13524 out->cmds[out_pos] = in->cmds[in_pos];
13525 }
13526 }
13527 }
13528
13529 local_free (repeats);
13530 }
13531 else if (rp_gen)
13532 {
13533 uint kernel_rules_avail = 0;
13534
13535 while (kernel_rules_cnt < rp_gen)
13536 {
13537 if (kernel_rules_avail == kernel_rules_cnt)
13538 {
13539 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13540
13541 kernel_rules_avail += INCR_RULES;
13542 }
13543
13544 memset (rule_buf, 0, HCBUFSIZ);
13545
13546 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13547
13548 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13549
13550 kernel_rules_cnt++;
13551 }
13552 }
13553 }
13554
13555 myfree (rule_buf);
13556
13557 /**
13558 * generate NOP rules
13559 */
13560
13561 if (kernel_rules_cnt == 0)
13562 {
13563 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13564
13565 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13566
13567 kernel_rules_cnt++;
13568 }
13569
13570 data.kernel_rules_cnt = kernel_rules_cnt;
13571 data.kernel_rules_buf = kernel_rules_buf;
13572
13573 /**
13574 * OpenCL platforms: detect
13575 */
13576
13577 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13578 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13579
13580 cl_uint platforms_cnt = 0;
13581 cl_uint platform_devices_cnt = 0;
13582
13583 if (keyspace == 0)
13584 {
13585 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13586
13587 if (platforms_cnt == 0)
13588 {
13589 log_info ("");
13590 log_info ("ATTENTION! No OpenCL compatible platform found");
13591 log_info ("");
13592 log_info ("You're probably missing the OpenCL runtime installation");
13593 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13594 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13595 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13596 log_info ("");
13597
13598 return (-1);
13599 }
13600
13601 if (opencl_platforms_filter != (uint) -1)
13602 {
13603 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13604
13605 if (opencl_platforms_filter > platform_cnt_mask)
13606 {
13607 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13608
13609 return (-1);
13610 }
13611 }
13612 }
13613
13614 /**
13615 * OpenCL device types:
13616 * 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.
13617 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13618 */
13619
13620 if (opencl_device_types == NULL)
13621 {
13622 cl_device_type device_types_all = 0;
13623
13624 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13625 {
13626 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13627
13628 cl_platform_id platform = platforms[platform_id];
13629
13630 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13631
13632 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13633 {
13634 cl_device_id device = platform_devices[platform_devices_id];
13635
13636 cl_device_type device_type;
13637
13638 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13639
13640 device_types_all |= device_type;
13641 }
13642 }
13643
13644 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13645 {
13646 device_types_filter |= CL_DEVICE_TYPE_CPU;
13647 }
13648 }
13649
13650 /**
13651 * OpenCL devices: simply push all devices from all platforms into the same device array
13652 */
13653
13654 int need_adl = 0;
13655 int need_nvapi = 0;
13656 int need_nvml = 0;
13657
13658 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13659
13660 data.devices_param = devices_param;
13661
13662 uint devices_cnt = 0;
13663
13664 uint devices_active = 0;
13665
13666 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13667 {
13668 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13669
13670 cl_platform_id platform = platforms[platform_id];
13671
13672 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13673
13674 char platform_vendor[INFOSZ] = { 0 };
13675
13676 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13677
13678 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13679 // this causes trouble with vendor id based macros
13680 // we'll assign generic to those without special optimization available
13681
13682 cl_uint platform_vendor_id = 0;
13683
13684 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13685 {
13686 platform_vendor_id = VENDOR_ID_AMD;
13687 }
13688 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13689 {
13690 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13691 }
13692 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13693 {
13694 platform_vendor_id = VENDOR_ID_APPLE;
13695 }
13696 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13697 {
13698 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13699 }
13700 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13701 {
13702 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13703 }
13704 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13705 {
13706 platform_vendor_id = VENDOR_ID_MESA;
13707 }
13708 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13709 {
13710 platform_vendor_id = VENDOR_ID_NV;
13711 }
13712 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13713 {
13714 platform_vendor_id = VENDOR_ID_POCL;
13715 }
13716 else
13717 {
13718 platform_vendor_id = VENDOR_ID_GENERIC;
13719 }
13720
13721 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13722 {
13723 size_t param_value_size = 0;
13724
13725 const uint device_id = devices_cnt;
13726
13727 hc_device_param_t *device_param = &data.devices_param[device_id];
13728
13729 device_param->platform_vendor_id = platform_vendor_id;
13730
13731 device_param->device = platform_devices[platform_devices_id];
13732
13733 device_param->device_id = device_id;
13734
13735 device_param->platform_devices_id = platform_devices_id;
13736
13737 // device_type
13738
13739 cl_device_type device_type;
13740
13741 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13742
13743 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13744
13745 device_param->device_type = device_type;
13746
13747 // device_name
13748
13749 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13750
13751 char *device_name = (char *) mymalloc (param_value_size);
13752
13753 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13754
13755 device_param->device_name = device_name;
13756
13757 // device_vendor
13758
13759 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13760
13761 char *device_vendor = (char *) mymalloc (param_value_size);
13762
13763 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13764
13765 device_param->device_vendor = device_vendor;
13766
13767 cl_uint device_vendor_id = 0;
13768
13769 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13770 {
13771 device_vendor_id = VENDOR_ID_AMD;
13772 }
13773 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13774 {
13775 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13776 }
13777 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13778 {
13779 device_vendor_id = VENDOR_ID_APPLE;
13780 }
13781 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13782 {
13783 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13784 }
13785 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13786 {
13787 device_vendor_id = VENDOR_ID_INTEL_SDK;
13788 }
13789 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13790 {
13791 device_vendor_id = VENDOR_ID_MESA;
13792 }
13793 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13794 {
13795 device_vendor_id = VENDOR_ID_NV;
13796 }
13797 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13798 {
13799 device_vendor_id = VENDOR_ID_POCL;
13800 }
13801 else
13802 {
13803 device_vendor_id = VENDOR_ID_GENERIC;
13804 }
13805
13806 device_param->device_vendor_id = device_vendor_id;
13807
13808 // tuning db
13809
13810 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13811
13812 // device_version
13813
13814 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13815
13816 char *device_version = (char *) mymalloc (param_value_size);
13817
13818 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13819
13820 device_param->device_version = device_version;
13821
13822 // device_opencl_version
13823
13824 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13825
13826 char *device_opencl_version = (char *) mymalloc (param_value_size);
13827
13828 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13829
13830 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13831
13832 myfree (device_opencl_version);
13833
13834 // vector_width
13835
13836 cl_uint vector_width;
13837
13838 if (opencl_vector_width_chgd == 0)
13839 {
13840 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13841 {
13842 if (opti_type & OPTI_TYPE_USES_BITS_64)
13843 {
13844 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13845 }
13846 else
13847 {
13848 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13849 }
13850 }
13851 else
13852 {
13853 vector_width = (cl_uint) tuningdb_entry->vector_width;
13854 }
13855 }
13856 else
13857 {
13858 vector_width = opencl_vector_width;
13859 }
13860
13861 if (vector_width > 16) vector_width = 16;
13862
13863 device_param->vector_width = vector_width;
13864
13865 // max_compute_units
13866
13867 cl_uint device_processors;
13868
13869 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13870
13871 device_param->device_processors = device_processors;
13872
13873 // device_maxmem_alloc
13874 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13875
13876 cl_ulong device_maxmem_alloc;
13877
13878 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13879
13880 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13881
13882 // device_global_mem
13883
13884 cl_ulong device_global_mem;
13885
13886 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13887
13888 device_param->device_global_mem = device_global_mem;
13889
13890 // max_work_group_size
13891
13892 size_t device_maxworkgroup_size;
13893
13894 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13895
13896 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13897
13898 // max_clock_frequency
13899
13900 cl_uint device_maxclock_frequency;
13901
13902 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13903
13904 device_param->device_maxclock_frequency = device_maxclock_frequency;
13905
13906 // device_endian_little
13907
13908 cl_bool device_endian_little;
13909
13910 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13911
13912 if (device_endian_little == CL_FALSE)
13913 {
13914 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13915
13916 device_param->skipped = 1;
13917 }
13918
13919 // device_available
13920
13921 cl_bool device_available;
13922
13923 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13924
13925 if (device_available == CL_FALSE)
13926 {
13927 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13928
13929 device_param->skipped = 1;
13930 }
13931
13932 // device_compiler_available
13933
13934 cl_bool device_compiler_available;
13935
13936 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13937
13938 if (device_compiler_available == CL_FALSE)
13939 {
13940 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13941
13942 device_param->skipped = 1;
13943 }
13944
13945 // device_execution_capabilities
13946
13947 cl_device_exec_capabilities device_execution_capabilities;
13948
13949 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13950
13951 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13952 {
13953 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13954
13955 device_param->skipped = 1;
13956 }
13957
13958 // device_extensions
13959
13960 size_t device_extensions_size;
13961
13962 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13963
13964 char *device_extensions = mymalloc (device_extensions_size + 1);
13965
13966 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13967
13968 if (strstr (device_extensions, "base_atomics") == 0)
13969 {
13970 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13971
13972 device_param->skipped = 1;
13973 }
13974
13975 if (strstr (device_extensions, "byte_addressable_store") == 0)
13976 {
13977 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13978
13979 device_param->skipped = 1;
13980 }
13981
13982 myfree (device_extensions);
13983
13984 // device_local_mem_size
13985
13986 cl_ulong device_local_mem_size;
13987
13988 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13989
13990 if (device_local_mem_size < 32768)
13991 {
13992 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13993
13994 device_param->skipped = 1;
13995 }
13996
13997 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13998 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13999 // This results in both utilizing it for 50%
14000 // However, Intel has much better SIMD control over their own hardware
14001 // It makes sense to give them full control over their own hardware
14002
14003 if (device_type & CL_DEVICE_TYPE_CPU)
14004 {
14005 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14006 {
14007 if (data.force == 0)
14008 {
14009 if (algorithm_pos == 0)
14010 {
14011 log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
14012 log_info (" You can use --force to override this but do not post error reports if you do so");
14013 }
14014
14015 device_param->skipped = 1;
14016 }
14017 }
14018 }
14019
14020 // skipped
14021
14022 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14023 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14024
14025 // driver_version
14026
14027 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14028
14029 char *driver_version = (char *) mymalloc (param_value_size);
14030
14031 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14032
14033 device_param->driver_version = driver_version;
14034
14035 // device_name_chksum
14036
14037 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14038
14039 #if __x86_64__
14040 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);
14041 #else
14042 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);
14043 #endif
14044
14045 uint device_name_digest[4] = { 0 };
14046
14047 md5_64 ((uint *) device_name_chksum, device_name_digest);
14048
14049 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14050
14051 device_param->device_name_chksum = device_name_chksum;
14052
14053 // device_processor_cores
14054
14055 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14056 {
14057 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14058 {
14059 need_adl = 1;
14060 }
14061
14062 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14063 {
14064 need_nvml = 1;
14065
14066 #ifdef _WIN
14067 need_nvapi = 1;
14068 #endif
14069 }
14070 }
14071
14072 // device_processor_cores
14073
14074 if (device_type & CL_DEVICE_TYPE_CPU)
14075 {
14076 cl_uint device_processor_cores = 1;
14077
14078 device_param->device_processor_cores = device_processor_cores;
14079 }
14080
14081 if (device_type & CL_DEVICE_TYPE_GPU)
14082 {
14083 if (device_vendor_id == VENDOR_ID_AMD)
14084 {
14085 cl_uint device_processor_cores = 0;
14086
14087 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
14088
14089 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
14090
14091 device_param->device_processor_cores = device_processor_cores;
14092 }
14093 else if (device_vendor_id == VENDOR_ID_NV)
14094 {
14095 cl_uint kernel_exec_timeout = 0;
14096
14097 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14098
14099 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14100
14101 device_param->kernel_exec_timeout = kernel_exec_timeout;
14102
14103 cl_uint device_processor_cores = 0;
14104
14105 #define CL_DEVICE_WARP_SIZE_NV 0x4003
14106
14107 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
14108
14109 device_param->device_processor_cores = device_processor_cores;
14110
14111 cl_uint sm_minor = 0;
14112 cl_uint sm_major = 0;
14113
14114 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14115 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14116
14117 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14118 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14119
14120 device_param->sm_minor = sm_minor;
14121 device_param->sm_major = sm_major;
14122
14123 // CPU burning loop damper
14124 // Value is given as number between 0-100
14125 // By default 100%
14126
14127 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14128
14129 if (nvidia_spin_damp_chgd == 0)
14130 {
14131 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14132 {
14133 /**
14134 * the workaround is not a friend of rule based attacks
14135 * the words from the wordlist combined with fast and slow rules cause
14136 * fluctuations which cause inaccurate wait time estimations
14137 * using a reduced damping percentage almost compensates this
14138 */
14139
14140 device_param->nvidia_spin_damp = 64;
14141 }
14142 }
14143
14144 device_param->nvidia_spin_damp /= 100;
14145 }
14146 else
14147 {
14148 cl_uint device_processor_cores = 1;
14149
14150 device_param->device_processor_cores = device_processor_cores;
14151 }
14152 }
14153
14154 // display results
14155
14156 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14157 {
14158 if (machine_readable == 0)
14159 {
14160 if (device_param->skipped == 0)
14161 {
14162 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14163 device_id + 1,
14164 device_name,
14165 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14166 (unsigned int) (device_global_mem / 1024 / 1024),
14167 (unsigned int) device_processors);
14168 }
14169 else
14170 {
14171 log_info ("Device #%u: %s, skipped",
14172 device_id + 1,
14173 device_name);
14174 }
14175 }
14176 }
14177
14178 // common driver check
14179
14180 if (device_param->skipped == 0)
14181 {
14182 if (device_type & CL_DEVICE_TYPE_GPU)
14183 {
14184 if (platform_vendor_id == VENDOR_ID_AMD)
14185 {
14186 int catalyst_check = (force == 1) ? 0 : 1;
14187
14188 int catalyst_warn = 0;
14189
14190 int catalyst_broken = 0;
14191
14192 if (catalyst_check == 1)
14193 {
14194 catalyst_warn = 1;
14195
14196 // v14.9 and higher
14197 if (atoi (device_param->driver_version) >= 1573)
14198 {
14199 catalyst_warn = 0;
14200 }
14201
14202 catalyst_check = 0;
14203 }
14204
14205 if (catalyst_broken == 1)
14206 {
14207 log_info ("");
14208 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
14209 log_info ("It will pass over cracked hashes and does not report them as cracked");
14210 log_info ("You are STRONGLY encouraged not to use it");
14211 log_info ("You can use --force to override this but do not post error reports if you do so");
14212 log_info ("");
14213
14214 return (-1);
14215 }
14216
14217 if (catalyst_warn == 1)
14218 {
14219 log_info ("");
14220 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
14221 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
14222 log_info ("See hashcat's homepage for official supported catalyst drivers");
14223 #ifdef _WIN
14224 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14225 #endif
14226 log_info ("You can use --force to override this but do not post error reports if you do so");
14227 log_info ("");
14228
14229 return (-1);
14230 }
14231 }
14232 else if (platform_vendor_id == VENDOR_ID_NV)
14233 {
14234 if (device_param->kernel_exec_timeout != 0)
14235 {
14236 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);
14237 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14238 }
14239 }
14240 }
14241
14242 /* turns out pocl still creates segfaults (because of llvm)
14243 if (device_type & CL_DEVICE_TYPE_CPU)
14244 {
14245 if (platform_vendor_id == VENDOR_ID_AMD)
14246 {
14247 if (force == 0)
14248 {
14249 log_info ("");
14250 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14251 log_info ("You are STRONGLY encouraged not to use it");
14252 log_info ("You can use --force to override this but do not post error reports if you do so");
14253 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14254 log_info ("");
14255
14256 return (-1);
14257 }
14258 }
14259 }
14260 */
14261
14262 /**
14263 * kernel accel and loops tuning db adjustment
14264 */
14265
14266 device_param->kernel_accel_min = 1;
14267 device_param->kernel_accel_max = 1024;
14268
14269 device_param->kernel_loops_min = 1;
14270 device_param->kernel_loops_max = 1024;
14271
14272 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14273
14274 if (tuningdb_entry)
14275 {
14276 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14277 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14278
14279 if (_kernel_accel)
14280 {
14281 device_param->kernel_accel_min = _kernel_accel;
14282 device_param->kernel_accel_max = _kernel_accel;
14283 }
14284
14285 if (_kernel_loops)
14286 {
14287 if (workload_profile == 1)
14288 {
14289 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14290 }
14291 else if (workload_profile == 2)
14292 {
14293 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14294 }
14295
14296 device_param->kernel_loops_min = _kernel_loops;
14297 device_param->kernel_loops_max = _kernel_loops;
14298 }
14299 }
14300
14301 // commandline parameters overwrite tuningdb entries
14302
14303 if (kernel_accel)
14304 {
14305 device_param->kernel_accel_min = kernel_accel;
14306 device_param->kernel_accel_max = kernel_accel;
14307 }
14308
14309 if (kernel_loops)
14310 {
14311 device_param->kernel_loops_min = kernel_loops;
14312 device_param->kernel_loops_max = kernel_loops;
14313 }
14314
14315 /**
14316 * activate device
14317 */
14318
14319 devices_active++;
14320 }
14321
14322 // next please
14323
14324 devices_cnt++;
14325 }
14326 }
14327
14328 if (keyspace == 0 && devices_active == 0)
14329 {
14330 log_error ("ERROR: No devices found/left");
14331
14332 return (-1);
14333 }
14334
14335 // 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)
14336
14337 if (devices_filter != (uint) -1)
14338 {
14339 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14340
14341 if (devices_filter > devices_cnt_mask)
14342 {
14343 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14344
14345 return (-1);
14346 }
14347 }
14348
14349 data.devices_cnt = devices_cnt;
14350
14351 data.devices_active = devices_active;
14352
14353 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14354 {
14355 if (machine_readable == 0)
14356 {
14357 log_info ("");
14358 }
14359 }
14360
14361 /**
14362 * HM devices: init
14363 */
14364
14365 #ifdef HAVE_HWMON
14366 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14367 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14368 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14369
14370 if (gpu_temp_disable == 0)
14371 {
14372 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14373 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14374 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14375
14376 data.hm_adl = NULL;
14377 data.hm_nvapi = NULL;
14378 data.hm_nvml = NULL;
14379
14380 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14381 {
14382 data.hm_nvml = nvml;
14383 }
14384
14385 if (data.hm_nvml)
14386 {
14387 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14388 {
14389 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14390
14391 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14392
14393 int tmp_out = 0;
14394
14395 for (int i = 0; i < tmp_in; i++)
14396 {
14397 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14398 }
14399
14400 for (int i = 0; i < tmp_out; i++)
14401 {
14402 unsigned int speed;
14403
14404 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14405
14406 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14407
14408 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14409 }
14410 }
14411 }
14412
14413 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14414 {
14415 data.hm_nvapi = nvapi;
14416 }
14417
14418 if (data.hm_nvapi)
14419 {
14420 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14421 {
14422 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14423
14424 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14425
14426 int tmp_out = 0;
14427
14428 for (int i = 0; i < tmp_in; i++)
14429 {
14430 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14431 }
14432 }
14433 }
14434
14435 if ((need_adl == 1) && (adl_init (adl) == 0))
14436 {
14437 data.hm_adl = adl;
14438 }
14439
14440 if (data.hm_adl)
14441 {
14442 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14443 {
14444 // total number of adapters
14445
14446 int hm_adapters_num;
14447
14448 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14449
14450 // adapter info
14451
14452 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14453
14454 if (lpAdapterInfo == NULL) return (-1);
14455
14456 // get a list (of ids of) valid/usable adapters
14457
14458 int num_adl_adapters = 0;
14459
14460 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14461
14462 if (num_adl_adapters > 0)
14463 {
14464 hc_thread_mutex_lock (mux_adl);
14465
14466 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14467
14468 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14469
14470 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14471 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14472
14473 hc_thread_mutex_unlock (mux_adl);
14474 }
14475
14476 myfree (valid_adl_device_list);
14477 myfree (lpAdapterInfo);
14478 }
14479 }
14480
14481 if (data.hm_adl == NULL && data.hm_nvml == NULL)
14482 {
14483 gpu_temp_disable = 1;
14484 }
14485 }
14486
14487 /**
14488 * OpenCL devices: allocate buffer for device specific information
14489 */
14490
14491 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14492 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14493
14494 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14495
14496 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14497
14498 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14499
14500 /**
14501 * User-defined GPU temp handling
14502 */
14503
14504 if (gpu_temp_disable == 1)
14505 {
14506 gpu_temp_abort = 0;
14507 gpu_temp_retain = 0;
14508 }
14509
14510 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14511 {
14512 if (gpu_temp_abort < gpu_temp_retain)
14513 {
14514 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14515
14516 return (-1);
14517 }
14518 }
14519
14520 data.gpu_temp_disable = gpu_temp_disable;
14521 data.gpu_temp_abort = gpu_temp_abort;
14522 data.gpu_temp_retain = gpu_temp_retain;
14523 #endif
14524
14525 /**
14526 * enable custom signal handler(s)
14527 */
14528
14529 if (benchmark == 0)
14530 {
14531 hc_signal (sigHandler_default);
14532 }
14533 else
14534 {
14535 hc_signal (sigHandler_benchmark);
14536 }
14537
14538 /**
14539 * inform the user
14540 */
14541
14542 if (data.quiet == 0)
14543 {
14544 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14545
14546 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);
14547
14548 if (attack_mode == ATTACK_MODE_STRAIGHT)
14549 {
14550 log_info ("Rules: %u", kernel_rules_cnt);
14551 }
14552
14553 if (opti_type)
14554 {
14555 log_info ("Applicable Optimizers:");
14556
14557 for (uint i = 0; i < 32; i++)
14558 {
14559 const uint opti_bit = 1u << i;
14560
14561 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14562 }
14563 }
14564
14565 /**
14566 * Watchdog and Temperature balance
14567 */
14568
14569 #ifdef HAVE_HWMON
14570 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL)
14571 {
14572 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14573 }
14574
14575 if (gpu_temp_abort == 0)
14576 {
14577 log_info ("Watchdog: Temperature abort trigger disabled");
14578 }
14579 else
14580 {
14581 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14582 }
14583
14584 if (gpu_temp_retain == 0)
14585 {
14586 log_info ("Watchdog: Temperature retain trigger disabled");
14587 }
14588 else
14589 {
14590 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14591 }
14592
14593 if (data.quiet == 0) log_info ("");
14594 #endif
14595 }
14596
14597 #ifdef HAVE_HWMON
14598
14599 /**
14600 * HM devices: copy
14601 */
14602
14603 if (gpu_temp_disable == 0)
14604 {
14605 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14606 {
14607 hc_device_param_t *device_param = &data.devices_param[device_id];
14608
14609 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14610
14611 if (device_param->skipped) continue;
14612
14613 const uint platform_devices_id = device_param->platform_devices_id;
14614
14615 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14616 {
14617 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14618 data.hm_device[device_id].nvapi = 0;
14619 data.hm_device[device_id].nvml = 0;
14620 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14621 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14622 data.hm_device[device_id].fan_set_supported = hm_adapters_adl[platform_devices_id].fan_set_supported;
14623 }
14624
14625 if (device_param->device_vendor_id == VENDOR_ID_NV)
14626 {
14627 data.hm_device[device_id].adl = 0;
14628 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14629 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14630 data.hm_device[device_id].od_version = 0;
14631 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14632 data.hm_device[device_id].fan_set_supported = 0;
14633 }
14634 }
14635 }
14636
14637 /**
14638 * powertune on user request
14639 */
14640
14641 if (powertune_enable == 1)
14642 {
14643 hc_thread_mutex_lock (mux_adl);
14644
14645 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14646 {
14647 hc_device_param_t *device_param = &data.devices_param[device_id];
14648
14649 if (device_param->skipped) continue;
14650
14651 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14652 {
14653 /**
14654 * Temporary fix:
14655 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14656 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14657 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14658 * Driver / ADL bug?
14659 */
14660
14661 if (data.hm_device[device_id].od_version == 6)
14662 {
14663 int ADL_rc;
14664
14665 // check powertune capabilities first, if not available then skip device
14666
14667 int powertune_supported = 0;
14668
14669 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14670 {
14671 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14672
14673 return (-1);
14674 }
14675
14676 // first backup current value, we will restore it later
14677
14678 if (powertune_supported != 0)
14679 {
14680 // powercontrol settings
14681
14682 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14683
14684 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14685 {
14686 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14687 }
14688
14689 if (ADL_rc != ADL_OK)
14690 {
14691 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14692
14693 return (-1);
14694 }
14695
14696 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14697 {
14698 log_error ("ERROR: Failed to set new ADL PowerControl values");
14699
14700 return (-1);
14701 }
14702
14703 // clocks
14704
14705 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14706
14707 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14708
14709 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)
14710 {
14711 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14712
14713 return (-1);
14714 }
14715
14716 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14717
14718 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14719
14720 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14721 {
14722 log_error ("ERROR: Failed to get ADL device capabilities");
14723
14724 return (-1);
14725 }
14726
14727 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14728 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14729
14730 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14731 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14732
14733 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14734 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14735
14736 // warning if profile has too low max values
14737
14738 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14739 {
14740 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14741 }
14742
14743 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14744 {
14745 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14746 }
14747
14748 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14749
14750 performance_state->iNumberOfPerformanceLevels = 2;
14751
14752 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14753 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14754 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14755 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14756
14757 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)
14758 {
14759 log_info ("ERROR: Failed to set ADL performance state");
14760
14761 return (-1);
14762 }
14763
14764 local_free (performance_state);
14765 }
14766
14767 // set powertune value only
14768
14769 if (powertune_supported != 0)
14770 {
14771 // powertune set
14772 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14773
14774 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14775 {
14776 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14777
14778 return (-1);
14779 }
14780
14781 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14782 {
14783 log_error ("ERROR: Failed to set new ADL PowerControl values");
14784
14785 return (-1);
14786 }
14787 }
14788 }
14789 }
14790
14791 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14792 {
14793 // first backup current value, we will restore it later
14794
14795 unsigned int limit;
14796
14797 int powertune_supported = 0;
14798
14799 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14800 {
14801 powertune_supported = 1;
14802 }
14803
14804 // if backup worked, activate the maximum allowed
14805
14806 if (powertune_supported != 0)
14807 {
14808 unsigned int minLimit;
14809 unsigned int maxLimit;
14810
14811 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14812 {
14813 if (maxLimit > 0)
14814 {
14815 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14816 {
14817 // now we can be sure we need to reset later
14818
14819 nvml_power_limit[device_id] = limit;
14820 }
14821 }
14822 }
14823 }
14824 }
14825 }
14826
14827 hc_thread_mutex_unlock (mux_adl);
14828 }
14829
14830 #endif // HAVE_HWMON
14831
14832 #ifdef DEBUG
14833 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14834 #endif
14835
14836 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14837
14838 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14839 {
14840 /**
14841 * host buffer
14842 */
14843
14844 hc_device_param_t *device_param = &data.devices_param[device_id];
14845
14846 if (device_param->skipped) continue;
14847
14848 /**
14849 * device properties
14850 */
14851
14852 const char *device_name_chksum = device_param->device_name_chksum;
14853 const u32 device_processors = device_param->device_processors;
14854 const u32 device_processor_cores = device_param->device_processor_cores;
14855
14856 /**
14857 * create context for each device
14858 */
14859
14860 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14861
14862 /**
14863 * create command-queue
14864 */
14865
14866 // not supported with NV
14867 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14868
14869 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14870
14871 /**
14872 * kernel threads: some algorithms need a fixed kernel-threads count
14873 * because of shared memory usage or bitslice
14874 * there needs to be some upper limit, otherwise there's too much overhead
14875 */
14876
14877 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14878
14879 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14880 {
14881 kernel_threads = KERNEL_THREADS_MAX_CPU;
14882 }
14883
14884 if (hash_mode == 1500) kernel_threads = 64; // DES
14885 if (hash_mode == 3000) kernel_threads = 64; // DES
14886 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14887 if (hash_mode == 7500) kernel_threads = 64; // RC4
14888 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14889 if (hash_mode == 9700) kernel_threads = 64; // RC4
14890 if (hash_mode == 9710) kernel_threads = 64; // RC4
14891 if (hash_mode == 9800) kernel_threads = 64; // RC4
14892 if (hash_mode == 9810) kernel_threads = 64; // RC4
14893 if (hash_mode == 10400) kernel_threads = 64; // RC4
14894 if (hash_mode == 10410) kernel_threads = 64; // RC4
14895 if (hash_mode == 10500) kernel_threads = 64; // RC4
14896 if (hash_mode == 13100) kernel_threads = 64; // RC4
14897
14898 device_param->kernel_threads = kernel_threads;
14899
14900 device_param->hardware_power = device_processors * kernel_threads;
14901
14902 /**
14903 * create input buffers on device : calculate size of fixed memory buffers
14904 */
14905
14906 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14907 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14908
14909 device_param->size_root_css = size_root_css;
14910 device_param->size_markov_css = size_markov_css;
14911
14912 size_t size_results = sizeof (uint);
14913
14914 device_param->size_results = size_results;
14915
14916 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14917 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14918
14919 size_t size_plains = digests_cnt * sizeof (plain_t);
14920 size_t size_salts = salts_cnt * sizeof (salt_t);
14921 size_t size_esalts = salts_cnt * esalt_size;
14922
14923 device_param->size_plains = size_plains;
14924 device_param->size_digests = size_digests;
14925 device_param->size_shown = size_shown;
14926 device_param->size_salts = size_salts;
14927
14928 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14929 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14930 size_t size_tm = 32 * sizeof (bs_word_t);
14931
14932 // scryptV stuff
14933
14934 size_t size_scryptV = 1;
14935
14936 if ((hash_mode == 8900) || (hash_mode == 9300))
14937 {
14938 uint tmto_start = 0;
14939 uint tmto_stop = 10;
14940
14941 if (scrypt_tmto)
14942 {
14943 tmto_start = scrypt_tmto;
14944 }
14945 else
14946 {
14947 // in case the user did not specify the tmto manually
14948 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14949 // but set the lower end only in case the user has a device with too less memory
14950
14951 if (hash_mode == 8900)
14952 {
14953 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14954 {
14955 tmto_start = 1;
14956 }
14957 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14958 {
14959 tmto_start = 2;
14960 }
14961 }
14962 else if (hash_mode == 9300)
14963 {
14964 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14965 {
14966 tmto_start = 2;
14967 }
14968 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14969 {
14970 tmto_start = 2;
14971 }
14972 }
14973 }
14974
14975 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14976 {
14977 // TODO: in theory the following calculation needs to be done per salt, not global
14978 // we assume all hashes have the same scrypt settings
14979
14980 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14981
14982 size_scryptV /= 1 << tmto;
14983
14984 size_scryptV *= device_processors * device_processor_cores;
14985
14986 if (size_scryptV > device_param->device_maxmem_alloc)
14987 {
14988 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14989
14990 continue;
14991 }
14992
14993 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14994 {
14995 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14996 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14997 }
14998
14999 break;
15000 }
15001
15002 if (data.salts_buf[0].scrypt_phy == 0)
15003 {
15004 log_error ("ERROR: can't allocate enough device memory");
15005
15006 return -1;
15007 }
15008
15009 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
15010 }
15011
15012 /**
15013 * some algorithms need a fixed kernel-loops count
15014 */
15015
15016 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15017 {
15018 const u32 kernel_loops_fixed = 1024;
15019
15020 device_param->kernel_loops_min = kernel_loops_fixed;
15021 device_param->kernel_loops_max = kernel_loops_fixed;
15022 }
15023
15024 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15025 {
15026 const u32 kernel_loops_fixed = 1024;
15027
15028 device_param->kernel_loops_min = kernel_loops_fixed;
15029 device_param->kernel_loops_max = kernel_loops_fixed;
15030 }
15031
15032 if (hash_mode == 8900)
15033 {
15034 const u32 kernel_loops_fixed = 1;
15035
15036 device_param->kernel_loops_min = kernel_loops_fixed;
15037 device_param->kernel_loops_max = kernel_loops_fixed;
15038 }
15039
15040 if (hash_mode == 9300)
15041 {
15042 const u32 kernel_loops_fixed = 1;
15043
15044 device_param->kernel_loops_min = kernel_loops_fixed;
15045 device_param->kernel_loops_max = kernel_loops_fixed;
15046 }
15047
15048 if (hash_mode == 12500)
15049 {
15050 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15051
15052 device_param->kernel_loops_min = kernel_loops_fixed;
15053 device_param->kernel_loops_max = kernel_loops_fixed;
15054 }
15055
15056 /**
15057 * some algorithms have a maximum kernel-loops count
15058 */
15059
15060 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15061 {
15062 u32 innerloop_cnt = 0;
15063
15064 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15065 {
15066 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15067 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15068 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15069 }
15070 else
15071 {
15072 innerloop_cnt = data.salts_buf[0].salt_iter;
15073 }
15074
15075 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15076 (innerloop_cnt <= device_param->kernel_loops_max))
15077 {
15078 device_param->kernel_loops_max = innerloop_cnt;
15079 }
15080 }
15081
15082 u32 kernel_accel_min = device_param->kernel_accel_min;
15083 u32 kernel_accel_max = device_param->kernel_accel_max;
15084
15085 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15086
15087 size_t size_pws = 4;
15088 size_t size_tmps = 4;
15089 size_t size_hooks = 4;
15090
15091 while (kernel_accel_max >= kernel_accel_min)
15092 {
15093 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15094
15095 // size_pws
15096
15097 size_pws = kernel_power_max * sizeof (pw_t);
15098
15099 // size_tmps
15100
15101 switch (hash_mode)
15102 {
15103 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15104 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15105 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15106 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15107 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15108 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15109 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15110 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15111 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15112 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15113 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15114 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15115 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15116 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15117 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15118 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15119 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15120 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15121 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15122 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15123 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15124 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15125 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15126 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15127 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15128 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15129 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15130 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15131 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15132 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15133 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15134 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15135 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15136 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15137 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15138 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15139 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15140 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15141 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15142 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15143 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15144 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15145 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15146 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15147 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15148 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15149 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15150 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15151 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15152 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15153 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15154 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15155 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15156 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15157 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15158 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15159 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15160 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15161 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15162 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15163 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15164 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15165 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15166 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15167 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15168 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15169 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15170 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15171 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15172 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15173 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15174 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15175 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15176 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15177 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15178 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15179 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15180 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15181 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15182 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15183 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15184 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15185 };
15186
15187 // size_hooks
15188
15189 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15190 {
15191 switch (hash_mode)
15192 {
15193 }
15194 }
15195
15196 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15197 // if not, decrease amplifier and try again
15198
15199 int skip = 0;
15200
15201 const u64 size_total
15202 = bitmap_size
15203 + bitmap_size
15204 + bitmap_size
15205 + bitmap_size
15206 + bitmap_size
15207 + bitmap_size
15208 + bitmap_size
15209 + bitmap_size
15210 + size_bfs
15211 + size_combs
15212 + size_digests
15213 + size_esalts
15214 + size_hooks
15215 + size_markov_css
15216 + size_plains
15217 + size_pws
15218 + size_pws // not a bug
15219 + size_results
15220 + size_root_css
15221 + size_rules
15222 + size_rules_c
15223 + size_salts
15224 + size_scryptV
15225 + size_shown
15226 + size_tm
15227 + size_tmps;
15228
15229 // Don't ask me, ask AMD!
15230
15231 if (size_total > device_param->device_maxmem_alloc) skip = 1;
15232 if (size_total > device_param->device_global_mem) skip = 1;
15233
15234 if (skip == 1)
15235 {
15236 kernel_accel_max--;
15237
15238 continue;
15239 }
15240
15241 break;
15242 }
15243
15244 /*
15245 if (kernel_accel_max == 0)
15246 {
15247 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
15248
15249 return -1;
15250 }
15251 */
15252
15253 device_param->kernel_accel_min = kernel_accel_min;
15254 device_param->kernel_accel_max = kernel_accel_max;
15255
15256 /*
15257 if (kernel_accel_max < kernel_accel)
15258 {
15259 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15260
15261 device_param->kernel_accel = kernel_accel_max;
15262 }
15263 */
15264
15265 device_param->size_bfs = size_bfs;
15266 device_param->size_combs = size_combs;
15267 device_param->size_rules = size_rules;
15268 device_param->size_rules_c = size_rules_c;
15269 device_param->size_pws = size_pws;
15270 device_param->size_tmps = size_tmps;
15271 device_param->size_hooks = size_hooks;
15272
15273 /**
15274 * default building options
15275 */
15276
15277 char build_opts[1024] = { 0 };
15278
15279 // we don't have sm_* on vendors not NV but it doesn't matter
15280
15281 #if _WIN
15282 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\\OpenCL\\\" -I '%s\\OpenCL\\' -I %s\\OpenCL\\ -I\"%s\\OpenCL\\\" -I'%s\\OpenCL\\' -I%s\\OpenCL\\", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
15283 #else
15284 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s/OpenCL/\" -I '%s/OpenCL/' -I %s/OpenCL/ -I\"%s/OpenCL/\" -I'%s/OpenCL/' -I%s/OpenCL/", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
15285 #endif
15286
15287 char build_opts_new[1024] = { 0 };
15288
15289 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_TYPE=%u -D_unroll -cl-std=CL1.1", build_opts, device_param->device_vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
15290
15291 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15292
15293 /*
15294 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
15295 {
15296 // we do vectorizing much better than the auto-vectorizer
15297
15298 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
15299
15300 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15301 }
15302 */
15303
15304 #ifdef DEBUG
15305 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15306 #endif
15307
15308 /**
15309 * main kernel
15310 */
15311
15312 {
15313 /**
15314 * kernel source filename
15315 */
15316
15317 char source_file[256] = { 0 };
15318
15319 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15320
15321 struct stat sst;
15322
15323 if (stat (source_file, &sst) == -1)
15324 {
15325 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15326
15327 return -1;
15328 }
15329
15330 /**
15331 * kernel cached filename
15332 */
15333
15334 char cached_file[256] = { 0 };
15335
15336 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15337
15338 int cached = 1;
15339
15340 struct stat cst;
15341
15342 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15343 {
15344 cached = 0;
15345 }
15346
15347 /**
15348 * kernel compile or load
15349 */
15350
15351 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15352
15353 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15354
15355 if (force_jit_compilation == -1)
15356 {
15357 if (cached == 0)
15358 {
15359 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15360
15361 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15362
15363 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15364
15365 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15366
15367 #ifdef DEBUG
15368 size_t build_log_size = 0;
15369
15370 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15371
15372 if (build_log_size > 1)
15373 {
15374 char *build_log = (char *) malloc (build_log_size + 1);
15375
15376 memset (build_log, 0, build_log_size + 1);
15377
15378 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15379
15380 puts (build_log);
15381
15382 free (build_log);
15383 }
15384 #endif
15385
15386 if (rc != 0)
15387 {
15388 device_param->skipped = true;
15389
15390 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15391
15392 continue;
15393 }
15394
15395 size_t binary_size;
15396
15397 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15398
15399 u8 *binary = (u8 *) mymalloc (binary_size);
15400
15401 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15402
15403 writeProgramBin (cached_file, binary, binary_size);
15404
15405 local_free (binary);
15406 }
15407 else
15408 {
15409 #ifdef DEBUG
15410 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15411 #endif
15412
15413 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15414
15415 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15416
15417 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15418 }
15419 }
15420 else
15421 {
15422 #ifdef DEBUG
15423 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15424 #endif
15425
15426 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15427
15428 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15429
15430 char build_opts_update[1024] = { 0 };
15431
15432 if (force_jit_compilation == 1500)
15433 {
15434 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15435 }
15436 else if (force_jit_compilation == 8900)
15437 {
15438 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DSCRYPT_N=%d -DSCRYPT_R=%d -DSCRYPT_P=%d -DSCRYPT_TMTO=%d", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, 1 << data.salts_buf[0].scrypt_tmto);
15439 }
15440 else
15441 {
15442 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15443 }
15444
15445 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15446
15447 #ifdef DEBUG
15448 size_t build_log_size = 0;
15449
15450 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15451
15452 if (build_log_size > 1)
15453 {
15454 char *build_log = (char *) malloc (build_log_size + 1);
15455
15456 memset (build_log, 0, build_log_size + 1);
15457
15458 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15459
15460 puts (build_log);
15461
15462 free (build_log);
15463 }
15464 #endif
15465
15466 if (rc != 0)
15467 {
15468 device_param->skipped = true;
15469
15470 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15471 }
15472 }
15473
15474 local_free (kernel_lengths);
15475 local_free (kernel_sources[0]);
15476 local_free (kernel_sources);
15477 }
15478
15479 /**
15480 * word generator kernel
15481 */
15482
15483 if (attack_mode != ATTACK_MODE_STRAIGHT)
15484 {
15485 /**
15486 * kernel mp source filename
15487 */
15488
15489 char source_file[256] = { 0 };
15490
15491 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15492
15493 struct stat sst;
15494
15495 if (stat (source_file, &sst) == -1)
15496 {
15497 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15498
15499 return -1;
15500 }
15501
15502 /**
15503 * kernel mp cached filename
15504 */
15505
15506 char cached_file[256] = { 0 };
15507
15508 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15509
15510 int cached = 1;
15511
15512 struct stat cst;
15513
15514 if (stat (cached_file, &cst) == -1)
15515 {
15516 cached = 0;
15517 }
15518
15519 /**
15520 * kernel compile or load
15521 */
15522
15523 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15524
15525 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15526
15527 if (cached == 0)
15528 {
15529 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15530 if (quiet == 0) log_info ("");
15531
15532 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15533
15534 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15535
15536 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15537
15538 if (rc != 0)
15539 {
15540 device_param->skipped = true;
15541
15542 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15543
15544 continue;
15545 }
15546
15547 size_t binary_size;
15548
15549 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15550
15551 u8 *binary = (u8 *) mymalloc (binary_size);
15552
15553 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15554
15555 writeProgramBin (cached_file, binary, binary_size);
15556
15557 local_free (binary);
15558 }
15559 else
15560 {
15561 #ifdef DEBUG
15562 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15563 #endif
15564
15565 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15566
15567 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15568
15569 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15570 }
15571
15572 local_free (kernel_lengths);
15573 local_free (kernel_sources[0]);
15574 local_free (kernel_sources);
15575 }
15576
15577 /**
15578 * amplifier kernel
15579 */
15580
15581 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15582 {
15583
15584 }
15585 else
15586 {
15587 /**
15588 * kernel amp source filename
15589 */
15590
15591 char source_file[256] = { 0 };
15592
15593 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15594
15595 struct stat sst;
15596
15597 if (stat (source_file, &sst) == -1)
15598 {
15599 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15600
15601 return -1;
15602 }
15603
15604 /**
15605 * kernel amp cached filename
15606 */
15607
15608 char cached_file[256] = { 0 };
15609
15610 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15611
15612 int cached = 1;
15613
15614 struct stat cst;
15615
15616 if (stat (cached_file, &cst) == -1)
15617 {
15618 cached = 0;
15619 }
15620
15621 /**
15622 * kernel compile or load
15623 */
15624
15625 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15626
15627 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15628
15629 if (cached == 0)
15630 {
15631 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15632 if (quiet == 0) log_info ("");
15633
15634 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15635
15636 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15637
15638 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15639
15640 if (rc != 0)
15641 {
15642 device_param->skipped = true;
15643
15644 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15645
15646 continue;
15647 }
15648
15649 size_t binary_size;
15650
15651 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15652
15653 u8 *binary = (u8 *) mymalloc (binary_size);
15654
15655 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15656
15657 writeProgramBin (cached_file, binary, binary_size);
15658
15659 local_free (binary);
15660 }
15661 else
15662 {
15663 #ifdef DEBUG
15664 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15665 #endif
15666
15667 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15668
15669 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15670
15671 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15672 }
15673
15674 local_free (kernel_lengths);
15675 local_free (kernel_sources[0]);
15676 local_free (kernel_sources);
15677 }
15678
15679 // some algorithm collide too fast, make that impossible
15680
15681 if (benchmark == 1)
15682 {
15683 ((uint *) digests_buf)[0] = -1;
15684 ((uint *) digests_buf)[1] = -1;
15685 ((uint *) digests_buf)[2] = -1;
15686 ((uint *) digests_buf)[3] = -1;
15687 }
15688
15689 /**
15690 * global buffers
15691 */
15692
15693 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15694 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15695 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15696 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15697 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15698 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15699 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15700 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15701 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15702 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15703 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15704 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15705 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15706 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15707 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15708 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15709 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15710 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15711
15712 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);
15713 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);
15714 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);
15715 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);
15716 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);
15717 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);
15718 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);
15719 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);
15720 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15721 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15722 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15723
15724 /**
15725 * special buffers
15726 */
15727
15728 if (attack_kern == ATTACK_KERN_STRAIGHT)
15729 {
15730 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15731 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15732
15733 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15734 }
15735 else if (attack_kern == ATTACK_KERN_COMBI)
15736 {
15737 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15738 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15739 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15740 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15741 }
15742 else if (attack_kern == ATTACK_KERN_BF)
15743 {
15744 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15745 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15746 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15747 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15748 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15749 }
15750
15751 if (size_esalts)
15752 {
15753 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15754
15755 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15756 }
15757
15758 /**
15759 * main host data
15760 */
15761
15762 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15763
15764 device_param->pws_buf = pws_buf;
15765
15766 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15767
15768 device_param->combs_buf = combs_buf;
15769
15770 void *hooks_buf = mymalloc (size_hooks);
15771
15772 device_param->hooks_buf = hooks_buf;
15773
15774 /**
15775 * kernel args
15776 */
15777
15778 device_param->kernel_params_buf32[21] = bitmap_mask;
15779 device_param->kernel_params_buf32[22] = bitmap_shift1;
15780 device_param->kernel_params_buf32[23] = bitmap_shift2;
15781 device_param->kernel_params_buf32[24] = 0; // salt_pos
15782 device_param->kernel_params_buf32[25] = 0; // loop_pos
15783 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15784 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15785 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15786 device_param->kernel_params_buf32[29] = 0; // digests_offset
15787 device_param->kernel_params_buf32[30] = 0; // combs_mode
15788 device_param->kernel_params_buf32[31] = 0; // gid_max
15789
15790 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15791 ? &device_param->d_pws_buf
15792 : &device_param->d_pws_amp_buf;
15793 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15794 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15795 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15796 device_param->kernel_params[ 4] = &device_param->d_tmps;
15797 device_param->kernel_params[ 5] = &device_param->d_hooks;
15798 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15799 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15800 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15801 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15802 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15803 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15804 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15805 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15806 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15807 device_param->kernel_params[15] = &device_param->d_digests_buf;
15808 device_param->kernel_params[16] = &device_param->d_digests_shown;
15809 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15810 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15811 device_param->kernel_params[19] = &device_param->d_result;
15812 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15813 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15814 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15815 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15816 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15817 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15818 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15819 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15820 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15821 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15822 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15823 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15824
15825 device_param->kernel_params_mp_buf64[3] = 0;
15826 device_param->kernel_params_mp_buf32[4] = 0;
15827 device_param->kernel_params_mp_buf32[5] = 0;
15828 device_param->kernel_params_mp_buf32[6] = 0;
15829 device_param->kernel_params_mp_buf32[7] = 0;
15830 device_param->kernel_params_mp_buf32[8] = 0;
15831
15832 device_param->kernel_params_mp[0] = NULL;
15833 device_param->kernel_params_mp[1] = NULL;
15834 device_param->kernel_params_mp[2] = NULL;
15835 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15836 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15837 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15838 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15839 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15840 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15841
15842 device_param->kernel_params_mp_l_buf64[3] = 0;
15843 device_param->kernel_params_mp_l_buf32[4] = 0;
15844 device_param->kernel_params_mp_l_buf32[5] = 0;
15845 device_param->kernel_params_mp_l_buf32[6] = 0;
15846 device_param->kernel_params_mp_l_buf32[7] = 0;
15847 device_param->kernel_params_mp_l_buf32[8] = 0;
15848 device_param->kernel_params_mp_l_buf32[9] = 0;
15849
15850 device_param->kernel_params_mp_l[0] = NULL;
15851 device_param->kernel_params_mp_l[1] = NULL;
15852 device_param->kernel_params_mp_l[2] = NULL;
15853 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15854 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15855 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15856 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15857 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15858 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15859 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15860
15861 device_param->kernel_params_mp_r_buf64[3] = 0;
15862 device_param->kernel_params_mp_r_buf32[4] = 0;
15863 device_param->kernel_params_mp_r_buf32[5] = 0;
15864 device_param->kernel_params_mp_r_buf32[6] = 0;
15865 device_param->kernel_params_mp_r_buf32[7] = 0;
15866 device_param->kernel_params_mp_r_buf32[8] = 0;
15867
15868 device_param->kernel_params_mp_r[0] = NULL;
15869 device_param->kernel_params_mp_r[1] = NULL;
15870 device_param->kernel_params_mp_r[2] = NULL;
15871 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15872 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15873 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15874 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15875 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15876 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15877
15878 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15879 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15880
15881 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15882 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15883 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15884 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15885 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15886 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15887 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15888
15889 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15890 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15891
15892 device_param->kernel_params_memset_buf32[1] = 0; // value
15893 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15894
15895 device_param->kernel_params_memset[0] = NULL;
15896 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15897 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15898
15899 /**
15900 * kernel name
15901 */
15902
15903 size_t kernel_wgs_tmp;
15904
15905 char kernel_name[64] = { 0 };
15906
15907 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15908 {
15909 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15910 {
15911 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15912
15913 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15914
15915 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15916
15917 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15918
15919 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15920
15921 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15922 }
15923 else
15924 {
15925 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15926
15927 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15928
15929 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15930
15931 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15932
15933 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15934
15935 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15936 }
15937
15938 if (data.attack_mode == ATTACK_MODE_BF)
15939 {
15940 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15941 {
15942 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15943
15944 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15945
15946 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);
15947 }
15948 }
15949 }
15950 else
15951 {
15952 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15953
15954 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15955
15956 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15957
15958 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15959
15960 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15961
15962 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15963
15964 if (opts_type & OPTS_TYPE_HOOK12)
15965 {
15966 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15967
15968 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15969
15970 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);
15971 }
15972
15973 if (opts_type & OPTS_TYPE_HOOK23)
15974 {
15975 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15976
15977 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15978
15979 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);
15980 }
15981 }
15982
15983 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);
15984 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);
15985 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);
15986
15987 for (uint i = 0; i <= 20; i++)
15988 {
15989 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15990 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15991 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15992
15993 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15994 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15995 }
15996
15997 for (uint i = 21; i <= 31; i++)
15998 {
15999 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16000 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16001 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16002
16003 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16004 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16005 }
16006
16007 // GPU memset
16008
16009 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16010
16011 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);
16012
16013 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
16014 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16015 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16016
16017 // MP start
16018
16019 if (attack_mode == ATTACK_MODE_BF)
16020 {
16021 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16022 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16023
16024 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);
16025 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);
16026
16027 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16028 {
16029 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16030 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16031 }
16032 }
16033 else if (attack_mode == ATTACK_MODE_HYBRID1)
16034 {
16035 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16036
16037 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);
16038 }
16039 else if (attack_mode == ATTACK_MODE_HYBRID2)
16040 {
16041 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16042
16043 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);
16044 }
16045
16046 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16047 {
16048 // nothing to do
16049 }
16050 else
16051 {
16052 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16053
16054 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);
16055 }
16056
16057 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16058 {
16059 // nothing to do
16060 }
16061 else
16062 {
16063 for (uint i = 0; i < 5; i++)
16064 {
16065 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16066 }
16067
16068 for (uint i = 5; i < 7; i++)
16069 {
16070 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16071 }
16072 }
16073
16074 // maybe this has been updated by clGetKernelWorkGroupInfo()
16075 // value can only be decreased, so we don't need to reallocate buffers
16076
16077 device_param->kernel_threads = kernel_threads;
16078
16079 // zero some data buffers
16080
16081 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16082 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16083 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16084 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16085 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16086 run_kernel_bzero (device_param, device_param->d_result, size_results);
16087
16088 /**
16089 * special buffers
16090 */
16091
16092 if (attack_kern == ATTACK_KERN_STRAIGHT)
16093 {
16094 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16095 }
16096 else if (attack_kern == ATTACK_KERN_COMBI)
16097 {
16098 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16099 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16100 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16101 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16102 }
16103 else if (attack_kern == ATTACK_KERN_BF)
16104 {
16105 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16106 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16107 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16108 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16109 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16110 }
16111
16112 #if defined(HAVE_HWMON)
16113
16114 /**
16115 * Store initial fanspeed if gpu_temp_retain is enabled
16116 */
16117
16118 if (gpu_temp_disable == 0)
16119 {
16120 if (gpu_temp_retain != 0)
16121 {
16122 hc_thread_mutex_lock (mux_adl);
16123
16124 if (data.hm_device[device_id].fan_get_supported == 1)
16125 {
16126 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16127 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16128
16129 temp_retain_fanspeed_value[device_id] = fanspeed;
16130 temp_retain_fanpolicy_value[device_id] = fanpolicy;
16131
16132 // we also set it to tell the OS we take control over the fan and it's automatic controller
16133 // if it was set to automatic. we do not control user-defined fanspeeds.
16134
16135 if (fanpolicy == 1)
16136 {
16137 data.hm_device[device_id].fan_set_supported = 1;
16138
16139 int rc = -1;
16140
16141 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16142 {
16143 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16144 }
16145 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16146 {
16147
16148 }
16149
16150 if (rc == 0)
16151 {
16152 data.hm_device[device_id].fan_set_supported = 1;
16153 }
16154 else
16155 {
16156 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16157
16158 data.hm_device[device_id].fan_set_supported = 0;
16159 }
16160 }
16161 else
16162 {
16163 data.hm_device[device_id].fan_set_supported = 0;
16164 }
16165 }
16166
16167 hc_thread_mutex_unlock (mux_adl);
16168 }
16169 }
16170
16171 #endif // HAVE_HWMON
16172 }
16173
16174 if (data.quiet == 0) log_info_nn ("");
16175
16176 /**
16177 * In benchmark-mode, inform user which algorithm is checked
16178 */
16179
16180 if (benchmark == 1)
16181 {
16182 if (machine_readable == 0)
16183 {
16184 quiet = 0;
16185
16186 data.quiet = quiet;
16187
16188 char *hash_type = strhashtype (data.hash_mode); // not a bug
16189
16190 log_info ("Hashtype: %s", hash_type);
16191 log_info ("");
16192 }
16193 }
16194
16195 /**
16196 * keep track of the progress
16197 */
16198
16199 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16200 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16201 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16202
16203 /**
16204 * open filehandles
16205 */
16206
16207 #if _WIN
16208 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16209 {
16210 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16211
16212 return (-1);
16213 }
16214
16215 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16216 {
16217 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16218
16219 return (-1);
16220 }
16221
16222 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16223 {
16224 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16225
16226 return (-1);
16227 }
16228 #endif
16229
16230 /**
16231 * dictionary pad
16232 */
16233
16234 segment_size *= (1024 * 1024);
16235
16236 data.segment_size = segment_size;
16237
16238 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16239
16240 wl_data->buf = (char *) mymalloc (segment_size);
16241 wl_data->avail = segment_size;
16242 wl_data->incr = segment_size;
16243 wl_data->cnt = 0;
16244 wl_data->pos = 0;
16245
16246 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
16247
16248 data.wordlist_mode = wordlist_mode;
16249
16250 cs_t *css_buf = NULL;
16251 uint css_cnt = 0;
16252 uint dictcnt = 0;
16253 uint maskcnt = 1;
16254 char **masks = NULL;
16255 char **dictfiles = NULL;
16256
16257 uint mask_from_file = 0;
16258
16259 if (attack_mode == ATTACK_MODE_STRAIGHT)
16260 {
16261 if (wordlist_mode == WL_MODE_FILE)
16262 {
16263 int wls_left = myargc - (optind + 1);
16264
16265 for (int i = 0; i < wls_left; i++)
16266 {
16267 char *l0_filename = myargv[optind + 1 + i];
16268
16269 struct stat l0_stat;
16270
16271 if (stat (l0_filename, &l0_stat) == -1)
16272 {
16273 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16274
16275 return (-1);
16276 }
16277
16278 uint is_dir = S_ISDIR (l0_stat.st_mode);
16279
16280 if (is_dir == 0)
16281 {
16282 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16283
16284 dictcnt++;
16285
16286 dictfiles[dictcnt - 1] = l0_filename;
16287 }
16288 else
16289 {
16290 // do not allow --keyspace w/ a directory
16291
16292 if (keyspace == 1)
16293 {
16294 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16295
16296 return (-1);
16297 }
16298
16299 char **dictionary_files = NULL;
16300
16301 dictionary_files = scan_directory (l0_filename);
16302
16303 if (dictionary_files != NULL)
16304 {
16305 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16306
16307 for (int d = 0; dictionary_files[d] != NULL; d++)
16308 {
16309 char *l1_filename = dictionary_files[d];
16310
16311 struct stat l1_stat;
16312
16313 if (stat (l1_filename, &l1_stat) == -1)
16314 {
16315 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16316
16317 return (-1);
16318 }
16319
16320 if (S_ISREG (l1_stat.st_mode))
16321 {
16322 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16323
16324 dictcnt++;
16325
16326 dictfiles[dictcnt - 1] = strdup (l1_filename);
16327 }
16328 }
16329 }
16330
16331 local_free (dictionary_files);
16332 }
16333 }
16334
16335 if (dictcnt < 1)
16336 {
16337 log_error ("ERROR: No usable dictionary file found.");
16338
16339 return (-1);
16340 }
16341 }
16342 else if (wordlist_mode == WL_MODE_STDIN)
16343 {
16344 dictcnt = 1;
16345 }
16346 }
16347 else if (attack_mode == ATTACK_MODE_COMBI)
16348 {
16349 // display
16350
16351 char *dictfile1 = myargv[optind + 1 + 0];
16352 char *dictfile2 = myargv[optind + 1 + 1];
16353
16354 // find the bigger dictionary and use as base
16355
16356 FILE *fp1 = NULL;
16357 FILE *fp2 = NULL;
16358
16359 struct stat tmp_stat;
16360
16361 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16362 {
16363 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16364
16365 return (-1);
16366 }
16367
16368 if (stat (dictfile1, &tmp_stat) == -1)
16369 {
16370 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16371
16372 fclose (fp1);
16373
16374 return (-1);
16375 }
16376
16377 if (S_ISDIR (tmp_stat.st_mode))
16378 {
16379 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16380
16381 fclose (fp1);
16382
16383 return (-1);
16384 }
16385
16386 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16387 {
16388 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16389
16390 fclose (fp1);
16391
16392 return (-1);
16393 }
16394
16395 if (stat (dictfile2, &tmp_stat) == -1)
16396 {
16397 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16398
16399 fclose (fp1);
16400 fclose (fp2);
16401
16402 return (-1);
16403 }
16404
16405 if (S_ISDIR (tmp_stat.st_mode))
16406 {
16407 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16408
16409 fclose (fp1);
16410 fclose (fp2);
16411
16412 return (-1);
16413 }
16414
16415 data.combs_cnt = 1;
16416
16417 data.quiet = 1;
16418
16419 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16420
16421 data.quiet = quiet;
16422
16423 if (words1_cnt == 0)
16424 {
16425 log_error ("ERROR: %s: empty file", dictfile1);
16426
16427 fclose (fp1);
16428 fclose (fp2);
16429
16430 return (-1);
16431 }
16432
16433 data.combs_cnt = 1;
16434
16435 data.quiet = 1;
16436
16437 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16438
16439 data.quiet = quiet;
16440
16441 if (words2_cnt == 0)
16442 {
16443 log_error ("ERROR: %s: empty file", dictfile2);
16444
16445 fclose (fp1);
16446 fclose (fp2);
16447
16448 return (-1);
16449 }
16450
16451 fclose (fp1);
16452 fclose (fp2);
16453
16454 data.dictfile = dictfile1;
16455 data.dictfile2 = dictfile2;
16456
16457 if (words1_cnt >= words2_cnt)
16458 {
16459 data.combs_cnt = words2_cnt;
16460 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16461
16462 dictfiles = &data.dictfile;
16463
16464 dictcnt = 1;
16465 }
16466 else
16467 {
16468 data.combs_cnt = words1_cnt;
16469 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16470
16471 dictfiles = &data.dictfile2;
16472
16473 dictcnt = 1;
16474
16475 // we also have to switch wordlist related rules!
16476
16477 char *tmpc = data.rule_buf_l;
16478
16479 data.rule_buf_l = data.rule_buf_r;
16480 data.rule_buf_r = tmpc;
16481
16482 int tmpi = data.rule_len_l;
16483
16484 data.rule_len_l = data.rule_len_r;
16485 data.rule_len_r = tmpi;
16486 }
16487 }
16488 else if (attack_mode == ATTACK_MODE_BF)
16489 {
16490 char *mask = NULL;
16491
16492 maskcnt = 0;
16493
16494 if (benchmark == 0)
16495 {
16496 mask = myargv[optind + 1];
16497
16498 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16499
16500 if ((optind + 2) <= myargc)
16501 {
16502 struct stat file_stat;
16503
16504 if (stat (mask, &file_stat) == -1)
16505 {
16506 maskcnt = 1;
16507
16508 masks[maskcnt - 1] = mystrdup (mask);
16509 }
16510 else
16511 {
16512 int wls_left = myargc - (optind + 1);
16513
16514 uint masks_avail = INCR_MASKS;
16515
16516 for (int i = 0; i < wls_left; i++)
16517 {
16518 if (i != 0)
16519 {
16520 mask = myargv[optind + 1 + i];
16521
16522 if (stat (mask, &file_stat) == -1)
16523 {
16524 log_error ("ERROR: %s: %s", mask, strerror (errno));
16525
16526 return (-1);
16527 }
16528 }
16529
16530 uint is_file = S_ISREG (file_stat.st_mode);
16531
16532 if (is_file == 1)
16533 {
16534 FILE *mask_fp;
16535
16536 if ((mask_fp = fopen (mask, "r")) == NULL)
16537 {
16538 log_error ("ERROR: %s: %s", mask, strerror (errno));
16539
16540 return (-1);
16541 }
16542
16543 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16544
16545 while (!feof (mask_fp))
16546 {
16547 memset (line_buf, 0, HCBUFSIZ);
16548
16549 int line_len = fgetl (mask_fp, line_buf);
16550
16551 if (line_len == 0) continue;
16552
16553 if (line_buf[0] == '#') continue;
16554
16555 if (masks_avail == maskcnt)
16556 {
16557 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16558
16559 masks_avail += INCR_MASKS;
16560 }
16561
16562 masks[maskcnt] = mystrdup (line_buf);
16563
16564 maskcnt++;
16565 }
16566
16567 myfree (line_buf);
16568
16569 fclose (mask_fp);
16570 }
16571 else
16572 {
16573 log_error ("ERROR: %s: unsupported file-type", mask);
16574
16575 return (-1);
16576 }
16577 }
16578
16579 mask_from_file = 1;
16580 }
16581 }
16582 else
16583 {
16584 custom_charset_1 = (char *) "?l?d?u";
16585 custom_charset_2 = (char *) "?l?d";
16586 custom_charset_3 = (char *) "?l?d*!$@_";
16587
16588 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16589 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16590 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16591
16592 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16593
16594 wordlist_mode = WL_MODE_MASK;
16595
16596 data.wordlist_mode = wordlist_mode;
16597
16598 increment = 1;
16599
16600 maskcnt = 1;
16601 }
16602 }
16603 else
16604 {
16605 /**
16606 * generate full masks and charsets
16607 */
16608
16609 masks = (char **) mymalloc (sizeof (char *));
16610
16611 switch (hash_mode)
16612 {
16613 case 1731: pw_min = 5;
16614 pw_max = 5;
16615 mask = mystrdup ("?b?b?b?b?b");
16616 break;
16617 case 12500: pw_min = 5;
16618 pw_max = 5;
16619 mask = mystrdup ("?b?b?b?b?b");
16620 break;
16621 default: pw_min = 7;
16622 pw_max = 7;
16623 mask = mystrdup ("?b?b?b?b?b?b?b");
16624 break;
16625 }
16626
16627 maskcnt = 1;
16628
16629 masks[maskcnt - 1] = mystrdup (mask);
16630
16631 wordlist_mode = WL_MODE_MASK;
16632
16633 data.wordlist_mode = wordlist_mode;
16634
16635 increment = 1;
16636 }
16637
16638 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16639
16640 if (increment)
16641 {
16642 if (increment_min > pw_min) pw_min = increment_min;
16643
16644 if (increment_max < pw_max) pw_max = increment_max;
16645 }
16646 }
16647 else if (attack_mode == ATTACK_MODE_HYBRID1)
16648 {
16649 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16650
16651 // display
16652
16653 char *mask = myargv[myargc - 1];
16654
16655 maskcnt = 0;
16656
16657 masks = (char **) mymalloc (1 * sizeof (char *));
16658
16659 // mod
16660
16661 struct stat file_stat;
16662
16663 if (stat (mask, &file_stat) == -1)
16664 {
16665 maskcnt = 1;
16666
16667 masks[maskcnt - 1] = mystrdup (mask);
16668 }
16669 else
16670 {
16671 uint is_file = S_ISREG (file_stat.st_mode);
16672
16673 if (is_file == 1)
16674 {
16675 FILE *mask_fp;
16676
16677 if ((mask_fp = fopen (mask, "r")) == NULL)
16678 {
16679 log_error ("ERROR: %s: %s", mask, strerror (errno));
16680
16681 return (-1);
16682 }
16683
16684 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16685
16686 uint masks_avail = 1;
16687
16688 while (!feof (mask_fp))
16689 {
16690 memset (line_buf, 0, HCBUFSIZ);
16691
16692 int line_len = fgetl (mask_fp, line_buf);
16693
16694 if (line_len == 0) continue;
16695
16696 if (line_buf[0] == '#') continue;
16697
16698 if (masks_avail == maskcnt)
16699 {
16700 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16701
16702 masks_avail += INCR_MASKS;
16703 }
16704
16705 masks[maskcnt] = mystrdup (line_buf);
16706
16707 maskcnt++;
16708 }
16709
16710 myfree (line_buf);
16711
16712 fclose (mask_fp);
16713
16714 mask_from_file = 1;
16715 }
16716 else
16717 {
16718 maskcnt = 1;
16719
16720 masks[maskcnt - 1] = mystrdup (mask);
16721 }
16722 }
16723
16724 // base
16725
16726 int wls_left = myargc - (optind + 2);
16727
16728 for (int i = 0; i < wls_left; i++)
16729 {
16730 char *filename = myargv[optind + 1 + i];
16731
16732 struct stat file_stat;
16733
16734 if (stat (filename, &file_stat) == -1)
16735 {
16736 log_error ("ERROR: %s: %s", filename, strerror (errno));
16737
16738 return (-1);
16739 }
16740
16741 uint is_dir = S_ISDIR (file_stat.st_mode);
16742
16743 if (is_dir == 0)
16744 {
16745 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16746
16747 dictcnt++;
16748
16749 dictfiles[dictcnt - 1] = filename;
16750 }
16751 else
16752 {
16753 // do not allow --keyspace w/ a directory
16754
16755 if (keyspace == 1)
16756 {
16757 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16758
16759 return (-1);
16760 }
16761
16762 char **dictionary_files = NULL;
16763
16764 dictionary_files = scan_directory (filename);
16765
16766 if (dictionary_files != NULL)
16767 {
16768 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16769
16770 for (int d = 0; dictionary_files[d] != NULL; d++)
16771 {
16772 char *l1_filename = dictionary_files[d];
16773
16774 struct stat l1_stat;
16775
16776 if (stat (l1_filename, &l1_stat) == -1)
16777 {
16778 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16779
16780 return (-1);
16781 }
16782
16783 if (S_ISREG (l1_stat.st_mode))
16784 {
16785 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16786
16787 dictcnt++;
16788
16789 dictfiles[dictcnt - 1] = strdup (l1_filename);
16790 }
16791 }
16792 }
16793
16794 local_free (dictionary_files);
16795 }
16796 }
16797
16798 if (dictcnt < 1)
16799 {
16800 log_error ("ERROR: No usable dictionary file found.");
16801
16802 return (-1);
16803 }
16804
16805 if (increment)
16806 {
16807 maskcnt = 0;
16808
16809 uint mask_min = increment_min; // we can't reject smaller masks here
16810 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16811
16812 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16813 {
16814 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16815
16816 if (cur_mask == NULL) break;
16817
16818 masks[maskcnt] = cur_mask;
16819
16820 maskcnt++;
16821
16822 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16823 }
16824 }
16825 }
16826 else if (attack_mode == ATTACK_MODE_HYBRID2)
16827 {
16828 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16829
16830 // display
16831
16832 char *mask = myargv[optind + 1 + 0];
16833
16834 maskcnt = 0;
16835
16836 masks = (char **) mymalloc (1 * sizeof (char *));
16837
16838 // mod
16839
16840 struct stat file_stat;
16841
16842 if (stat (mask, &file_stat) == -1)
16843 {
16844 maskcnt = 1;
16845
16846 masks[maskcnt - 1] = mystrdup (mask);
16847 }
16848 else
16849 {
16850 uint is_file = S_ISREG (file_stat.st_mode);
16851
16852 if (is_file == 1)
16853 {
16854 FILE *mask_fp;
16855
16856 if ((mask_fp = fopen (mask, "r")) == NULL)
16857 {
16858 log_error ("ERROR: %s: %s", mask, strerror (errno));
16859
16860 return (-1);
16861 }
16862
16863 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16864
16865 uint masks_avail = 1;
16866
16867 while (!feof (mask_fp))
16868 {
16869 memset (line_buf, 0, HCBUFSIZ);
16870
16871 int line_len = fgetl (mask_fp, line_buf);
16872
16873 if (line_len == 0) continue;
16874
16875 if (line_buf[0] == '#') continue;
16876
16877 if (masks_avail == maskcnt)
16878 {
16879 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16880
16881 masks_avail += INCR_MASKS;
16882 }
16883
16884 masks[maskcnt] = mystrdup (line_buf);
16885
16886 maskcnt++;
16887 }
16888
16889 myfree (line_buf);
16890
16891 fclose (mask_fp);
16892
16893 mask_from_file = 1;
16894 }
16895 else
16896 {
16897 maskcnt = 1;
16898
16899 masks[maskcnt - 1] = mystrdup (mask);
16900 }
16901 }
16902
16903 // base
16904
16905 int wls_left = myargc - (optind + 2);
16906
16907 for (int i = 0; i < wls_left; i++)
16908 {
16909 char *filename = myargv[optind + 2 + i];
16910
16911 struct stat file_stat;
16912
16913 if (stat (filename, &file_stat) == -1)
16914 {
16915 log_error ("ERROR: %s: %s", filename, strerror (errno));
16916
16917 return (-1);
16918 }
16919
16920 uint is_dir = S_ISDIR (file_stat.st_mode);
16921
16922 if (is_dir == 0)
16923 {
16924 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16925
16926 dictcnt++;
16927
16928 dictfiles[dictcnt - 1] = filename;
16929 }
16930 else
16931 {
16932 // do not allow --keyspace w/ a directory
16933
16934 if (keyspace == 1)
16935 {
16936 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16937
16938 return (-1);
16939 }
16940
16941 char **dictionary_files = NULL;
16942
16943 dictionary_files = scan_directory (filename);
16944
16945 if (dictionary_files != NULL)
16946 {
16947 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16948
16949 for (int d = 0; dictionary_files[d] != NULL; d++)
16950 {
16951 char *l1_filename = dictionary_files[d];
16952
16953 struct stat l1_stat;
16954
16955 if (stat (l1_filename, &l1_stat) == -1)
16956 {
16957 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16958
16959 return (-1);
16960 }
16961
16962 if (S_ISREG (l1_stat.st_mode))
16963 {
16964 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16965
16966 dictcnt++;
16967
16968 dictfiles[dictcnt - 1] = strdup (l1_filename);
16969 }
16970 }
16971 }
16972
16973 local_free (dictionary_files);
16974 }
16975 }
16976
16977 if (dictcnt < 1)
16978 {
16979 log_error ("ERROR: No usable dictionary file found.");
16980
16981 return (-1);
16982 }
16983
16984 if (increment)
16985 {
16986 maskcnt = 0;
16987
16988 uint mask_min = increment_min; // we can't reject smaller masks here
16989 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16990
16991 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16992 {
16993 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16994
16995 if (cur_mask == NULL) break;
16996
16997 masks[maskcnt] = cur_mask;
16998
16999 maskcnt++;
17000
17001 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17002 }
17003 }
17004 }
17005
17006 data.pw_min = pw_min;
17007 data.pw_max = pw_max;
17008
17009 /**
17010 * weak hash check
17011 */
17012
17013 if (weak_hash_threshold >= salts_cnt)
17014 {
17015 hc_device_param_t *device_param = NULL;
17016
17017 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17018 {
17019 device_param = &data.devices_param[device_id];
17020
17021 if (device_param->skipped) continue;
17022
17023 break;
17024 }
17025
17026 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17027
17028 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17029 {
17030 weak_hash_check (device_param, salt_pos);
17031 }
17032
17033 // Display hack, guarantee that there is at least one \r before real start
17034
17035 //if (data.quiet == 0) log_info ("");
17036 }
17037
17038 /**
17039 * status and monitor threads
17040 */
17041
17042 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
17043
17044 uint i_threads_cnt = 0;
17045
17046 hc_thread_t *i_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17047
17048 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17049 {
17050 if (stdout_flag == 0)
17051 {
17052 hc_thread_create (i_threads[i_threads_cnt], thread_keypress, &benchmark);
17053
17054 i_threads_cnt++;
17055 }
17056 }
17057
17058 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
17059
17060 uint ni_threads_cnt = 0;
17061
17062 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17063
17064 if (stdout_flag == 0)
17065 {
17066 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
17067
17068 ni_threads_cnt++;
17069 }
17070
17071 /**
17072 * Outfile remove
17073 */
17074
17075 if (keyspace == 0)
17076 {
17077 if (outfile_check_timer != 0)
17078 {
17079 if (data.outfile_check_directory != NULL)
17080 {
17081 if ((hash_mode != 5200) &&
17082 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17083 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17084 (hash_mode != 9000))
17085 {
17086 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
17087
17088 ni_threads_cnt++;
17089 }
17090 else
17091 {
17092 outfile_check_timer = 0;
17093 }
17094 }
17095 else
17096 {
17097 outfile_check_timer = 0;
17098 }
17099 }
17100 }
17101
17102 /**
17103 * Inform the user if we got some hashes remove because of the pot file remove feature
17104 */
17105
17106 if (data.quiet == 0)
17107 {
17108 if (potfile_remove_cracks > 0)
17109 {
17110 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
17111 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
17112 }
17113 }
17114
17115 data.outfile_check_timer = outfile_check_timer;
17116
17117 /**
17118 * main loop
17119 */
17120
17121 char **induction_dictionaries = NULL;
17122
17123 int induction_dictionaries_cnt = 0;
17124
17125 hcstat_table_t *root_table_buf = NULL;
17126 hcstat_table_t *markov_table_buf = NULL;
17127
17128 uint initial_restore_done = 0;
17129
17130 data.maskcnt = maskcnt;
17131
17132 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17133 {
17134 if (data.devices_status == STATUS_CRACKED) break;
17135
17136 data.devices_status = STATUS_INIT;
17137
17138 if (maskpos > rd->maskpos)
17139 {
17140 rd->dictpos = 0;
17141 }
17142
17143 rd->maskpos = maskpos;
17144 data.maskpos = maskpos;
17145
17146 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17147 {
17148 char *mask = masks[maskpos];
17149
17150 if (mask_from_file == 1)
17151 {
17152 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17153
17154 char *str_ptr;
17155 uint str_pos;
17156
17157 uint mask_offset = 0;
17158
17159 uint separator_cnt;
17160
17161 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17162 {
17163 str_ptr = strstr (mask + mask_offset, ",");
17164
17165 if (str_ptr == NULL) break;
17166
17167 str_pos = str_ptr - mask;
17168
17169 // escaped separator, i.e. "\,"
17170
17171 if (str_pos > 0)
17172 {
17173 if (mask[str_pos - 1] == '\\')
17174 {
17175 separator_cnt --;
17176
17177 mask_offset = str_pos + 1;
17178
17179 continue;
17180 }
17181 }
17182
17183 // reset the offset
17184
17185 mask_offset = 0;
17186
17187 mask[str_pos] = '\0';
17188
17189 switch (separator_cnt)
17190 {
17191 case 0:
17192 mp_reset_usr (mp_usr, 0);
17193
17194 custom_charset_1 = mask;
17195 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17196 break;
17197
17198 case 1:
17199 mp_reset_usr (mp_usr, 1);
17200
17201 custom_charset_2 = mask;
17202 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17203 break;
17204
17205 case 2:
17206 mp_reset_usr (mp_usr, 2);
17207
17208 custom_charset_3 = mask;
17209 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17210 break;
17211
17212 case 3:
17213 mp_reset_usr (mp_usr, 3);
17214
17215 custom_charset_4 = mask;
17216 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17217 break;
17218 }
17219
17220 mask = mask + str_pos + 1;
17221 }
17222 }
17223
17224 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17225 {
17226 if (maskpos > 0)
17227 {
17228 local_free (css_buf);
17229 local_free (data.root_css_buf);
17230 local_free (data.markov_css_buf);
17231
17232 local_free (masks[maskpos - 1]);
17233 }
17234
17235 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17236
17237 data.mask = mask;
17238 data.css_cnt = css_cnt;
17239 data.css_buf = css_buf;
17240
17241 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17242
17243 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17244
17245 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17246 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17247
17248 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17249
17250 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17251
17252 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17253 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17254
17255 data.root_css_buf = root_css_buf;
17256 data.markov_css_buf = markov_css_buf;
17257
17258 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17259
17260 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17261
17262 local_free (root_table_buf);
17263 local_free (markov_table_buf);
17264
17265 // args
17266
17267 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17268 {
17269 hc_device_param_t *device_param = &data.devices_param[device_id];
17270
17271 if (device_param->skipped) continue;
17272
17273 device_param->kernel_params_mp[0] = &device_param->d_combs;
17274 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17275 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17276
17277 device_param->kernel_params_mp_buf64[3] = 0;
17278 device_param->kernel_params_mp_buf32[4] = css_cnt;
17279 device_param->kernel_params_mp_buf32[5] = 0;
17280 device_param->kernel_params_mp_buf32[6] = 0;
17281 device_param->kernel_params_mp_buf32[7] = 0;
17282
17283 if (attack_mode == ATTACK_MODE_HYBRID1)
17284 {
17285 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17286 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17287 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17288 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17289 }
17290 else if (attack_mode == ATTACK_MODE_HYBRID2)
17291 {
17292 device_param->kernel_params_mp_buf32[5] = 0;
17293 device_param->kernel_params_mp_buf32[6] = 0;
17294 device_param->kernel_params_mp_buf32[7] = 0;
17295 }
17296
17297 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]);
17298 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]);
17299 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]);
17300
17301 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);
17302 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);
17303 }
17304 }
17305 else if (attack_mode == ATTACK_MODE_BF)
17306 {
17307 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17308
17309 if (increment)
17310 {
17311 for (uint i = 0; i < dictcnt; i++)
17312 {
17313 local_free (dictfiles[i]);
17314 }
17315
17316 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17317 {
17318 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17319
17320 if (l1_filename == NULL) break;
17321
17322 dictcnt++;
17323
17324 dictfiles[dictcnt - 1] = l1_filename;
17325 }
17326 }
17327 else
17328 {
17329 dictcnt++;
17330
17331 dictfiles[dictcnt - 1] = mask;
17332 }
17333
17334 if (dictcnt == 0)
17335 {
17336 log_error ("ERROR: Mask is too small");
17337
17338 return (-1);
17339 }
17340 }
17341 }
17342
17343 free (induction_dictionaries);
17344
17345 // induction_dictionaries_cnt = 0; // implied
17346
17347 if (attack_mode != ATTACK_MODE_BF)
17348 {
17349 if (keyspace == 0)
17350 {
17351 induction_dictionaries = scan_directory (induction_directory);
17352
17353 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17354 }
17355 }
17356
17357 if (induction_dictionaries_cnt)
17358 {
17359 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17360 }
17361
17362 /**
17363 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17364 */
17365 if (keyspace == 1)
17366 {
17367 if ((maskcnt > 1) || (dictcnt > 1))
17368 {
17369 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17370
17371 return (-1);
17372 }
17373 }
17374
17375 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17376 {
17377 char *subid = logfile_generate_subid ();
17378
17379 data.subid = subid;
17380
17381 logfile_sub_msg ("START");
17382
17383 data.devices_status = STATUS_INIT;
17384
17385 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17386 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17387 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17388
17389 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17390
17391 data.cpt_pos = 0;
17392
17393 data.cpt_start = time (NULL);
17394
17395 data.cpt_total = 0;
17396
17397 if (data.restore == 0)
17398 {
17399 rd->words_cur = skip;
17400
17401 skip = 0;
17402
17403 data.skip = 0;
17404 }
17405
17406 data.ms_paused = 0;
17407
17408 data.kernel_power_final = 0;
17409
17410 data.words_cur = rd->words_cur;
17411
17412 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17413 {
17414 hc_device_param_t *device_param = &data.devices_param[device_id];
17415
17416 if (device_param->skipped) continue;
17417
17418 device_param->speed_pos = 0;
17419
17420 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17421 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17422
17423 device_param->exec_pos = 0;
17424
17425 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17426
17427 device_param->outerloop_pos = 0;
17428 device_param->outerloop_left = 0;
17429 device_param->innerloop_pos = 0;
17430 device_param->innerloop_left = 0;
17431
17432 // some more resets:
17433
17434 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17435
17436 device_param->pws_cnt = 0;
17437
17438 device_param->words_off = 0;
17439 device_param->words_done = 0;
17440 }
17441
17442 // figure out some workload
17443
17444 if (attack_mode == ATTACK_MODE_STRAIGHT)
17445 {
17446 if (data.wordlist_mode == WL_MODE_FILE)
17447 {
17448 char *dictfile = NULL;
17449
17450 if (induction_dictionaries_cnt)
17451 {
17452 dictfile = induction_dictionaries[0];
17453 }
17454 else
17455 {
17456 dictfile = dictfiles[dictpos];
17457 }
17458
17459 data.dictfile = dictfile;
17460
17461 logfile_sub_string (dictfile);
17462
17463 for (uint i = 0; i < rp_files_cnt; i++)
17464 {
17465 logfile_sub_var_string ("rulefile", rp_files[i]);
17466 }
17467
17468 FILE *fd2 = fopen (dictfile, "rb");
17469
17470 if (fd2 == NULL)
17471 {
17472 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17473
17474 return (-1);
17475 }
17476
17477 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17478
17479 fclose (fd2);
17480
17481 if (data.words_cnt == 0)
17482 {
17483 if (data.devices_status == STATUS_CRACKED) break;
17484 if (data.devices_status == STATUS_ABORTED) break;
17485
17486 dictpos++;
17487
17488 continue;
17489 }
17490 }
17491 }
17492 else if (attack_mode == ATTACK_MODE_COMBI)
17493 {
17494 char *dictfile = data.dictfile;
17495 char *dictfile2 = data.dictfile2;
17496
17497 logfile_sub_string (dictfile);
17498 logfile_sub_string (dictfile2);
17499
17500 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17501 {
17502 FILE *fd2 = fopen (dictfile, "rb");
17503
17504 if (fd2 == NULL)
17505 {
17506 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17507
17508 return (-1);
17509 }
17510
17511 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17512
17513 fclose (fd2);
17514 }
17515 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17516 {
17517 FILE *fd2 = fopen (dictfile2, "rb");
17518
17519 if (fd2 == NULL)
17520 {
17521 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17522
17523 return (-1);
17524 }
17525
17526 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17527
17528 fclose (fd2);
17529 }
17530
17531 if (data.words_cnt == 0)
17532 {
17533 if (data.devices_status == STATUS_CRACKED) break;
17534 if (data.devices_status == STATUS_ABORTED) break;
17535
17536 dictpos++;
17537
17538 continue;
17539 }
17540 }
17541 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17542 {
17543 char *dictfile = NULL;
17544
17545 if (induction_dictionaries_cnt)
17546 {
17547 dictfile = induction_dictionaries[0];
17548 }
17549 else
17550 {
17551 dictfile = dictfiles[dictpos];
17552 }
17553
17554 data.dictfile = dictfile;
17555
17556 char *mask = data.mask;
17557
17558 logfile_sub_string (dictfile);
17559 logfile_sub_string (mask);
17560
17561 FILE *fd2 = fopen (dictfile, "rb");
17562
17563 if (fd2 == NULL)
17564 {
17565 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17566
17567 return (-1);
17568 }
17569
17570 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17571
17572 fclose (fd2);
17573
17574 if (data.words_cnt == 0)
17575 {
17576 if (data.devices_status == STATUS_CRACKED) break;
17577 if (data.devices_status == STATUS_ABORTED) break;
17578
17579 dictpos++;
17580
17581 continue;
17582 }
17583 }
17584 else if (attack_mode == ATTACK_MODE_BF)
17585 {
17586 local_free (css_buf);
17587 local_free (data.root_css_buf);
17588 local_free (data.markov_css_buf);
17589
17590 char *mask = dictfiles[dictpos];
17591
17592 logfile_sub_string (mask);
17593
17594 // base
17595
17596 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17597
17598 if (opts_type & OPTS_TYPE_PT_UNICODE)
17599 {
17600 uint css_cnt_unicode = css_cnt * 2;
17601
17602 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17603
17604 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17605 {
17606 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17607
17608 css_buf_unicode[j + 1].cs_buf[0] = 0;
17609 css_buf_unicode[j + 1].cs_len = 1;
17610 }
17611
17612 free (css_buf);
17613
17614 css_buf = css_buf_unicode;
17615 css_cnt = css_cnt_unicode;
17616 }
17617
17618 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17619
17620 uint mask_min = pw_min;
17621 uint mask_max = pw_max;
17622
17623 if (opts_type & OPTS_TYPE_PT_UNICODE)
17624 {
17625 mask_min *= 2;
17626 mask_max *= 2;
17627 }
17628
17629 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17630 {
17631 if (css_cnt < mask_min)
17632 {
17633 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17634 }
17635
17636 if (css_cnt > mask_max)
17637 {
17638 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17639 }
17640
17641 // skip to next mask
17642
17643 dictpos++;
17644
17645 rd->dictpos = dictpos;
17646
17647 logfile_sub_msg ("STOP");
17648
17649 continue;
17650 }
17651
17652 uint save_css_cnt = css_cnt;
17653
17654 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17655 {
17656 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17657 {
17658 uint salt_len = (uint) data.salts_buf[0].salt_len;
17659 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17660
17661 uint css_cnt_salt = css_cnt + salt_len;
17662
17663 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17664
17665 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17666
17667 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17668 {
17669 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17670 css_buf_salt[j].cs_len = 1;
17671 }
17672
17673 free (css_buf);
17674
17675 css_buf = css_buf_salt;
17676 css_cnt = css_cnt_salt;
17677 }
17678 }
17679
17680 data.mask = mask;
17681 data.css_cnt = css_cnt;
17682 data.css_buf = css_buf;
17683
17684 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17685
17686 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17687
17688 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17689
17690 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17691 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17692
17693 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17694
17695 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17696
17697 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17698 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17699
17700 data.root_css_buf = root_css_buf;
17701 data.markov_css_buf = markov_css_buf;
17702
17703 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17704
17705 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17706
17707 local_free (root_table_buf);
17708 local_free (markov_table_buf);
17709
17710 // copy + args
17711
17712 uint css_cnt_l = css_cnt;
17713 uint css_cnt_r;
17714
17715 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17716 {
17717 if (save_css_cnt < 6)
17718 {
17719 css_cnt_r = 1;
17720 }
17721 else if (save_css_cnt == 6)
17722 {
17723 css_cnt_r = 2;
17724 }
17725 else
17726 {
17727 if (opts_type & OPTS_TYPE_PT_UNICODE)
17728 {
17729 if (save_css_cnt == 8 || save_css_cnt == 10)
17730 {
17731 css_cnt_r = 2;
17732 }
17733 else
17734 {
17735 css_cnt_r = 4;
17736 }
17737 }
17738 else
17739 {
17740 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17741 {
17742 css_cnt_r = 3;
17743 }
17744 else
17745 {
17746 css_cnt_r = 4;
17747 }
17748 }
17749 }
17750 }
17751 else
17752 {
17753 css_cnt_r = 1;
17754
17755 /* unfinished code?
17756 int sum = css_buf[css_cnt_r - 1].cs_len;
17757
17758 for (uint i = 1; i < 4 && i < css_cnt; i++)
17759 {
17760 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17761
17762 css_cnt_r++;
17763
17764 sum *= css_buf[css_cnt_r - 1].cs_len;
17765 }
17766 */
17767 }
17768
17769 css_cnt_l -= css_cnt_r;
17770
17771 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17772
17773 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17774 {
17775 hc_device_param_t *device_param = &data.devices_param[device_id];
17776
17777 if (device_param->skipped) continue;
17778
17779 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17780 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17781 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17782
17783 device_param->kernel_params_mp_l_buf64[3] = 0;
17784 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17785 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17786 device_param->kernel_params_mp_l_buf32[6] = 0;
17787 device_param->kernel_params_mp_l_buf32[7] = 0;
17788 device_param->kernel_params_mp_l_buf32[8] = 0;
17789
17790 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17791 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17792 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17793 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17794
17795 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17796 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17797 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17798
17799 device_param->kernel_params_mp_r_buf64[3] = 0;
17800 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17801 device_param->kernel_params_mp_r_buf32[5] = 0;
17802 device_param->kernel_params_mp_r_buf32[6] = 0;
17803 device_param->kernel_params_mp_r_buf32[7] = 0;
17804
17805 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]);
17806 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]);
17807 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]);
17808
17809 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]);
17810 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]);
17811 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]);
17812
17813 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);
17814 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);
17815 }
17816 }
17817
17818 u64 words_base = data.words_cnt;
17819
17820 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17821 {
17822 if (data.kernel_rules_cnt)
17823 {
17824 words_base /= data.kernel_rules_cnt;
17825 }
17826 }
17827 else if (data.attack_kern == ATTACK_KERN_COMBI)
17828 {
17829 if (data.combs_cnt)
17830 {
17831 words_base /= data.combs_cnt;
17832 }
17833 }
17834 else if (data.attack_kern == ATTACK_KERN_BF)
17835 {
17836 if (data.bfs_cnt)
17837 {
17838 words_base /= data.bfs_cnt;
17839 }
17840 }
17841
17842 data.words_base = words_base;
17843
17844 if (keyspace == 1)
17845 {
17846 log_info ("%llu", (unsigned long long int) words_base);
17847
17848 return (0);
17849 }
17850
17851 if (data.words_cur > data.words_base)
17852 {
17853 log_error ("ERROR: restore value greater keyspace");
17854
17855 return (-1);
17856 }
17857
17858 if (data.words_cur)
17859 {
17860 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17861 {
17862 for (uint i = 0; i < data.salts_cnt; i++)
17863 {
17864 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17865 }
17866 }
17867 else if (data.attack_kern == ATTACK_KERN_COMBI)
17868 {
17869 for (uint i = 0; i < data.salts_cnt; i++)
17870 {
17871 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17872 }
17873 }
17874 else if (data.attack_kern == ATTACK_KERN_BF)
17875 {
17876 for (uint i = 0; i < data.salts_cnt; i++)
17877 {
17878 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17879 }
17880 }
17881 }
17882
17883 /*
17884 * Update loopback file
17885 */
17886
17887 if (loopback == 1)
17888 {
17889 time_t now;
17890
17891 time (&now);
17892
17893 uint random_num = get_random_num (0, 9999);
17894
17895 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17896
17897 data.loopback_file = loopback_file;
17898 }
17899
17900 /*
17901 * Update dictionary statistic
17902 */
17903
17904 if (keyspace == 0)
17905 {
17906 dictstat_fp = fopen (dictstat, "wb");
17907
17908 if (dictstat_fp)
17909 {
17910 lock_file (dictstat_fp);
17911
17912 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17913
17914 fclose (dictstat_fp);
17915 }
17916 }
17917
17918 /**
17919 * create autotune threads
17920 */
17921
17922 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17923
17924 data.devices_status = STATUS_AUTOTUNE;
17925
17926 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17927 {
17928 hc_device_param_t *device_param = &devices_param[device_id];
17929
17930 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
17931 }
17932
17933 hc_thread_wait (data.devices_cnt, c_threads);
17934
17935 /*
17936 * Inform user about possible slow speeds
17937 */
17938
17939 uint hardware_power_all = 0;
17940
17941 uint kernel_power_all = 0;
17942
17943 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17944 {
17945 hc_device_param_t *device_param = &devices_param[device_id];
17946
17947 hardware_power_all += device_param->hardware_power;
17948
17949 kernel_power_all += device_param->kernel_power;
17950 }
17951
17952 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
17953
17954 data.kernel_power_all = kernel_power_all;
17955
17956 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17957 {
17958 if (data.words_base < kernel_power_all)
17959 {
17960 if (quiet == 0)
17961 {
17962 log_info ("ATTENTION!");
17963 log_info (" The wordlist or mask you are using is too small.");
17964 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17965 log_info (" The cracking speed will drop.");
17966 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17967 log_info ("");
17968 }
17969 }
17970 }
17971
17972 /**
17973 * create cracker threads
17974 */
17975
17976 data.devices_status = STATUS_RUNNING;
17977
17978 if (initial_restore_done == 0)
17979 {
17980 if (data.restore_disable == 0) cycle_restore ();
17981
17982 initial_restore_done = 1;
17983 }
17984
17985 hc_timer_set (&data.timer_running);
17986
17987 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17988 {
17989 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17990 {
17991 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17992 if (quiet == 0) fflush (stdout);
17993 }
17994 }
17995 else if (wordlist_mode == WL_MODE_STDIN)
17996 {
17997 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17998 if (data.quiet == 0) log_info ("");
17999 }
18000
18001 time_t runtime_start;
18002
18003 time (&runtime_start);
18004
18005 data.runtime_start = runtime_start;
18006
18007 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18008 {
18009 hc_device_param_t *device_param = &devices_param[device_id];
18010
18011 if (wordlist_mode == WL_MODE_STDIN)
18012 {
18013 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18014 }
18015 else
18016 {
18017 hc_thread_create (c_threads[device_id], thread_calc, device_param);
18018 }
18019 }
18020
18021 hc_thread_wait (data.devices_cnt, c_threads);
18022
18023 local_free (c_threads);
18024
18025 data.restore = 0;
18026
18027 // finalize task
18028
18029 logfile_sub_var_uint ("status-after-work", data.devices_status);
18030
18031 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18032
18033 if (data.devices_status == STATUS_CRACKED) break;
18034 if (data.devices_status == STATUS_ABORTED) break;
18035
18036 if (data.devices_status == STATUS_BYPASS)
18037 {
18038 data.devices_status = STATUS_RUNNING;
18039 }
18040
18041 if (induction_dictionaries_cnt)
18042 {
18043 unlink (induction_dictionaries[0]);
18044 }
18045
18046 free (induction_dictionaries);
18047
18048 if (attack_mode != ATTACK_MODE_BF)
18049 {
18050 induction_dictionaries = scan_directory (induction_directory);
18051
18052 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18053 }
18054
18055 if (benchmark == 0)
18056 {
18057 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
18058 {
18059 if (quiet == 0) clear_prompt ();
18060
18061 if (quiet == 0) log_info ("");
18062
18063 if (status == 1)
18064 {
18065 status_display ();
18066 }
18067 else
18068 {
18069 if (quiet == 0) status_display ();
18070 }
18071
18072 if (quiet == 0) log_info ("");
18073 }
18074 }
18075
18076 if (attack_mode == ATTACK_MODE_BF)
18077 {
18078 dictpos++;
18079
18080 rd->dictpos = dictpos;
18081 }
18082 else
18083 {
18084 if (induction_dictionaries_cnt)
18085 {
18086 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18087 }
18088 else
18089 {
18090 dictpos++;
18091
18092 rd->dictpos = dictpos;
18093 }
18094 }
18095
18096 time_t runtime_stop;
18097
18098 time (&runtime_stop);
18099
18100 data.runtime_stop = runtime_stop;
18101
18102 logfile_sub_uint (runtime_start);
18103 logfile_sub_uint (runtime_stop);
18104
18105 logfile_sub_msg ("STOP");
18106
18107 global_free (subid);
18108 }
18109
18110 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18111
18112 if (data.devices_status == STATUS_CRACKED) break;
18113 if (data.devices_status == STATUS_ABORTED) break;
18114 if (data.devices_status == STATUS_QUIT) break;
18115
18116 if (data.devices_status == STATUS_BYPASS)
18117 {
18118 data.devices_status = STATUS_RUNNING;
18119 }
18120 }
18121
18122 // 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
18123
18124 if (attack_mode == ATTACK_MODE_STRAIGHT)
18125 {
18126 if (data.wordlist_mode == WL_MODE_FILE)
18127 {
18128 if (data.dictfile == NULL)
18129 {
18130 if (dictfiles != NULL)
18131 {
18132 data.dictfile = dictfiles[0];
18133
18134 hc_timer_set (&data.timer_running);
18135 }
18136 }
18137 }
18138 }
18139 // NOTE: combi is okay because it is already set beforehand
18140 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18141 {
18142 if (data.dictfile == NULL)
18143 {
18144 if (dictfiles != NULL)
18145 {
18146 hc_timer_set (&data.timer_running);
18147
18148 data.dictfile = dictfiles[0];
18149 }
18150 }
18151 }
18152 else if (attack_mode == ATTACK_MODE_BF)
18153 {
18154 if (data.mask == NULL)
18155 {
18156 hc_timer_set (&data.timer_running);
18157
18158 data.mask = masks[0];
18159 }
18160 }
18161
18162 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18163 {
18164 data.devices_status = STATUS_EXHAUSTED;
18165 }
18166
18167 // if cracked / aborted remove last induction dictionary
18168
18169 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18170 {
18171 struct stat induct_stat;
18172
18173 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18174 {
18175 unlink (induction_dictionaries[file_pos]);
18176 }
18177 }
18178
18179 // wait for non-interactive threads
18180
18181 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
18182 {
18183 hc_thread_wait (1, &ni_threads[thread_idx]);
18184 }
18185
18186 local_free (ni_threads);
18187
18188 // wait for interactive threads
18189
18190 for (uint thread_idx = 0; thread_idx < i_threads_cnt; thread_idx++)
18191 {
18192 hc_thread_wait (1, &i_threads[thread_idx]);
18193 }
18194
18195 local_free (i_threads);
18196
18197 // we dont need restore file anymore
18198 if (data.restore_disable == 0)
18199 {
18200 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18201 {
18202 unlink (eff_restore_file);
18203 unlink (new_restore_file);
18204 }
18205 else
18206 {
18207 cycle_restore ();
18208 }
18209 }
18210
18211 // finally save left hashes
18212
18213 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18214 {
18215 save_hash ();
18216 }
18217
18218 /**
18219 * Clean up
18220 */
18221
18222 if (benchmark == 1)
18223 {
18224 status_benchmark ();
18225
18226 if (machine_readable == 0)
18227 {
18228 log_info ("");
18229 }
18230 }
18231 else
18232 {
18233 if (quiet == 0) clear_prompt ();
18234
18235 if (quiet == 0) log_info ("");
18236
18237 if (status == 1)
18238 {
18239 status_display ();
18240 }
18241 else
18242 {
18243 if (quiet == 0) status_display ();
18244 }
18245
18246 if (quiet == 0) log_info ("");
18247 }
18248
18249 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18250 {
18251 hc_device_param_t *device_param = &data.devices_param[device_id];
18252
18253 if (device_param->skipped) continue;
18254
18255 local_free (device_param->combs_buf);
18256
18257 local_free (device_param->hooks_buf);
18258
18259 local_free (device_param->device_name);
18260
18261 local_free (device_param->device_name_chksum);
18262
18263 local_free (device_param->device_version);
18264
18265 local_free (device_param->driver_version);
18266
18267 if (device_param->pws_buf) myfree (device_param->pws_buf);
18268 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18269 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18270 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18271 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18272 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18273 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18274 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18275 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18276 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18277 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18278 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18279 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18280 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18281 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18282 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18283 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18284 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18285 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18286 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18287 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18288 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18289 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18290 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18291 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18292 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
18293 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18294 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18295 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18296
18297 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18298 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18299 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18300 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18301 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18302 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18303 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18304 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18305 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18306 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18307 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18308
18309 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18310 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18311 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18312
18313 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18314 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18315 }
18316
18317 // reset default fan speed
18318
18319 #ifdef HAVE_HWMON
18320 if (gpu_temp_disable == 0)
18321 {
18322 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
18323 {
18324 hc_thread_mutex_lock (mux_adl);
18325
18326 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18327 {
18328 hc_device_param_t *device_param = &data.devices_param[device_id];
18329
18330 if (device_param->skipped) continue;
18331
18332 if (data.hm_device[device_id].fan_set_supported == 1)
18333 {
18334 int fanspeed = temp_retain_fanspeed_value[device_id];
18335 int fanpolicy = temp_retain_fanpolicy_value[device_id];
18336
18337 if (fanpolicy == 1)
18338 {
18339 int rc = -1;
18340
18341 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18342 {
18343 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
18344 }
18345 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18346 {
18347
18348 }
18349
18350 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18351 }
18352 }
18353 }
18354
18355 hc_thread_mutex_unlock (mux_adl);
18356 }
18357 }
18358
18359 // reset power tuning
18360
18361 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18362 {
18363 hc_thread_mutex_lock (mux_adl);
18364
18365 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18366 {
18367 hc_device_param_t *device_param = &data.devices_param[device_id];
18368
18369 if (device_param->skipped) continue;
18370
18371 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18372 {
18373 if (data.hm_device[device_id].od_version == 6)
18374 {
18375 // check powertune capabilities first, if not available then skip device
18376
18377 int powertune_supported = 0;
18378
18379 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18380 {
18381 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18382
18383 return (-1);
18384 }
18385
18386 if (powertune_supported != 0)
18387 {
18388 // powercontrol settings
18389
18390 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18391 {
18392 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18393
18394 return (-1);
18395 }
18396
18397 // clocks
18398
18399 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18400
18401 performance_state->iNumberOfPerformanceLevels = 2;
18402
18403 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18404 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18405 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18406 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18407
18408 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18409 {
18410 log_info ("ERROR: Failed to restore ADL performance state");
18411
18412 return (-1);
18413 }
18414
18415 local_free (performance_state);
18416 }
18417 }
18418 }
18419
18420 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18421 {
18422 unsigned int limit = nvml_power_limit[device_id];
18423
18424 if (limit > 0)
18425 {
18426 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18427 }
18428 }
18429 }
18430
18431 hc_thread_mutex_unlock (mux_adl);
18432 }
18433
18434 if (gpu_temp_disable == 0)
18435 {
18436 if (data.hm_nvml)
18437 {
18438 hm_NVML_nvmlShutdown (data.hm_nvml);
18439
18440 nvml_close (data.hm_nvml);
18441
18442 data.hm_nvml = NULL;
18443 }
18444
18445 if (data.hm_adl)
18446 {
18447 hm_ADL_Main_Control_Destroy (data.hm_adl);
18448
18449 adl_close (data.hm_adl);
18450
18451 data.hm_adl = NULL;
18452 }
18453 }
18454 #endif // HAVE_HWMON
18455
18456 // free memory
18457
18458 local_free (masks);
18459
18460 local_free (dictstat_base);
18461
18462 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18463 {
18464 pot_t *pot_ptr = &pot[pot_pos];
18465
18466 hash_t *hash = &pot_ptr->hash;
18467
18468 local_free (hash->digest);
18469
18470 if (isSalted)
18471 {
18472 local_free (hash->salt);
18473 }
18474 }
18475
18476 local_free (pot);
18477
18478 local_free (all_kernel_rules_cnt);
18479 local_free (all_kernel_rules_buf);
18480
18481 local_free (wl_data->buf);
18482 local_free (wl_data);
18483
18484 local_free (bitmap_s1_a);
18485 local_free (bitmap_s1_b);
18486 local_free (bitmap_s1_c);
18487 local_free (bitmap_s1_d);
18488 local_free (bitmap_s2_a);
18489 local_free (bitmap_s2_b);
18490 local_free (bitmap_s2_c);
18491 local_free (bitmap_s2_d);
18492
18493 #ifdef HAVE_HWMON
18494 local_free (temp_retain_fanspeed_value);
18495 local_free (od_clock_mem_status);
18496 local_free (od_power_control_status);
18497 local_free (nvml_power_limit);
18498 #endif
18499
18500 global_free (devices_param);
18501
18502 global_free (kernel_rules_buf);
18503
18504 global_free (root_css_buf);
18505 global_free (markov_css_buf);
18506
18507 global_free (digests_buf);
18508 global_free (digests_shown);
18509 global_free (digests_shown_tmp);
18510
18511 global_free (salts_buf);
18512 global_free (salts_shown);
18513
18514 global_free (esalts_buf);
18515
18516 global_free (words_progress_done);
18517 global_free (words_progress_rejected);
18518 global_free (words_progress_restored);
18519
18520 if (pot_fp) fclose (pot_fp);
18521
18522 if (data.devices_status == STATUS_QUIT) break;
18523 }
18524
18525 // destroy others mutex
18526
18527 hc_thread_mutex_delete (mux_dispatcher);
18528 hc_thread_mutex_delete (mux_counter);
18529 hc_thread_mutex_delete (mux_display);
18530 hc_thread_mutex_delete (mux_adl);
18531
18532 // free memory
18533
18534 local_free (eff_restore_file);
18535 local_free (new_restore_file);
18536
18537 local_free (rd);
18538
18539 // tuning db
18540
18541 tuning_db_destroy (tuning_db);
18542
18543 // loopback
18544
18545 local_free (loopback_file);
18546
18547 if (loopback == 1) unlink (loopback_file);
18548
18549 // induction directory
18550
18551 if (induction_dir == NULL)
18552 {
18553 if (attack_mode != ATTACK_MODE_BF)
18554 {
18555 if (rmdir (induction_directory) == -1)
18556 {
18557 if (errno == ENOENT)
18558 {
18559 // good, we can ignore
18560 }
18561 else if (errno == ENOTEMPTY)
18562 {
18563 // good, we can ignore
18564 }
18565 else
18566 {
18567 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18568
18569 return (-1);
18570 }
18571 }
18572
18573 local_free (induction_directory);
18574 }
18575 }
18576
18577 // outfile-check directory
18578
18579 if (outfile_check_dir == NULL)
18580 {
18581 if (rmdir (outfile_check_directory) == -1)
18582 {
18583 if (errno == ENOENT)
18584 {
18585 // good, we can ignore
18586 }
18587 else if (errno == ENOTEMPTY)
18588 {
18589 // good, we can ignore
18590 }
18591 else
18592 {
18593 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18594
18595 return (-1);
18596 }
18597 }
18598
18599 local_free (outfile_check_directory);
18600 }
18601
18602 time_t proc_stop;
18603
18604 time (&proc_stop);
18605
18606 logfile_top_uint (proc_start);
18607 logfile_top_uint (proc_stop);
18608
18609 logfile_top_msg ("STOP");
18610
18611 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18612 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18613
18614 if (data.ocl) ocl_close (data.ocl);
18615
18616 if (data.devices_status == STATUS_ABORTED) return 2;
18617 if (data.devices_status == STATUS_QUIT) return 2;
18618 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18619 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18620 if (data.devices_status == STATUS_CRACKED) return 0;
18621
18622 return -1;
18623 }
Hashcat additions to support pwdhash