projects / hashcat.git / blob
? search:


13ee720b4ecc9a730fac978c88795f5995e27f04
[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 DARWIN
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define STDOUT_FLAG 0
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define MACHINE_READABLE 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define NVIDIA_SPIN_DAMP 100
79 #define GPU_TEMP_DISABLE 0
80 #define GPU_TEMP_ABORT 90
81 #define GPU_TEMP_RETAIN 75
82 #define WORKLOAD_PROFILE 2
83 #define KERNEL_ACCEL 0
84 #define KERNEL_LOOPS 0
85 #define KERNEL_RULES 1024
86 #define KERNEL_COMBS 1024
87 #define KERNEL_BFS 1024
88 #define KERNEL_THREADS_MAX 256
89 #define KERNEL_THREADS_MAX_CPU 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 | | Compare hashlist with potfile; Show cracked hashes |",
395 " --left | | Compare hashlist with potfile; Show uncracked hashes |",
396 " --username | | Enable ignoring of usernames in hashfile |",
397 " --remove | | Enable remove of hash once it is cracked |",
398 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
399 " --potfile-disable | | Do not write potfile |",
400 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
401 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
402 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
403 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
404 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
405 " --logfile-disable | | Disable the logfile |",
406 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
407 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
408 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
409 " -b, --benchmark | | Run benchmark |",
410 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
411 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
412 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
413 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
414 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
415 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
416 " -D, --opencl-device-types | Str | OpenCL device-types to use, separate with comma | -D 1",
417 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
418 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
419 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
420 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
421 " --nvidia-spin-damp | Num | Workaround NVidias CPU burning loop bug, in percent | --nvidia-spin-damp=50",
422 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
423 #ifdef HAVE_HWMON
424 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
425 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
426 " --powertune-enable | | Enable power tuning, restores settings when finished |",
427 #endif
428 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
429 " -s, --skip | Num | Skip X words from the start | -s 1000000",
430 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
431 " --keyspace | | Show keyspace base:mod values and quit |",
432 " -j, --rule-left | Rule | Single rule applied to each word from left wordlist | -j 'c'",
433 " -k, --rule-right | Rule | Single rule applied to each word from right wordlist | -k '^-'",
434 " -r, --rules-file | File | Multiple rules applied to each word from wordlists | -r rules/best64.rule",
435 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
436 " --generate-rules-func-min | Num | Force min X funcs per rule |",
437 " --generate-rules-func-max | Num | Force max X funcs per rule |",
438 " --generate-rules-seed | Num | Force RNG seed set to X |",
439 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
440 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
441 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
442 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
443 " -i, --increment | | Enable mask increment mode |",
444 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
445 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
446 "",
447 "- [ Hash modes ] -",
448 "",
449 " # | Name | Category",
450 " ======+==================================================+======================================",
451 " 900 | MD4 | Raw Hash",
452 " 0 | MD5 | Raw Hash",
453 " 5100 | Half MD5 | Raw Hash",
454 " 100 | SHA1 | Raw Hash",
455 " 10800 | SHA-384 | Raw Hash",
456 " 1400 | SHA-256 | Raw Hash",
457 " 1700 | SHA-512 | Raw Hash",
458 " 5000 | SHA-3(Keccak) | Raw Hash",
459 " 10100 | SipHash | Raw Hash",
460 " 6000 | RipeMD160 | Raw Hash",
461 " 6100 | Whirlpool | Raw Hash",
462 " 6900 | GOST R 34.11-94 | Raw Hash",
463 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
464 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
465 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
466 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
467 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
468 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
469 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
470 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
471 " 2600 | md5(md5($pass)) | Raw Hash, Salted and / or Iterated",
472 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
473 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
474 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
475 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
476 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
477 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
478 " 4500 | sha1(sha1($pass)) | Raw Hash, Salted and / or Iterated",
479 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
480 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
481 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
482 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
483 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
484 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
485 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
486 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
487 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
488 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
489 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
490 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
491 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
492 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
493 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
494 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
495 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
496 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
497 " 400 | phpass | Generic KDF",
498 " 8900 | scrypt | Generic KDF",
499 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
500 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
501 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
502 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
503 " 23 | Skype | Network protocols",
504 " 2500 | WPA/WPA2 | Network protocols",
505 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
506 " 5300 | IKE-PSK MD5 | Network protocols",
507 " 5400 | IKE-PSK SHA1 | Network protocols",
508 " 5500 | NetNTLMv1 | Network protocols",
509 " 5500 | NetNTLMv1 + ESS | Network protocols",
510 " 5600 | NetNTLMv2 | Network protocols",
511 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
512 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
513 " 8300 | DNSSEC (NSEC3) | Network protocols",
514 " 10200 | Cram MD5 | Network protocols",
515 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
516 " 11200 | MySQL CRAM (SHA1) | Network protocols",
517 " 11400 | SIP digest authentication (MD5) | Network protocols",
518 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
519 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
520 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
521 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
522 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
523 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
524 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
525 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
526 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
527 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
528 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
529 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
530 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
531 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
532 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
533 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
534 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
535 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
536 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
537 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
538 " 12 | PostgreSQL | Database Server",
539 " 131 | MSSQL(2000) | Database Server",
540 " 132 | MSSQL(2005) | Database Server",
541 " 1731 | MSSQL(2012) | Database Server",
542 " 1731 | MSSQL(2014) | Database Server",
543 " 200 | MySQL323 | Database Server",
544 " 300 | MySQL4.1/MySQL5 | Database Server",
545 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
546 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
547 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
548 " 8000 | Sybase ASE | Database Server",
549 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
550 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
551 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
552 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
553 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
554 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
555 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
556 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
557 " 11500 | CRC32 | Checksums",
558 " 3000 | LM | Operating-Systems",
559 " 1000 | NTLM | Operating-Systems",
560 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
561 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
562 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
563 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
564 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
565 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
566 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
567 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
568 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
569 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
570 " 1722 | OSX v10.7 | Operating-Systems",
571 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
572 " 6300 | AIX {smd5} | Operating-Systems",
573 " 6700 | AIX {ssha1} | Operating-Systems",
574 " 6400 | AIX {ssha256} | Operating-Systems",
575 " 6500 | AIX {ssha512} | Operating-Systems",
576 " 2400 | Cisco-PIX | Operating-Systems",
577 " 2410 | Cisco-ASA | Operating-Systems",
578 " 500 | Cisco-IOS $1$ | Operating-Systems",
579 " 5700 | Cisco-IOS $4$ | Operating-Systems",
580 " 9200 | Cisco-IOS $8$ | Operating-Systems",
581 " 9300 | Cisco-IOS $9$ | Operating-Systems",
582 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
583 " 501 | Juniper IVE | Operating-Systems",
584 " 5800 | Android PIN | Operating-Systems",
585 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
586 " 8100 | Citrix Netscaler | Operating-Systems",
587 " 8500 | RACF | Operating-Systems",
588 " 7200 | GRUB 2 | Operating-Systems",
589 " 9900 | Radmin2 | Operating-Systems",
590 " 125 | ArubaOS | Operating-Systems",
591 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
592 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
593 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
594 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
595 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
596 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
597 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
598 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
599 " 11600 | 7-Zip | Archives",
600 " 12500 | RAR3-hp | Archives",
601 " 13000 | RAR5 | Archives",
602 " 13200 | AxCrypt | Archives",
603 " 13300 | AxCrypt in memory SHA1 | Archives",
604 " 13600 | WinZip | Archives",
605 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
606 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
607 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
608 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
609 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
610 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
611 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
612 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
613 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
614 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
615 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
616 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
617 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
618 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
619 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
620 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
621 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
622 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
623 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
624 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
625 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
626 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
627 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
628 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
629 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
630 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
631 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
632 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
633 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
634 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
635 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
636 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
637 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
638 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
639 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
640 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
641 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
642 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
643 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
644 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
645 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
646 " 9400 | MS Office 2007 | Documents",
647 " 9500 | MS Office 2010 | Documents",
648 " 9600 | MS Office 2013 | Documents",
649 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
650 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
651 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
652 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
653 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
654 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
655 " 9000 | Password Safe v2 | Password Managers",
656 " 5200 | Password Safe v3 | Password Managers",
657 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
658 " 6600 | 1Password, agilekeychain | Password Managers",
659 " 8200 | 1Password, cloudkeychain | Password Managers",
660 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
661 " 12700 | Blockchain, My Wallet | Password Managers",
662 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
663 "",
664 "- [ Outfile Formats ] -",
665 "",
666 " # | Format",
667 " ===+========",
668 " 1 | hash[:salt]",
669 " 2 | plain",
670 " 3 | hash[:salt]:plain",
671 " 4 | hex_plain",
672 " 5 | hash[:salt]:hex_plain",
673 " 6 | plain:hex_plain",
674 " 7 | hash[:salt]:plain:hex_plain",
675 " 8 | crackpos",
676 " 9 | hash[:salt]:crack_pos",
677 " 10 | plain:crack_pos",
678 " 11 | hash[:salt]:plain:crack_pos",
679 " 12 | hex_plain:crack_pos",
680 " 13 | hash[:salt]:hex_plain:crack_pos",
681 " 14 | plain:hex_plain:crack_pos",
682 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
683 "",
684 "- [ Rule Debugging Modes ] -",
685 "",
686 " # | Format",
687 " ===+========",
688 " 1 | Finding-Rule",
689 " 2 | Original-Word",
690 " 3 | Original-Word:Finding-Rule",
691 " 4 | Original-Word:Finding-Rule:Processed-Word",
692 "",
693 "- [ Attack Modes ] -",
694 "",
695 " # | Mode",
696 " ===+======",
697 " 0 | Straight",
698 " 1 | Combination",
699 " 3 | Brute-force",
700 " 6 | Hybrid Wordlist + Mask",
701 " 7 | Hybrid Mask + Wordlist",
702 "",
703 "- [ Built-in Charsets ] -",
704 "",
705 " ? | Charset",
706 " ===+=========",
707 " l | abcdefghijklmnopqrstuvwxyz",
708 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
709 " d | 0123456789",
710 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
711 " a | ?l?u?d?s",
712 " b | 0x00 - 0xff",
713 "",
714 "- [ OpenCL Device Types ] -",
715 "",
716 " # | Device Type",
717 " ===+=============",
718 " 1 | CPU",
719 " 2 | GPU",
720 " 3 | FPGA, DSP, Co-Processor",
721 "",
722 "- [ Workload Profiles ] -",
723 "",
724 " # | Performance | Runtime | Power Consumption | Desktop Impact",
725 " ===+=============+=========+===================+=================",
726 " 1 | Low | 2 ms | Low | Minimal",
727 " 2 | Default | 12 ms | Economic | Noticeable",
728 " 3 | High | 96 ms | High | Unresponsive",
729 " 4 | Nightmare | 480 ms | Insane | Headless",
730 "",
731 "- [ Basic Examples ] -",
732 "",
733 " Attack- | Hash- |",
734 " Mode | Type | Example command",
735 " ==================+=======+==================================================================",
736 " Wordlist | $P$ | %s -a 0 -m 400 example400.hash example.dict",
737 " Wordlist + Rules | MD5 | %s -a 0 -m 0 example0.hash example.dict -r rules/best64.rule",
738 " Brute-Force | MD5 | %s -a 3 -m 0 example0.hash ?a?a?a?a?a?a",
739 " Combinator | MD5 | %s -a 1 -m 0 example0.hash example.dict example.dict",
740 "",
741 "If you still have no idea what just happened try following pages:",
742 "",
743 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
744 "* https://hashcat.net/wiki/#frequently_asked_questions",
745 NULL
746 };
747
748 /**
749 * hashcat specific functions
750 */
751
752 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
753 {
754 int exec_pos = (int) device_param->exec_pos - last_num_entries;
755
756 if (exec_pos < 0) exec_pos += EXEC_CACHE;
757
758 double exec_ms_sum = 0;
759
760 int exec_ms_cnt = 0;
761
762 for (int i = 0; i < last_num_entries; i++)
763 {
764 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
765
766 if (exec_ms)
767 {
768 exec_ms_sum += exec_ms;
769
770 exec_ms_cnt++;
771 }
772 }
773
774 if (exec_ms_cnt == 0) return 0;
775
776 return exec_ms_sum / exec_ms_cnt;
777 }
778
779 void status_display_machine_readable ()
780 {
781 FILE *out = stdout;
782
783 fprintf (out, "STATUS\t%u\t", data.devices_status);
784
785 /**
786 * speed new
787 */
788
789 fprintf (out, "SPEED\t");
790
791 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
792 {
793 hc_device_param_t *device_param = &data.devices_param[device_id];
794
795 if (device_param->skipped) continue;
796
797 u64 speed_cnt = 0;
798 double speed_ms = 0;
799
800 for (int i = 0; i < SPEED_CACHE; i++)
801 {
802 speed_cnt += device_param->speed_cnt[i];
803 speed_ms += device_param->speed_ms[i];
804 }
805
806 speed_cnt /= SPEED_CACHE;
807 speed_ms /= SPEED_CACHE;
808
809 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
810 }
811
812 /**
813 * exec time
814 */
815
816 fprintf (out, "EXEC_RUNTIME\t");
817
818 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
819 {
820 hc_device_param_t *device_param = &data.devices_param[device_id];
821
822 if (device_param->skipped) continue;
823
824 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
825
826 fprintf (out, "%f\t", exec_ms_avg);
827 }
828
829 /**
830 * words_cur
831 */
832
833 u64 words_cur = get_lowest_words_done ();
834
835 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
836
837 /**
838 * counter
839 */
840
841 u64 progress_total = data.words_cnt * data.salts_cnt;
842
843 u64 all_done = 0;
844 u64 all_rejected = 0;
845 u64 all_restored = 0;
846
847 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
848 {
849 all_done += data.words_progress_done[salt_pos];
850 all_rejected += data.words_progress_rejected[salt_pos];
851 all_restored += data.words_progress_restored[salt_pos];
852 }
853
854 u64 progress_cur = all_restored + all_done + all_rejected;
855 u64 progress_end = progress_total;
856
857 u64 progress_skip = 0;
858
859 if (data.skip)
860 {
861 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
862
863 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
864 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
865 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
866 }
867
868 if (data.limit)
869 {
870 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
871
872 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
873 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
874 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
875 }
876
877 u64 progress_cur_relative_skip = progress_cur - progress_skip;
878 u64 progress_end_relative_skip = progress_end - progress_skip;
879
880 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
881
882 /**
883 * cracks
884 */
885
886 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
887 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
888
889 /**
890 * temperature
891 */
892
893 #ifdef HAVE_HWMON
894 if (data.gpu_temp_disable == 0)
895 {
896 fprintf (out, "TEMP\t");
897
898 hc_thread_mutex_lock (mux_adl);
899
900 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
901 {
902 hc_device_param_t *device_param = &data.devices_param[device_id];
903
904 if (device_param->skipped) continue;
905
906 int temp = hm_get_temperature_with_device_id (device_id);
907
908 fprintf (out, "%d\t", temp);
909 }
910
911 hc_thread_mutex_unlock (mux_adl);
912 }
913 #endif // HAVE_HWMON
914
915 /**
916 * flush
917 */
918
919 fputs (EOL, out);
920 fflush (out);
921 }
922
923 void status_display ()
924 {
925 if (data.devices_status == STATUS_INIT) return;
926 if (data.devices_status == STATUS_STARTING) return;
927
928 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 char display_runtime[32] = { 0 };
1344
1345 struct tm tm_etc;
1346 struct tm tm_runtime;
1347
1348 struct tm *tmp = NULL;
1349
1350 #ifdef WIN
1351 tmp = _gmtime64 (&sec_etc);
1352 #else
1353 tmp = gmtime (&sec_etc);
1354 #endif
1355
1356 if (tmp != NULL)
1357 {
1358 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1359
1360 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1361
1362 time_t now;
1363
1364 time (&now);
1365
1366 now += sec_etc;
1367
1368 char *etc = ctime (&now);
1369
1370 size_t etc_len = strlen (etc);
1371
1372 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1373 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1374
1375 if (data.runtime)
1376 {
1377 time_t runtime_cur;
1378
1379 time (&runtime_cur);
1380
1381 #ifdef WIN
1382
1383 __time64_t runtime_left = data.proc_start + data.runtime - runtime_cur;
1384
1385 tmp = _gmtime64 (&runtime_left);
1386
1387 #else
1388
1389 time_t runtime_left = data.proc_start + data.runtime - runtime_cur;
1390
1391 tmp = gmtime (&runtime_left);
1392
1393 #endif
1394
1395 if ((tmp != NULL) && (runtime_left > 0) && (runtime_left < sec_etc))
1396 {
1397 memcpy (&tm_runtime, tmp, sizeof (tm_runtime));
1398
1399 format_timer_display (&tm_runtime, display_runtime, sizeof (display_runtime));
1400
1401 log_info ("Time.Estimated.: %s (%s), but limited (%s)", etc, display_etc, display_runtime);
1402 }
1403 else
1404 {
1405 log_info ("Time.Estimated.: %s (%s), but limit exceeded", etc, display_etc);
1406 }
1407 }
1408 else
1409 {
1410 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1411 }
1412 }
1413 }
1414 }
1415 }
1416
1417 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1418 {
1419 hc_device_param_t *device_param = &data.devices_param[device_id];
1420
1421 if (device_param->skipped) continue;
1422
1423 char display_dev_cur[16] = { 0 };
1424
1425 strncpy (display_dev_cur, "0.00", 4);
1426
1427 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1428
1429 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1430 }
1431
1432 char display_all_cur[16] = { 0 };
1433
1434 strncpy (display_all_cur, "0.00", 4);
1435
1436 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1437
1438 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1439
1440 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1441 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1442
1443 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);
1444
1445 // crack-per-time
1446
1447 if (data.digests_cnt > 100)
1448 {
1449 time_t now = time (NULL);
1450
1451 int cpt_cur_min = 0;
1452 int cpt_cur_hour = 0;
1453 int cpt_cur_day = 0;
1454
1455 for (int i = 0; i < CPT_BUF; i++)
1456 {
1457 const uint cracked = data.cpt_buf[i].cracked;
1458 const time_t timestamp = data.cpt_buf[i].timestamp;
1459
1460 if ((timestamp + 60) > now)
1461 {
1462 cpt_cur_min += cracked;
1463 }
1464
1465 if ((timestamp + 3600) > now)
1466 {
1467 cpt_cur_hour += cracked;
1468 }
1469
1470 if ((timestamp + 86400) > now)
1471 {
1472 cpt_cur_day += cracked;
1473 }
1474 }
1475
1476 double ms_real = ms_running - ms_paused;
1477
1478 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1479 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1480 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1481
1482 if ((data.cpt_start + 86400) < now)
1483 {
1484 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1485 cpt_cur_min,
1486 cpt_cur_hour,
1487 cpt_cur_day,
1488 cpt_avg_min,
1489 cpt_avg_hour,
1490 cpt_avg_day);
1491 }
1492 else if ((data.cpt_start + 3600) < now)
1493 {
1494 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1495 cpt_cur_min,
1496 cpt_cur_hour,
1497 cpt_avg_min,
1498 cpt_avg_hour,
1499 cpt_avg_day);
1500 }
1501 else if ((data.cpt_start + 60) < now)
1502 {
1503 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1504 cpt_cur_min,
1505 cpt_avg_min,
1506 cpt_avg_hour,
1507 cpt_avg_day);
1508 }
1509 else
1510 {
1511 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1512 cpt_avg_min,
1513 cpt_avg_hour,
1514 cpt_avg_day);
1515 }
1516 }
1517
1518 // Restore point
1519
1520 u64 restore_point = get_lowest_words_done ();
1521
1522 u64 restore_total = data.words_base;
1523
1524 float percent_restore = 0;
1525
1526 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1527
1528 if (progress_end_relative_skip)
1529 {
1530 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1531 {
1532 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1533 float percent_rejected = 0.0;
1534
1535 if (progress_cur)
1536 {
1537 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1538 }
1539
1540 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);
1541 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1542
1543 if (data.restore_disable == 0)
1544 {
1545 if (percent_finished != 1)
1546 {
1547 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1548 }
1549 }
1550 }
1551 }
1552 else
1553 {
1554 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1555 {
1556 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1557 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1558
1559 if (data.restore_disable == 0)
1560 {
1561 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1562 }
1563 }
1564 else
1565 {
1566 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1567 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1568
1569 // --restore not allowed if stdin is used -- really? why?
1570
1571 //if (data.restore_disable == 0)
1572 //{
1573 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1574 //}
1575 }
1576 }
1577
1578 #ifdef HAVE_HWMON
1579
1580 if (data.devices_status == STATUS_EXHAUSTED) return;
1581 if (data.devices_status == STATUS_CRACKED) return;
1582 if (data.devices_status == STATUS_ABORTED) return;
1583 if (data.devices_status == STATUS_QUIT) return;
1584
1585 if (data.gpu_temp_disable == 0)
1586 {
1587 hc_thread_mutex_lock (mux_adl);
1588
1589 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1590 {
1591 hc_device_param_t *device_param = &data.devices_param[device_id];
1592
1593 if (device_param->skipped) continue;
1594
1595 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1596 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1597 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1598 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1599 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1600 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1601 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1602
1603 char output_buf[256] = { 0 };
1604
1605 int output_len = 0;
1606
1607 if (num_temperature >= 0)
1608 {
1609 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1610
1611 output_len = strlen (output_buf);
1612 }
1613
1614 if (num_fanspeed >= 0)
1615 {
1616 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1617
1618 output_len = strlen (output_buf);
1619 }
1620
1621 if (num_utilization >= 0)
1622 {
1623 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1624
1625 output_len = strlen (output_buf);
1626 }
1627
1628 if (num_corespeed >= 0)
1629 {
1630 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1631
1632 output_len = strlen (output_buf);
1633 }
1634
1635 if (num_memoryspeed >= 0)
1636 {
1637 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1638
1639 output_len = strlen (output_buf);
1640 }
1641
1642 if (num_buslanes >= 0)
1643 {
1644 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1645
1646 output_len = strlen (output_buf);
1647 }
1648
1649 if (num_throttle == 1)
1650 {
1651 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1652
1653 output_len = strlen (output_buf);
1654 }
1655
1656 if (output_len == 0)
1657 {
1658 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1659
1660 output_len = strlen (output_buf);
1661 }
1662
1663 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1664 }
1665
1666 hc_thread_mutex_unlock (mux_adl);
1667 }
1668
1669 #endif // HAVE_HWMON
1670 }
1671
1672 static void status_benchmark_automate ()
1673 {
1674 u64 speed_cnt[DEVICES_MAX] = { 0 };
1675 double speed_ms[DEVICES_MAX] = { 0 };
1676
1677 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1678 {
1679 hc_device_param_t *device_param = &data.devices_param[device_id];
1680
1681 if (device_param->skipped) continue;
1682
1683 speed_cnt[device_id] = device_param->speed_cnt[0];
1684 speed_ms[device_id] = device_param->speed_ms[0];
1685 }
1686
1687 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1688
1689 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1690 {
1691 hc_device_param_t *device_param = &data.devices_param[device_id];
1692
1693 if (device_param->skipped) continue;
1694
1695 hashes_dev_ms[device_id] = 0;
1696
1697 if (speed_ms[device_id])
1698 {
1699 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1700 }
1701 }
1702
1703 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1704 {
1705 hc_device_param_t *device_param = &data.devices_param[device_id];
1706
1707 if (device_param->skipped) continue;
1708
1709 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1710 }
1711 }
1712
1713 static void status_benchmark ()
1714 {
1715 if (data.devices_status == STATUS_INIT) return;
1716 if (data.devices_status == STATUS_STARTING) return;
1717
1718 if (data.machine_readable == 1)
1719 {
1720 status_benchmark_automate ();
1721
1722 return;
1723 }
1724
1725 u64 speed_cnt[DEVICES_MAX] = { 0 };
1726 double speed_ms[DEVICES_MAX] = { 0 };
1727
1728 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1729 {
1730 hc_device_param_t *device_param = &data.devices_param[device_id];
1731
1732 if (device_param->skipped) continue;
1733
1734 speed_cnt[device_id] = device_param->speed_cnt[0];
1735 speed_ms[device_id] = device_param->speed_ms[0];
1736 }
1737
1738 double hashes_all_ms = 0;
1739
1740 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1741
1742 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1743 {
1744 hc_device_param_t *device_param = &data.devices_param[device_id];
1745
1746 if (device_param->skipped) continue;
1747
1748 hashes_dev_ms[device_id] = 0;
1749
1750 if (speed_ms[device_id])
1751 {
1752 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1753
1754 hashes_all_ms += hashes_dev_ms[device_id];
1755 }
1756 }
1757
1758 /**
1759 * exec time
1760 */
1761
1762 double exec_all_ms[DEVICES_MAX] = { 0 };
1763
1764 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1765 {
1766 hc_device_param_t *device_param = &data.devices_param[device_id];
1767
1768 if (device_param->skipped) continue;
1769
1770 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1771
1772 exec_all_ms[device_id] = exec_ms_avg;
1773 }
1774
1775 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1776 {
1777 hc_device_param_t *device_param = &data.devices_param[device_id];
1778
1779 if (device_param->skipped) continue;
1780
1781 char display_dev_cur[16] = { 0 };
1782
1783 strncpy (display_dev_cur, "0.00", 4);
1784
1785 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1786
1787 if (data.devices_active >= 10)
1788 {
1789 log_info ("Speed.Dev.#%d: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1790 }
1791 else
1792 {
1793 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1794 }
1795 }
1796
1797 char display_all_cur[16] = { 0 };
1798
1799 strncpy (display_all_cur, "0.00", 4);
1800
1801 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1802
1803 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1804 }
1805
1806 /**
1807 * hashcat -only- functions
1808 */
1809
1810 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1811 {
1812 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1813 {
1814 if (attack_kern == ATTACK_KERN_STRAIGHT)
1815 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1816 else if (attack_kern == ATTACK_KERN_COMBI)
1817 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1818 else if (attack_kern == ATTACK_KERN_BF)
1819 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1820 }
1821 else
1822 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1823 }
1824
1825 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)
1826 {
1827 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1828 {
1829 if (attack_kern == ATTACK_KERN_STRAIGHT)
1830 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1831 else if (attack_kern == ATTACK_KERN_COMBI)
1832 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1833 else if (attack_kern == ATTACK_KERN_BF)
1834 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1835 }
1836 else
1837 {
1838 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1839 }
1840 }
1841
1842 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1843 {
1844 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1845 {
1846 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1847 }
1848 else
1849 {
1850 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1851 }
1852 }
1853
1854 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)
1855 {
1856 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1857 {
1858 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1859 }
1860 else
1861 {
1862 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1863 }
1864 }
1865
1866 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1867 {
1868 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1869 }
1870
1871 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1872 {
1873 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1874 }
1875
1876 static char *filename_from_filepath (char *filepath)
1877 {
1878 char *ptr = NULL;
1879
1880 if ((ptr = strrchr (filepath, '/')) != NULL)
1881 {
1882 ptr++;
1883 }
1884 else if ((ptr = strrchr (filepath, '\\')) != NULL)
1885 {
1886 ptr++;
1887 }
1888 else
1889 {
1890 ptr = filepath;
1891 }
1892
1893 return ptr;
1894 }
1895
1896 static uint convert_from_hex (char *line_buf, const uint line_len)
1897 {
1898 if (line_len & 1) return (line_len); // not in hex
1899
1900 if (data.hex_wordlist == 1)
1901 {
1902 uint i;
1903 uint j;
1904
1905 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1906 {
1907 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1908 }
1909
1910 memset (line_buf + i, 0, line_len - i);
1911
1912 return (i);
1913 }
1914 else if (line_len >= 6) // $HEX[] = 6
1915 {
1916 if (line_buf[0] != '$') return (line_len);
1917 if (line_buf[1] != 'H') return (line_len);
1918 if (line_buf[2] != 'E') return (line_len);
1919 if (line_buf[3] != 'X') return (line_len);
1920 if (line_buf[4] != '[') return (line_len);
1921 if (line_buf[line_len - 1] != ']') return (line_len);
1922
1923 uint i;
1924 uint j;
1925
1926 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1927 {
1928 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1929 }
1930
1931 memset (line_buf + i, 0, line_len - i);
1932
1933 return (i);
1934 }
1935
1936 return (line_len);
1937 }
1938
1939 static void clear_prompt ()
1940 {
1941 fputc ('\r', stdout);
1942
1943 for (size_t i = 0; i < strlen (PROMPT); i++)
1944 {
1945 fputc (' ', stdout);
1946 }
1947
1948 fputc ('\r', stdout);
1949
1950 fflush (stdout);
1951 }
1952
1953 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1954 {
1955 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);
1956 }
1957
1958 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1959 {
1960 char *outfile = data.outfile;
1961 uint quiet = data.quiet;
1962 FILE *pot_fp = data.pot_fp;
1963 uint loopback = data.loopback;
1964 uint debug_mode = data.debug_mode;
1965 char *debug_file = data.debug_file;
1966
1967 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1968 int debug_rule_len = 0; // -1 error
1969 uint debug_plain_len = 0;
1970
1971 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1972
1973 // hash
1974
1975 char out_buf[HCBUFSIZ] = { 0 };
1976
1977 const u32 salt_pos = plain->salt_pos;
1978 const u32 digest_pos = plain->digest_pos; // relative
1979 const u32 gidvid = plain->gidvid;
1980 const u32 il_pos = plain->il_pos;
1981
1982 ascii_digest (out_buf, salt_pos, digest_pos);
1983
1984 // plain
1985
1986 u64 crackpos = device_param->words_off;
1987
1988 uint plain_buf[16] = { 0 };
1989
1990 u8 *plain_ptr = (u8 *) plain_buf;
1991
1992 unsigned int plain_len = 0;
1993
1994 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1995 {
1996 pw_t pw;
1997
1998 gidd_to_pw_t (device_param, gidvid, &pw);
1999
2000 for (int i = 0; i < 16; i++)
2001 {
2002 plain_buf[i] = pw.i[i];
2003 }
2004
2005 plain_len = pw.pw_len;
2006
2007 const uint off = device_param->innerloop_pos + il_pos;
2008
2009 if (debug_mode > 0)
2010 {
2011 debug_rule_len = 0;
2012
2013 // save rule
2014 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
2015 {
2016 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
2017
2018 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
2019 }
2020
2021 // save plain
2022 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
2023 {
2024 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
2025
2026 memcpy (debug_plain_ptr, plain_ptr, plain_len);
2027
2028 debug_plain_len = plain_len;
2029 }
2030 }
2031
2032 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2033
2034 crackpos += gidvid;
2035 crackpos *= data.kernel_rules_cnt;
2036 crackpos += device_param->innerloop_pos + il_pos;
2037
2038 if (plain_len > data.pw_max) plain_len = data.pw_max;
2039 }
2040 else if (data.attack_mode == ATTACK_MODE_COMBI)
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 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2054 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2055
2056 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2057 {
2058 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2059 }
2060 else
2061 {
2062 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2063
2064 memcpy (plain_ptr, comb_buf, comb_len);
2065 }
2066
2067 plain_len += comb_len;
2068
2069 crackpos += gidvid;
2070 crackpos *= data.combs_cnt;
2071 crackpos += device_param->innerloop_pos + il_pos;
2072
2073 if (data.pw_max != PW_DICTMAX1)
2074 {
2075 if (plain_len > data.pw_max) plain_len = data.pw_max;
2076 }
2077 }
2078 else if (data.attack_mode == ATTACK_MODE_BF)
2079 {
2080 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2081 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2082
2083 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2084 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2085
2086 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2087 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2088
2089 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2090 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2091
2092 plain_len = data.css_cnt;
2093
2094 crackpos += gidvid;
2095 crackpos *= data.bfs_cnt;
2096 crackpos += device_param->innerloop_pos + il_pos;
2097 }
2098 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2099 {
2100 pw_t pw;
2101
2102 gidd_to_pw_t (device_param, gidvid, &pw);
2103
2104 for (int i = 0; i < 16; i++)
2105 {
2106 plain_buf[i] = pw.i[i];
2107 }
2108
2109 plain_len = pw.pw_len;
2110
2111 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2112
2113 uint start = 0;
2114 uint stop = device_param->kernel_params_mp_buf32[4];
2115
2116 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2117
2118 plain_len += start + stop;
2119
2120 crackpos += gidvid;
2121 crackpos *= data.combs_cnt;
2122 crackpos += device_param->innerloop_pos + il_pos;
2123
2124 if (data.pw_max != PW_DICTMAX1)
2125 {
2126 if (plain_len > data.pw_max) plain_len = data.pw_max;
2127 }
2128 }
2129 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2130 {
2131 pw_t pw;
2132
2133 gidd_to_pw_t (device_param, gidvid, &pw);
2134
2135 for (int i = 0; i < 16; i++)
2136 {
2137 plain_buf[i] = pw.i[i];
2138 }
2139
2140 plain_len = pw.pw_len;
2141
2142 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2143
2144 uint start = 0;
2145 uint stop = device_param->kernel_params_mp_buf32[4];
2146
2147 memmove (plain_ptr + stop, plain_ptr, plain_len);
2148
2149 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2150
2151 plain_len += start + stop;
2152
2153 crackpos += gidvid;
2154 crackpos *= data.combs_cnt;
2155 crackpos += device_param->innerloop_pos + il_pos;
2156
2157 if (data.pw_max != PW_DICTMAX1)
2158 {
2159 if (plain_len > data.pw_max) plain_len = data.pw_max;
2160 }
2161 }
2162
2163 if (data.attack_mode == ATTACK_MODE_BF)
2164 {
2165 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2166 {
2167 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2168 {
2169 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2170 {
2171 plain_len = plain_len - data.salts_buf[0].salt_len;
2172 }
2173 }
2174
2175 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2176 {
2177 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2178 {
2179 plain_ptr[j] = plain_ptr[i];
2180 }
2181
2182 plain_len = plain_len / 2;
2183 }
2184 }
2185 }
2186
2187 // if enabled, update also the potfile
2188
2189 if (pot_fp)
2190 {
2191 lock_file (pot_fp);
2192
2193 fprintf (pot_fp, "%s:", out_buf);
2194
2195 format_plain (pot_fp, plain_ptr, plain_len, 1);
2196
2197 fputc ('\n', pot_fp);
2198
2199 fflush (pot_fp);
2200
2201 unlock_file (pot_fp);
2202 }
2203
2204 // outfile
2205
2206 FILE *out_fp = NULL;
2207
2208 if (outfile != NULL)
2209 {
2210 if ((out_fp = fopen (outfile, "ab")) == NULL)
2211 {
2212 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2213
2214 out_fp = stdout;
2215 }
2216
2217 lock_file (out_fp);
2218 }
2219 else
2220 {
2221 out_fp = stdout;
2222
2223 if (quiet == 0) clear_prompt ();
2224 }
2225
2226 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2227
2228 if (outfile != NULL)
2229 {
2230 if (out_fp != stdout)
2231 {
2232 fclose (out_fp);
2233 }
2234 }
2235 else
2236 {
2237 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2238 {
2239 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2240 {
2241 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2242 if (quiet == 0) fflush (stdout);
2243 }
2244 }
2245 }
2246
2247 // loopback
2248
2249 if (loopback)
2250 {
2251 char *loopback_file = data.loopback_file;
2252
2253 FILE *fb_fp = NULL;
2254
2255 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2256 {
2257 lock_file (fb_fp);
2258
2259 format_plain (fb_fp, plain_ptr, plain_len, 1);
2260
2261 fputc ('\n', fb_fp);
2262
2263 fclose (fb_fp);
2264 }
2265 }
2266
2267 // (rule) debug mode
2268
2269 // the next check implies that:
2270 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2271 // - debug_mode > 0
2272
2273 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2274 {
2275 if (debug_rule_len < 0) debug_rule_len = 0;
2276
2277 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2278
2279 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2280
2281 if ((quiet == 0) && (debug_file == NULL))
2282 {
2283 fprintf (stdout, "%s", PROMPT);
2284
2285 fflush (stdout);
2286 }
2287 }
2288 }
2289
2290 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2291 {
2292 salt_t *salt_buf = &data.salts_buf[salt_pos];
2293
2294 u32 num_cracked;
2295
2296 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2297
2298 if (num_cracked)
2299 {
2300 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2301
2302 log_info_nn ("");
2303
2304 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2305
2306 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);
2307
2308 uint cpt_cracked = 0;
2309
2310 hc_thread_mutex_lock (mux_display);
2311
2312 for (uint i = 0; i < num_cracked; i++)
2313 {
2314 const uint hash_pos = cracked[i].hash_pos;
2315
2316 if (data.digests_shown[hash_pos] == 1) continue;
2317
2318 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2319 {
2320 data.digests_shown[hash_pos] = 1;
2321
2322 data.digests_done++;
2323
2324 cpt_cracked++;
2325
2326 salt_buf->digests_done++;
2327
2328 if (salt_buf->digests_done == salt_buf->digests_cnt)
2329 {
2330 data.salts_shown[salt_pos] = 1;
2331
2332 data.salts_done++;
2333 }
2334 }
2335
2336 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2337
2338 check_hash (device_param, &cracked[i]);
2339 }
2340
2341 hc_thread_mutex_unlock (mux_display);
2342
2343 myfree (cracked);
2344
2345 if (cpt_cracked > 0)
2346 {
2347 hc_thread_mutex_lock (mux_display);
2348
2349 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2350 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2351
2352 data.cpt_pos++;
2353
2354 data.cpt_total += cpt_cracked;
2355
2356 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2357
2358 hc_thread_mutex_unlock (mux_display);
2359 }
2360
2361 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2362 {
2363 // we need to reset cracked state on the device
2364 // otherwise host thinks again and again the hash was cracked
2365 // and returns invalid password each time
2366
2367 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2368
2369 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);
2370 }
2371
2372 num_cracked = 0;
2373
2374 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2375 }
2376 }
2377
2378 // stolen from princeprocessor ;)
2379
2380 typedef struct
2381 {
2382 FILE *fp;
2383
2384 char buf[BUFSIZ];
2385 int len;
2386
2387 } out_t;
2388
2389 static void out_flush (out_t *out)
2390 {
2391 fwrite (out->buf, 1, out->len, out->fp);
2392
2393 out->len = 0;
2394 }
2395
2396 static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
2397 {
2398 char *ptr = out->buf + out->len;
2399
2400 memcpy (ptr, pw_buf, pw_len);
2401
2402 ptr[pw_len] = '\n';
2403
2404 out->len += pw_len + 1;
2405
2406 if (out->len >= BUFSIZ - 100)
2407 {
2408 out_flush (out);
2409 }
2410 }
2411
2412 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2413 {
2414 out_t out;
2415
2416 out.fp = stdout;
2417 out.len = 0;
2418
2419 uint plain_buf[16] = { 0 };
2420
2421 u8 *plain_ptr = (u8 *) plain_buf;
2422
2423 uint plain_len = 0;
2424
2425 const uint il_cnt = device_param->kernel_params_buf32[30]; // ugly, i know
2426
2427 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2428 {
2429 pw_t pw;
2430
2431 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2432 {
2433 gidd_to_pw_t (device_param, gidvid, &pw);
2434
2435 const uint pos = device_param->innerloop_pos;
2436
2437 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2438 {
2439 for (int i = 0; i < 8; i++)
2440 {
2441 plain_buf[i] = pw.i[i];
2442 }
2443
2444 plain_len = pw.pw_len;
2445
2446 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2447
2448 if (plain_len > data.pw_max) plain_len = data.pw_max;
2449
2450 out_push (&out, plain_ptr, plain_len);
2451 }
2452 }
2453 }
2454 else if (data.attack_mode == ATTACK_MODE_COMBI)
2455 {
2456 pw_t pw;
2457
2458 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2459 {
2460 gidd_to_pw_t (device_param, gidvid, &pw);
2461
2462 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2463 {
2464 for (int i = 0; i < 8; i++)
2465 {
2466 plain_buf[i] = pw.i[i];
2467 }
2468
2469 plain_len = pw.pw_len;
2470
2471 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2472 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2473
2474 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2475 {
2476 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2477 }
2478 else
2479 {
2480 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2481
2482 memcpy (plain_ptr, comb_buf, comb_len);
2483 }
2484
2485 plain_len += comb_len;
2486
2487 if (data.pw_max != PW_DICTMAX1)
2488 {
2489 if (plain_len > data.pw_max) plain_len = data.pw_max;
2490 }
2491
2492 out_push (&out, plain_ptr, plain_len);
2493 }
2494 }
2495 }
2496 else if (data.attack_mode == ATTACK_MODE_BF)
2497 {
2498 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2499 {
2500 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2501 {
2502 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2503 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2504
2505 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2506 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2507
2508 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2509 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2510
2511 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2512 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2513
2514 plain_len = data.css_cnt;
2515
2516 out_push (&out, plain_ptr, plain_len);
2517 }
2518 }
2519 }
2520 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2521 {
2522 pw_t pw;
2523
2524 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2525 {
2526 gidd_to_pw_t (device_param, gidvid, &pw);
2527
2528 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2529 {
2530 for (int i = 0; i < 8; i++)
2531 {
2532 plain_buf[i] = pw.i[i];
2533 }
2534
2535 plain_len = pw.pw_len;
2536
2537 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2538
2539 uint start = 0;
2540 uint stop = device_param->kernel_params_mp_buf32[4];
2541
2542 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2543
2544 plain_len += start + stop;
2545
2546 out_push (&out, plain_ptr, plain_len);
2547 }
2548 }
2549 }
2550 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2551 {
2552 pw_t pw;
2553
2554 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2555 {
2556 gidd_to_pw_t (device_param, gidvid, &pw);
2557
2558 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2559 {
2560 for (int i = 0; i < 8; i++)
2561 {
2562 plain_buf[i] = pw.i[i];
2563 }
2564
2565 plain_len = pw.pw_len;
2566
2567 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2568
2569 uint start = 0;
2570 uint stop = device_param->kernel_params_mp_buf32[4];
2571
2572 memmove (plain_ptr + stop, plain_ptr, plain_len);
2573
2574 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2575
2576 plain_len += start + stop;
2577
2578 out_push (&out, plain_ptr, plain_len);
2579 }
2580 }
2581 }
2582
2583 out_flush (&out);
2584 }
2585
2586 static void save_hash ()
2587 {
2588 char *hashfile = data.hashfile;
2589
2590 char new_hashfile[256] = { 0 };
2591 char old_hashfile[256] = { 0 };
2592
2593 snprintf (new_hashfile, 255, "%s.new", hashfile);
2594 snprintf (old_hashfile, 255, "%s.old", hashfile);
2595
2596 unlink (new_hashfile);
2597
2598 char separator = data.separator;
2599
2600 FILE *fp = fopen (new_hashfile, "wb");
2601
2602 if (fp == NULL)
2603 {
2604 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2605
2606 exit (-1);
2607 }
2608
2609 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2610 {
2611 if (data.salts_shown[salt_pos] == 1) continue;
2612
2613 salt_t *salt_buf = &data.salts_buf[salt_pos];
2614
2615 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2616 {
2617 uint idx = salt_buf->digests_offset + digest_pos;
2618
2619 if (data.digests_shown[idx] == 1) continue;
2620
2621 if (data.hash_mode != 2500)
2622 {
2623 if (data.username == 1)
2624 {
2625 user_t *user = data.hash_info[idx]->user;
2626
2627 uint i;
2628
2629 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2630
2631 fputc (separator, fp);
2632 }
2633
2634 char out_buf[HCBUFSIZ]; // scratch buffer
2635
2636 out_buf[0] = 0;
2637
2638 ascii_digest (out_buf, salt_pos, digest_pos);
2639
2640 fputs (out_buf, fp);
2641
2642 fputc ('\n', fp);
2643 }
2644 else
2645 {
2646 hccap_t hccap;
2647
2648 to_hccap_t (&hccap, salt_pos, digest_pos);
2649
2650 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2651 }
2652 }
2653 }
2654
2655 fflush (fp);
2656
2657 fclose (fp);
2658
2659 unlink (old_hashfile);
2660
2661 if (rename (hashfile, old_hashfile) != 0)
2662 {
2663 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2664
2665 exit (-1);
2666 }
2667
2668 unlink (hashfile);
2669
2670 if (rename (new_hashfile, hashfile) != 0)
2671 {
2672 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2673
2674 exit (-1);
2675 }
2676
2677 unlink (old_hashfile);
2678 }
2679
2680 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2681 {
2682 uint num_elements = num;
2683
2684 device_param->kernel_params_buf32[33] = data.combs_mode;
2685 device_param->kernel_params_buf32[34] = num;
2686
2687 uint kernel_threads = device_param->kernel_threads;
2688
2689 while (num_elements % kernel_threads) num_elements++;
2690
2691 cl_kernel kernel = NULL;
2692
2693 switch (kern_run)
2694 {
2695 case KERN_RUN_1: kernel = device_param->kernel1; break;
2696 case KERN_RUN_12: kernel = device_param->kernel12; break;
2697 case KERN_RUN_2: kernel = device_param->kernel2; break;
2698 case KERN_RUN_23: kernel = device_param->kernel23; break;
2699 case KERN_RUN_3: kernel = device_param->kernel3; break;
2700 }
2701
2702 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2703 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2704 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2705 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2706 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2707 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2708 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2709 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2710 hc_clSetKernelArg (data.ocl, kernel, 32, sizeof (cl_uint), device_param->kernel_params[32]);
2711 hc_clSetKernelArg (data.ocl, kernel, 33, sizeof (cl_uint), device_param->kernel_params[33]);
2712 hc_clSetKernelArg (data.ocl, kernel, 34, sizeof (cl_uint), device_param->kernel_params[34]);
2713
2714 cl_event event;
2715
2716 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2717 {
2718 const size_t global_work_size[3] = { num_elements, 32, 1 };
2719 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2720
2721 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2722 }
2723 else
2724 {
2725 if (kern_run == KERN_RUN_2)
2726 {
2727 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2728 {
2729 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2730 }
2731 }
2732
2733 while (num_elements % kernel_threads) num_elements++;
2734
2735 const size_t global_work_size[3] = { num_elements, 1, 1 };
2736 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2737
2738 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2739 }
2740
2741 hc_clFlush (data.ocl, device_param->command_queue);
2742
2743 if (device_param->nvidia_spin_damp)
2744 {
2745 if (data.devices_status == STATUS_RUNNING)
2746 {
2747 if (iteration < EXPECTED_ITERATIONS)
2748 {
2749 switch (kern_run)
2750 {
2751 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2752 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2753 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2754 }
2755 }
2756 }
2757 }
2758
2759 hc_clWaitForEvents (data.ocl, 1, &event);
2760
2761 cl_ulong time_start;
2762 cl_ulong time_end;
2763
2764 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2765 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2766
2767 const double exec_us = (double) (time_end - time_start) / 1000;
2768
2769 if (data.devices_status == STATUS_RUNNING)
2770 {
2771 if (iteration < EXPECTED_ITERATIONS)
2772 {
2773 switch (kern_run)
2774 {
2775 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2776 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2777 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2778 }
2779 }
2780 }
2781
2782 if (event_update)
2783 {
2784 uint exec_pos = device_param->exec_pos;
2785
2786 device_param->exec_ms[exec_pos] = exec_us / 1000;
2787
2788 exec_pos++;
2789
2790 if (exec_pos == EXEC_CACHE)
2791 {
2792 exec_pos = 0;
2793 }
2794
2795 device_param->exec_pos = exec_pos;
2796 }
2797
2798 hc_clReleaseEvent (data.ocl, event);
2799
2800 hc_clFinish (data.ocl, device_param->command_queue);
2801 }
2802
2803 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2804 {
2805 uint num_elements = num;
2806
2807 switch (kern_run)
2808 {
2809 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2810 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2811 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2812 }
2813
2814 // causes problems with special threads like in bcrypt
2815 // const uint kernel_threads = device_param->kernel_threads;
2816
2817 uint kernel_threads = device_param->kernel_threads;
2818
2819 while (num_elements % kernel_threads) num_elements++;
2820
2821 cl_kernel kernel = NULL;
2822
2823 switch (kern_run)
2824 {
2825 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2826 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2827 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2828 }
2829
2830 switch (kern_run)
2831 {
2832 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2833 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2834 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2835 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2836 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2837 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2838 break;
2839 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2840 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2841 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2842 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2843 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2844 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2845 break;
2846 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2847 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2848 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2849 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2850 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2851 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2852 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2853 break;
2854 }
2855
2856 const size_t global_work_size[3] = { num_elements, 1, 1 };
2857 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2858
2859 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2860
2861 hc_clFlush (data.ocl, device_param->command_queue);
2862
2863 hc_clFinish (data.ocl, device_param->command_queue);
2864 }
2865
2866 static void run_kernel_tm (hc_device_param_t *device_param)
2867 {
2868 const uint num_elements = 1024; // fixed
2869
2870 uint kernel_threads = 32;
2871
2872 cl_kernel kernel = device_param->kernel_tm;
2873
2874 const size_t global_work_size[3] = { num_elements, 1, 1 };
2875 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2876
2877 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2878
2879 hc_clFlush (data.ocl, device_param->command_queue);
2880
2881 hc_clFinish (data.ocl, device_param->command_queue);
2882 }
2883
2884 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2885 {
2886 uint num_elements = num;
2887
2888 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2889 device_param->kernel_params_amp_buf32[6] = num_elements;
2890
2891 // causes problems with special threads like in bcrypt
2892 // const uint kernel_threads = device_param->kernel_threads;
2893
2894 uint kernel_threads = device_param->kernel_threads;
2895
2896 while (num_elements % kernel_threads) num_elements++;
2897
2898 cl_kernel kernel = device_param->kernel_amp;
2899
2900 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2901 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2902
2903 const size_t global_work_size[3] = { num_elements, 1, 1 };
2904 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2905
2906 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2907
2908 hc_clFlush (data.ocl, device_param->command_queue);
2909
2910 hc_clFinish (data.ocl, device_param->command_queue);
2911 }
2912
2913 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2914 {
2915 const u32 num16d = num / 16;
2916 const u32 num16m = num % 16;
2917
2918 if (num16d)
2919 {
2920 device_param->kernel_params_memset_buf32[1] = value;
2921 device_param->kernel_params_memset_buf32[2] = num16d;
2922
2923 uint kernel_threads = device_param->kernel_threads;
2924
2925 uint num_elements = num16d;
2926
2927 while (num_elements % kernel_threads) num_elements++;
2928
2929 cl_kernel kernel = device_param->kernel_memset;
2930
2931 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2932 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2933 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2934
2935 const size_t global_work_size[3] = { num_elements, 1, 1 };
2936 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2937
2938 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2939
2940 hc_clFlush (data.ocl, device_param->command_queue);
2941
2942 hc_clFinish (data.ocl, device_param->command_queue);
2943 }
2944
2945 if (num16m)
2946 {
2947 u32 tmp[4];
2948
2949 tmp[0] = value;
2950 tmp[1] = value;
2951 tmp[2] = value;
2952 tmp[3] = value;
2953
2954 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2955 }
2956 }
2957
2958 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2959 {
2960 run_kernel_memset (device_param, buf, 0, size);
2961
2962 /*
2963 int rc = -1;
2964
2965 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2966 {
2967 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2968
2969 const cl_uchar zero = 0;
2970
2971 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2972 }
2973
2974 if (rc != 0)
2975 {
2976 // NOTE: clEnqueueFillBuffer () always fails with -59
2977 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2978 // How's that possible, OpenCL 1.2 support is advertised??
2979 // We need to workaround...
2980
2981 #define FILLSZ 0x100000
2982
2983 char *tmp = (char *) mymalloc (FILLSZ);
2984
2985 for (size_t i = 0; i < size; i += FILLSZ)
2986 {
2987 const size_t left = size - i;
2988
2989 const size_t fillsz = MIN (FILLSZ, left);
2990
2991 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2992 }
2993
2994 myfree (tmp);
2995 }
2996 */
2997 }
2998
2999 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)
3000 {
3001 if (data.hash_mode == 2000)
3002 {
3003 process_stdout (device_param, pws_cnt);
3004
3005 return;
3006 }
3007
3008 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3009 {
3010 if (attack_mode == ATTACK_MODE_BF)
3011 {
3012 if (opts_type & OPTS_TYPE_PT_BITSLICE)
3013 {
3014 const uint size_tm = 32 * sizeof (bs_word_t);
3015
3016 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
3017
3018 run_kernel_tm (device_param);
3019
3020 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);
3021 }
3022 }
3023
3024 if (highest_pw_len < 16)
3025 {
3026 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
3027 }
3028 else if (highest_pw_len < 32)
3029 {
3030 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
3031 }
3032 else
3033 {
3034 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
3035 }
3036 }
3037 else
3038 {
3039 run_kernel_amp (device_param, pws_cnt);
3040
3041 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
3042
3043 if (opts_type & OPTS_TYPE_HOOK12)
3044 {
3045 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
3046
3047 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);
3048
3049 // do something with data
3050
3051 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);
3052 }
3053
3054 uint iter = salt_buf->salt_iter;
3055
3056 uint loop_step = device_param->kernel_loops;
3057
3058 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
3059 {
3060 uint loop_left = iter - loop_pos;
3061
3062 loop_left = MIN (loop_left, loop_step);
3063
3064 device_param->kernel_params_buf32[28] = loop_pos;
3065 device_param->kernel_params_buf32[29] = loop_left;
3066
3067 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
3068
3069 if (data.devices_status == STATUS_CRACKED) break;
3070 if (data.devices_status == STATUS_ABORTED) break;
3071 if (data.devices_status == STATUS_QUIT) break;
3072 if (data.devices_status == STATUS_BYPASS) break;
3073
3074 /**
3075 * speed
3076 */
3077
3078 const float iter_part = (float) (loop_pos + loop_left) / iter;
3079
3080 const u64 perf_sum_all = pws_cnt * iter_part;
3081
3082 double speed_ms;
3083
3084 hc_timer_get (device_param->timer_speed, speed_ms);
3085
3086 const u32 speed_pos = device_param->speed_pos;
3087
3088 device_param->speed_cnt[speed_pos] = perf_sum_all;
3089
3090 device_param->speed_ms[speed_pos] = speed_ms;
3091
3092 if (data.benchmark == 1)
3093 {
3094 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3095 }
3096 }
3097
3098 if (opts_type & OPTS_TYPE_HOOK23)
3099 {
3100 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3101
3102 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);
3103
3104 // do something with data
3105
3106 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);
3107 }
3108
3109 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3110 }
3111 }
3112
3113 static int run_rule_engine (const int rule_len, const char *rule_buf)
3114 {
3115 if (rule_len == 0)
3116 {
3117 return 0;
3118 }
3119 else if (rule_len == 1)
3120 {
3121 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3122 }
3123
3124 return 1;
3125 }
3126
3127 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3128 {
3129 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3130 {
3131 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);
3132 }
3133 else if (data.attack_kern == ATTACK_KERN_COMBI)
3134 {
3135 if (data.attack_mode == ATTACK_MODE_COMBI)
3136 {
3137 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3138 {
3139 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3140 {
3141 for (u32 i = 0; i < pws_cnt; i++)
3142 {
3143 const u32 pw_len = device_param->pws_buf[i].pw_len;
3144
3145 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3146
3147 ptr[pw_len] = 0x01;
3148 }
3149 }
3150 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3151 {
3152 for (u32 i = 0; i < pws_cnt; i++)
3153 {
3154 const u32 pw_len = device_param->pws_buf[i].pw_len;
3155
3156 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3157
3158 ptr[pw_len] = 0x80;
3159 }
3160 }
3161 }
3162 }
3163 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3164 {
3165 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3166 {
3167 for (u32 i = 0; i < pws_cnt; i++)
3168 {
3169 const u32 pw_len = device_param->pws_buf[i].pw_len;
3170
3171 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3172
3173 ptr[pw_len] = 0x01;
3174 }
3175 }
3176 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3177 {
3178 for (u32 i = 0; i < pws_cnt; i++)
3179 {
3180 const u32 pw_len = device_param->pws_buf[i].pw_len;
3181
3182 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3183
3184 ptr[pw_len] = 0x80;
3185 }
3186 }
3187 }
3188
3189 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);
3190 }
3191 else if (data.attack_kern == ATTACK_KERN_BF)
3192 {
3193 const u64 off = device_param->words_off;
3194
3195 device_param->kernel_params_mp_l_buf64[3] = off;
3196
3197 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3198 }
3199 }
3200
3201 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3202 {
3203 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3204
3205 device_param->kernel_params_buf32[28] = 0;
3206 device_param->kernel_params_buf32[29] = kernel_loops; // not a bug, both need to be set
3207 device_param->kernel_params_buf32[30] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3208
3209 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3210 {
3211 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3212 }
3213 else
3214 {
3215 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3216 }
3217
3218 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3219
3220 return exec_ms_prev;
3221 }
3222
3223 static void autotune (hc_device_param_t *device_param)
3224 {
3225 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3226
3227 const u32 kernel_accel_min = device_param->kernel_accel_min;
3228 const u32 kernel_accel_max = device_param->kernel_accel_max;
3229
3230 const u32 kernel_loops_min = device_param->kernel_loops_min;
3231 const u32 kernel_loops_max = device_param->kernel_loops_max;
3232
3233 u32 kernel_accel = kernel_accel_min;
3234 u32 kernel_loops = kernel_loops_min;
3235
3236 // in this case the user specified a fixed -u and -n on the commandline
3237 // no way to tune anything
3238 // but we need to run a few caching rounds
3239
3240 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3241 {
3242 if (data.hash_mode != 2000)
3243 {
3244 try_run (device_param, kernel_accel, kernel_loops);
3245 try_run (device_param, kernel_accel, kernel_loops);
3246 try_run (device_param, kernel_accel, kernel_loops);
3247 try_run (device_param, kernel_accel, kernel_loops);
3248 }
3249
3250 device_param->kernel_accel = kernel_accel;
3251 device_param->kernel_loops = kernel_loops;
3252
3253 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3254
3255 device_param->kernel_power = kernel_power;
3256
3257 return;
3258 }
3259
3260 // from here it's clear we are allowed to autotune
3261 // so let's init some fake words
3262
3263 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3264
3265 if (data.attack_kern == ATTACK_KERN_BF)
3266 {
3267 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3268 }
3269 else
3270 {
3271 for (u32 i = 0; i < kernel_power_max; i++)
3272 {
3273 device_param->pws_buf[i].i[0] = i;
3274 device_param->pws_buf[i].i[1] = 0x01234567;
3275 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3276 }
3277
3278 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);
3279 }
3280
3281 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3282 {
3283 if (data.kernel_rules_cnt > 1)
3284 {
3285 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);
3286 }
3287 }
3288 else
3289 {
3290 run_kernel_amp (device_param, kernel_power_max);
3291 }
3292
3293 #define VERIFIER_CNT 1
3294
3295 // first find out highest kernel-loops that stays below target_ms
3296
3297 if (kernel_loops_min < kernel_loops_max)
3298 {
3299 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3300 {
3301 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3302
3303 for (int i = 0; i < VERIFIER_CNT; i++)
3304 {
3305 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3306
3307 exec_ms = MIN (exec_ms, exec_ms_v);
3308 }
3309
3310 if (exec_ms < target_ms) break;
3311 }
3312 }
3313
3314 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3315
3316 #define STEPS_CNT 10
3317
3318 if (kernel_accel_min < kernel_accel_max)
3319 {
3320 for (int i = 0; i < STEPS_CNT; i++)
3321 {
3322 const u32 kernel_accel_try = 1 << i;
3323
3324 if (kernel_accel_try < kernel_accel_min) continue;
3325 if (kernel_accel_try > kernel_accel_max) break;
3326
3327 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3328
3329 for (int i = 0; i < VERIFIER_CNT; i++)
3330 {
3331 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3332
3333 exec_ms = MIN (exec_ms, exec_ms_v);
3334 }
3335
3336 if (exec_ms > target_ms) break;
3337
3338 kernel_accel = kernel_accel_try;
3339 }
3340 }
3341
3342 // at this point we want to know the actual runtime for the following reason:
3343 // we need a reference for the balancing loop following up, and this
3344 // the balancing loop can have an effect that the creates a new opportunity, for example:
3345 // if the target is 95 ms and the current runtime is 48ms the above loop
3346 // stopped the execution because the previous exec_ms was > 95ms
3347 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3348 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3349
3350 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3351
3352 for (int i = 0; i < VERIFIER_CNT; i++)
3353 {
3354 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3355
3356 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3357 }
3358
3359 u32 diff = kernel_loops - kernel_accel;
3360
3361 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3362 {
3363 u32 kernel_accel_orig = kernel_accel;
3364 u32 kernel_loops_orig = kernel_loops;
3365
3366 for (u32 f = 1; f < 1024; f++)
3367 {
3368 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3369 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3370
3371 if (kernel_accel_try > kernel_accel_max) break;
3372 if (kernel_loops_try < kernel_loops_min) break;
3373
3374 u32 diff_new = kernel_loops_try - kernel_accel_try;
3375
3376 if (diff_new > diff) break;
3377
3378 diff_new = diff;
3379
3380 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3381
3382 for (int i = 0; i < VERIFIER_CNT; i++)
3383 {
3384 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3385
3386 exec_ms = MIN (exec_ms, exec_ms_v);
3387 }
3388
3389 if (exec_ms < exec_ms_pre_final)
3390 {
3391 exec_ms_pre_final = exec_ms;
3392
3393 kernel_accel = kernel_accel_try;
3394 kernel_loops = kernel_loops_try;
3395 }
3396 }
3397 }
3398
3399 const double exec_left = target_ms / exec_ms_pre_final;
3400
3401 const double accel_left = kernel_accel_max / kernel_accel;
3402
3403 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3404
3405 if (exec_accel_min >= 1.0)
3406 {
3407 // this is safe to not overflow kernel_accel_max because of accel_left
3408
3409 kernel_accel = (double) kernel_accel * exec_accel_min;
3410 }
3411
3412 // reset them fake words
3413
3414 /*
3415 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3416
3417 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);
3418 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);
3419 */
3420
3421 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3422
3423 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3424 {
3425 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3426 }
3427
3428 // reset timer
3429
3430 device_param->exec_pos = 0;
3431
3432 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3433
3434 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3435 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3436 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3437
3438 // store
3439
3440 device_param->kernel_accel = kernel_accel;
3441 device_param->kernel_loops = kernel_loops;
3442
3443 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3444
3445 device_param->kernel_power = kernel_power;
3446
3447 #ifdef DEBUG
3448
3449 if (data.quiet == 0)
3450 {
3451 clear_prompt ();
3452
3453 log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3454 "- Device #%u: autotuned kernel-loops to %u\n",
3455 device_param->device_id + 1, kernel_accel,
3456 device_param->device_id + 1, kernel_loops);
3457
3458 fprintf (stdout, "%s", PROMPT);
3459
3460 fflush (stdout);
3461 }
3462
3463 #endif
3464 }
3465
3466 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3467 {
3468 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3469
3470 // init speed timer
3471
3472 uint speed_pos = device_param->speed_pos;
3473
3474 #ifdef _POSIX
3475 if (device_param->timer_speed.tv_sec == 0)
3476 {
3477 hc_timer_set (&device_param->timer_speed);
3478 }
3479 #endif
3480
3481 #ifdef _WIN
3482 if (device_param->timer_speed.QuadPart == 0)
3483 {
3484 hc_timer_set (&device_param->timer_speed);
3485 }
3486 #endif
3487
3488 // find higest password length, this is for optimization stuff
3489
3490 uint highest_pw_len = 0;
3491
3492 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3493 {
3494 }
3495 else if (data.attack_kern == ATTACK_KERN_COMBI)
3496 {
3497 }
3498 else if (data.attack_kern == ATTACK_KERN_BF)
3499 {
3500 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3501 + device_param->kernel_params_mp_l_buf32[5];
3502 }
3503
3504 // iteration type
3505
3506 uint innerloop_step = 0;
3507 uint innerloop_cnt = 0;
3508
3509 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3510 else innerloop_step = 1;
3511
3512 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3513 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3514 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3515
3516 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3517
3518 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3519 {
3520 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3521
3522 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3523
3524 if (data.devices_status == STATUS_CRACKED) break;
3525 if (data.devices_status == STATUS_ABORTED) break;
3526 if (data.devices_status == STATUS_QUIT) break;
3527 if (data.devices_status == STATUS_BYPASS) break;
3528
3529 salt_t *salt_buf = &data.salts_buf[salt_pos];
3530
3531 device_param->kernel_params_buf32[27] = salt_pos;
3532 device_param->kernel_params_buf32[31] = salt_buf->digests_cnt;
3533 device_param->kernel_params_buf32[32] = salt_buf->digests_offset;
3534
3535 FILE *combs_fp = device_param->combs_fp;
3536
3537 if (data.attack_mode == ATTACK_MODE_COMBI)
3538 {
3539 rewind (combs_fp);
3540 }
3541
3542 // innerloops
3543
3544 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3545 {
3546 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3547
3548 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3549
3550 if (data.devices_status == STATUS_CRACKED) break;
3551 if (data.devices_status == STATUS_ABORTED) break;
3552 if (data.devices_status == STATUS_QUIT) break;
3553 if (data.devices_status == STATUS_BYPASS) break;
3554
3555 uint fast_iteration = 0;
3556
3557 uint innerloop_left = innerloop_cnt - innerloop_pos;
3558
3559 if (innerloop_left > innerloop_step)
3560 {
3561 innerloop_left = innerloop_step;
3562
3563 fast_iteration = 1;
3564 }
3565
3566 device_param->innerloop_pos = innerloop_pos;
3567 device_param->innerloop_left = innerloop_left;
3568
3569 device_param->kernel_params_buf32[30] = innerloop_left;
3570
3571 // i think we can get rid of this
3572 if (innerloop_left == 0)
3573 {
3574 puts ("bug, how should this happen????\n");
3575
3576 continue;
3577 }
3578
3579 if (data.salts_shown[salt_pos] == 1)
3580 {
3581 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3582
3583 continue;
3584 }
3585
3586 // initialize amplifiers
3587
3588 if (data.attack_mode == ATTACK_MODE_COMBI)
3589 {
3590 uint i = 0;
3591
3592 while (i < innerloop_left)
3593 {
3594 if (feof (combs_fp)) break;
3595
3596 int line_len = fgetl (combs_fp, line_buf);
3597
3598 if (line_len >= PW_MAX1) continue;
3599
3600 line_len = convert_from_hex (line_buf, line_len);
3601
3602 char *line_buf_new = line_buf;
3603
3604 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3605 {
3606 char rule_buf_out[BLOCK_SIZE] = { 0 };
3607
3608 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3609
3610 if (rule_len_out < 0)
3611 {
3612 data.words_progress_rejected[salt_pos] += pws_cnt;
3613
3614 continue;
3615 }
3616
3617 line_len = rule_len_out;
3618
3619 line_buf_new = rule_buf_out;
3620 }
3621
3622 line_len = MIN (line_len, PW_DICTMAX);
3623
3624 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3625
3626 memcpy (ptr, line_buf_new, line_len);
3627
3628 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3629
3630 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3631 {
3632 uppercase (ptr, line_len);
3633 }
3634
3635 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3636 {
3637 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3638 {
3639 ptr[line_len] = 0x80;
3640 }
3641
3642 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3643 {
3644 ptr[line_len] = 0x01;
3645 }
3646 }
3647
3648 device_param->combs_buf[i].pw_len = line_len;
3649
3650 i++;
3651 }
3652
3653 for (uint j = i; j < innerloop_left; j++)
3654 {
3655 device_param->combs_buf[j].i[0] = 0;
3656 device_param->combs_buf[j].i[1] = 0;
3657 device_param->combs_buf[j].i[2] = 0;
3658 device_param->combs_buf[j].i[3] = 0;
3659 device_param->combs_buf[j].i[4] = 0;
3660 device_param->combs_buf[j].i[5] = 0;
3661 device_param->combs_buf[j].i[6] = 0;
3662 device_param->combs_buf[j].i[7] = 0;
3663
3664 device_param->combs_buf[j].pw_len = 0;
3665 }
3666
3667 innerloop_left = i;
3668 }
3669 else if (data.attack_mode == ATTACK_MODE_BF)
3670 {
3671 u64 off = innerloop_pos;
3672
3673 device_param->kernel_params_mp_r_buf64[3] = off;
3674
3675 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3676 }
3677 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3678 {
3679 u64 off = innerloop_pos;
3680
3681 device_param->kernel_params_mp_buf64[3] = off;
3682
3683 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3684 }
3685 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3686 {
3687 u64 off = innerloop_pos;
3688
3689 device_param->kernel_params_mp_buf64[3] = off;
3690
3691 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3692 }
3693
3694 // copy amplifiers
3695
3696 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3697 {
3698 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);
3699 }
3700 else if (data.attack_mode == ATTACK_MODE_COMBI)
3701 {
3702 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);
3703 }
3704 else if (data.attack_mode == ATTACK_MODE_BF)
3705 {
3706 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);
3707 }
3708 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3709 {
3710 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);
3711 }
3712 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3713 {
3714 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);
3715 }
3716
3717 if (data.benchmark == 1)
3718 {
3719 hc_timer_set (&device_param->timer_speed);
3720 }
3721
3722 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3723
3724 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3725
3726 if (data.devices_status == STATUS_CRACKED) break;
3727 if (data.devices_status == STATUS_ABORTED) break;
3728 if (data.devices_status == STATUS_QUIT) break;
3729 if (data.devices_status == STATUS_BYPASS) break;
3730
3731 /**
3732 * result
3733 */
3734
3735 if (data.benchmark == 0)
3736 {
3737 check_cracked (device_param, salt_pos);
3738 }
3739
3740 /**
3741 * progress
3742 */
3743
3744 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3745
3746 hc_thread_mutex_lock (mux_counter);
3747
3748 data.words_progress_done[salt_pos] += perf_sum_all;
3749
3750 hc_thread_mutex_unlock (mux_counter);
3751
3752 /**
3753 * speed
3754 */
3755
3756 double speed_ms;
3757
3758 hc_timer_get (device_param->timer_speed, speed_ms);
3759
3760 hc_timer_set (&device_param->timer_speed);
3761
3762 // current speed
3763
3764 //hc_thread_mutex_lock (mux_display);
3765
3766 device_param->speed_cnt[speed_pos] = perf_sum_all;
3767
3768 device_param->speed_ms[speed_pos] = speed_ms;
3769
3770 //hc_thread_mutex_unlock (mux_display);
3771
3772 speed_pos++;
3773
3774 if (speed_pos == SPEED_CACHE)
3775 {
3776 speed_pos = 0;
3777 }
3778
3779 /**
3780 * benchmark
3781 */
3782
3783 if (data.benchmark == 1) break;
3784 }
3785 }
3786
3787 device_param->speed_pos = speed_pos;
3788
3789 myfree (line_buf);
3790 }
3791
3792 static void load_segment (wl_data_t *wl_data, FILE *fd)
3793 {
3794 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3795
3796 wl_data->pos = 0;
3797
3798 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3799
3800 wl_data->buf[wl_data->cnt] = 0;
3801
3802 if (wl_data->cnt == 0) return;
3803
3804 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3805
3806 while (!feof (fd))
3807 {
3808 if (wl_data->cnt == wl_data->avail)
3809 {
3810 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3811
3812 wl_data->avail += wl_data->incr;
3813 }
3814
3815 const int c = fgetc (fd);
3816
3817 if (c == EOF) break;
3818
3819 wl_data->buf[wl_data->cnt] = (char) c;
3820
3821 wl_data->cnt++;
3822
3823 if (c == '\n') break;
3824 }
3825
3826 // ensure stream ends with a newline
3827
3828 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3829 {
3830 wl_data->cnt++;
3831
3832 wl_data->buf[wl_data->cnt - 1] = '\n';
3833 }
3834
3835 return;
3836 }
3837
3838 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3839 {
3840 char *ptr = buf;
3841
3842 for (u32 i = 0; i < sz; i++, ptr++)
3843 {
3844 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3845
3846 if (i == 7)
3847 {
3848 *off = i;
3849 *len = i;
3850
3851 return;
3852 }
3853
3854 if (*ptr != '\n') continue;
3855
3856 *off = i + 1;
3857
3858 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3859
3860 *len = i;
3861
3862 return;
3863 }
3864
3865 *off = sz;
3866 *len = sz;
3867 }
3868
3869 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3870 {
3871 char *ptr = buf;
3872
3873 for (u32 i = 0; i < sz; i++, ptr++)
3874 {
3875 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3876
3877 if (*ptr != '\n') continue;
3878
3879 *off = i + 1;
3880
3881 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3882
3883 *len = i;
3884
3885 return;
3886 }
3887
3888 *off = sz;
3889 *len = sz;
3890 }
3891
3892 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3893 {
3894 char *ptr = buf;
3895
3896 for (u32 i = 0; i < sz; i++, ptr++)
3897 {
3898 if (*ptr != '\n') continue;
3899
3900 *off = i + 1;
3901
3902 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3903
3904 *len = i;
3905
3906 return;
3907 }
3908
3909 *off = sz;
3910 *len = sz;
3911 }
3912
3913 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3914 {
3915 while (wl_data->pos < wl_data->cnt)
3916 {
3917 uint off;
3918 uint len;
3919
3920 char *ptr = wl_data->buf + wl_data->pos;
3921
3922 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3923
3924 wl_data->pos += off;
3925
3926 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3927 {
3928 char rule_buf_out[BLOCK_SIZE] = { 0 };
3929
3930 int rule_len_out = -1;
3931
3932 if (len < BLOCK_SIZE)
3933 {
3934 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3935 }
3936
3937 if (rule_len_out < 0)
3938 {
3939 continue;
3940 }
3941
3942 if (rule_len_out > PW_MAX)
3943 {
3944 continue;
3945 }
3946 }
3947 else
3948 {
3949 if (len > PW_MAX)
3950 {
3951 continue;
3952 }
3953 }
3954
3955 *out_buf = ptr;
3956 *out_len = len;
3957
3958 return;
3959 }
3960
3961 if (feof (fd))
3962 {
3963 fprintf (stderr, "BUG feof()!!\n");
3964
3965 return;
3966 }
3967
3968 load_segment (wl_data, fd);
3969
3970 get_next_word (wl_data, fd, out_buf, out_len);
3971 }
3972
3973 #ifdef _POSIX
3974 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3975 #endif
3976
3977 #ifdef _WIN
3978 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3979 #endif
3980 {
3981 hc_signal (NULL);
3982
3983 dictstat_t d;
3984
3985 d.cnt = 0;
3986
3987 #ifdef _POSIX
3988 fstat (fileno (fd), &d.stat);
3989 #endif
3990
3991 #ifdef _WIN
3992 _fstat64 (fileno (fd), &d.stat);
3993 #endif
3994
3995 d.stat.st_mode = 0;
3996 d.stat.st_nlink = 0;
3997 d.stat.st_uid = 0;
3998 d.stat.st_gid = 0;
3999 d.stat.st_rdev = 0;
4000 d.stat.st_atime = 0;
4001
4002 #ifdef _POSIX
4003 d.stat.st_blksize = 0;
4004 d.stat.st_blocks = 0;
4005 #endif
4006
4007 if (d.stat.st_size == 0) return 0;
4008
4009 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4010
4011 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
4012 {
4013 if (d_cache)
4014 {
4015 u64 cnt = d_cache->cnt;
4016
4017 u64 keyspace = cnt;
4018
4019 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4020 {
4021 keyspace *= data.kernel_rules_cnt;
4022 }
4023 else if (data.attack_kern == ATTACK_KERN_COMBI)
4024 {
4025 keyspace *= data.combs_cnt;
4026 }
4027
4028 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);
4029 if (data.quiet == 0) log_info ("");
4030
4031 hc_signal (sigHandler_default);
4032
4033 return (keyspace);
4034 }
4035 }
4036
4037 time_t now = 0;
4038 time_t prev = 0;
4039
4040 u64 comp = 0;
4041 u64 cnt = 0;
4042 u64 cnt2 = 0;
4043
4044 while (!feof (fd))
4045 {
4046 load_segment (wl_data, fd);
4047
4048 comp += wl_data->cnt;
4049
4050 u32 i = 0;
4051
4052 while (i < wl_data->cnt)
4053 {
4054 u32 len;
4055 u32 off;
4056
4057 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
4058
4059 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4060 {
4061 char rule_buf_out[BLOCK_SIZE] = { 0 };
4062
4063 int rule_len_out = -1;
4064
4065 if (len < BLOCK_SIZE)
4066 {
4067 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
4068 }
4069
4070 if (rule_len_out < 0)
4071 {
4072 len = PW_MAX1;
4073 }
4074 else
4075 {
4076 len = rule_len_out;
4077 }
4078 }
4079
4080 if (len < PW_MAX1)
4081 {
4082 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4083 {
4084 cnt += data.kernel_rules_cnt;
4085 }
4086 else if (data.attack_kern == ATTACK_KERN_COMBI)
4087 {
4088 cnt += data.combs_cnt;
4089 }
4090
4091 d.cnt++;
4092 }
4093
4094 i += off;
4095
4096 cnt2++;
4097 }
4098
4099 time (&now);
4100
4101 if ((now - prev) == 0) continue;
4102
4103 float percent = (float) comp / (float) d.stat.st_size;
4104
4105 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);
4106
4107 time (&prev);
4108 }
4109
4110 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);
4111 if (data.quiet == 0) log_info ("");
4112
4113 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4114
4115 hc_signal (sigHandler_default);
4116
4117 return (cnt);
4118 }
4119
4120 static void *thread_monitor (void *p)
4121 {
4122 uint runtime_check = 0;
4123 uint remove_check = 0;
4124 uint status_check = 0;
4125 uint restore_check = 0;
4126
4127 uint restore_left = data.restore_timer;
4128 uint remove_left = data.remove_timer;
4129 uint status_left = data.status_timer;
4130
4131 #ifdef HAVE_HWMON
4132 uint hwmon_check = 0;
4133
4134 int slowdown_warnings = 0;
4135
4136 // these variables are mainly used for fan control
4137
4138 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4139
4140 // temperature controller "loopback" values
4141
4142 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4143 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4144
4145 int temp_threshold = 1; // degrees celcius
4146
4147 int fan_speed_min = 15; // in percentage
4148 int fan_speed_max = 100;
4149
4150 time_t last_temp_check_time;
4151 #endif // HAVE_HWMON
4152
4153 uint sleep_time = 1;
4154
4155 if (data.runtime)
4156 {
4157 runtime_check = 1;
4158 }
4159
4160 if (data.restore_timer)
4161 {
4162 restore_check = 1;
4163 }
4164
4165 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4166 {
4167 remove_check = 1;
4168 }
4169
4170 if (data.status == 1)
4171 {
4172 status_check = 1;
4173 }
4174
4175 #ifdef HAVE_HWMON
4176 if (data.gpu_temp_disable == 0)
4177 {
4178 time (&last_temp_check_time);
4179
4180 hwmon_check = 1;
4181 }
4182 #endif
4183
4184 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4185 {
4186 #ifdef HAVE_HWMON
4187 if (hwmon_check == 0)
4188 #endif
4189 return (p);
4190 }
4191
4192 while (data.shutdown_inner == 0)
4193 {
4194 hc_sleep (sleep_time);
4195
4196 if (data.devices_status != STATUS_RUNNING) continue;
4197
4198 #ifdef HAVE_HWMON
4199
4200 if (hwmon_check == 1)
4201 {
4202 hc_thread_mutex_lock (mux_adl);
4203
4204 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4205 {
4206 hc_device_param_t *device_param = &data.devices_param[device_id];
4207
4208 if (device_param->skipped) continue;
4209
4210 if (device_param->device_vendor_id == VENDOR_ID_NV)
4211 {
4212 if (data.hm_nvapi)
4213 {
4214 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
4215 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4216
4217 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4218 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4219
4220 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4221
4222 perfPolicies_status.info_value = perfPolicies_info.info_value;
4223
4224 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4225
4226 if (perfPolicies_status.throttle & 2)
4227 {
4228 if (slowdown_warnings < 3)
4229 {
4230 if (data.quiet == 0) clear_prompt ();
4231
4232 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4233
4234 if (slowdown_warnings == 2)
4235 {
4236 log_info ("");
4237 }
4238
4239 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4240 if (data.quiet == 0) fflush (stdout);
4241
4242 slowdown_warnings++;
4243 }
4244 }
4245 else
4246 {
4247 slowdown_warnings = 0;
4248 }
4249 }
4250 }
4251 }
4252
4253 hc_thread_mutex_unlock (mux_adl);
4254 }
4255
4256 if (hwmon_check == 1)
4257 {
4258 hc_thread_mutex_lock (mux_adl);
4259
4260 time_t temp_check_time;
4261
4262 time (&temp_check_time);
4263
4264 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4265
4266 if (Ta == 0) Ta = 1;
4267
4268 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4269 {
4270 hc_device_param_t *device_param = &data.devices_param[device_id];
4271
4272 if (device_param->skipped) continue;
4273
4274 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4275
4276 const int temperature = hm_get_temperature_with_device_id (device_id);
4277
4278 if (temperature > (int) data.gpu_temp_abort)
4279 {
4280 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4281
4282 if (data.devices_status != STATUS_QUIT) myabort ();
4283
4284 break;
4285 }
4286
4287 const int gpu_temp_retain = data.gpu_temp_retain;
4288
4289 if (gpu_temp_retain)
4290 {
4291 if (data.hm_device[device_id].fan_set_supported == 1)
4292 {
4293 int temp_cur = temperature;
4294
4295 int temp_diff_new = gpu_temp_retain - temp_cur;
4296
4297 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4298
4299 // calculate Ta value (time difference in seconds between the last check and this check)
4300
4301 last_temp_check_time = temp_check_time;
4302
4303 float Kp = 1.8;
4304 float Ki = 0.005;
4305 float Kd = 6;
4306
4307 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4308
4309 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);
4310
4311 if (abs (fan_diff_required) >= temp_threshold)
4312 {
4313 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4314
4315 int fan_speed_level = fan_speed_cur;
4316
4317 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4318
4319 int fan_speed_new = fan_speed_level - fan_diff_required;
4320
4321 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4322 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4323
4324 if (fan_speed_new != fan_speed_cur)
4325 {
4326 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4327 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4328
4329 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4330 {
4331 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4332 {
4333 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4334 }
4335 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4336 {
4337 #ifdef WIN
4338 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4339 #endif
4340
4341 #ifdef LINUX
4342 hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4343 #endif
4344 }
4345
4346 fan_speed_chgd[device_id] = 1;
4347 }
4348
4349 temp_diff_old[device_id] = temp_diff_new;
4350 }
4351 }
4352 }
4353 }
4354 }
4355
4356 hc_thread_mutex_unlock (mux_adl);
4357 }
4358 #endif // HAVE_HWMON
4359
4360 if (restore_check == 1)
4361 {
4362 restore_left--;
4363
4364 if (restore_left == 0)
4365 {
4366 if (data.restore_disable == 0) cycle_restore ();
4367
4368 restore_left = data.restore_timer;
4369 }
4370 }
4371
4372 if ((runtime_check == 1) && (data.runtime_start > 0))
4373 {
4374 time_t runtime_cur;
4375
4376 time (&runtime_cur);
4377
4378 int runtime_left = data.proc_start + data.runtime - runtime_cur;
4379
4380 if (runtime_left <= 0)
4381 {
4382 if (data.benchmark == 0)
4383 {
4384 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4385 }
4386
4387 if (data.devices_status != STATUS_QUIT) myabort ();
4388 }
4389 }
4390
4391 if (remove_check == 1)
4392 {
4393 remove_left--;
4394
4395 if (remove_left == 0)
4396 {
4397 if (data.digests_saved != data.digests_done)
4398 {
4399 data.digests_saved = data.digests_done;
4400
4401 save_hash ();
4402 }
4403
4404 remove_left = data.remove_timer;
4405 }
4406 }
4407
4408 if (status_check == 1)
4409 {
4410 status_left--;
4411
4412 if (status_left == 0)
4413 {
4414 hc_thread_mutex_lock (mux_display);
4415
4416 if (data.quiet == 0) clear_prompt ();
4417
4418 if (data.quiet == 0) log_info ("");
4419
4420 status_display ();
4421
4422 if (data.quiet == 0) log_info ("");
4423
4424 hc_thread_mutex_unlock (mux_display);
4425
4426 status_left = data.status_timer;
4427 }
4428 }
4429 }
4430
4431 #ifdef HAVE_HWMON
4432 myfree (fan_speed_chgd);
4433
4434 myfree (temp_diff_old);
4435 myfree (temp_diff_sum);
4436 #endif
4437
4438 p = NULL;
4439
4440 return (p);
4441 }
4442
4443 static void *thread_outfile_remove (void *p)
4444 {
4445 // some hash-dependent constants
4446 char *outfile_dir = data.outfile_check_directory;
4447 uint dgst_size = data.dgst_size;
4448 uint isSalted = data.isSalted;
4449 uint esalt_size = data.esalt_size;
4450 uint hash_mode = data.hash_mode;
4451
4452 uint outfile_check_timer = data.outfile_check_timer;
4453
4454 char separator = data.separator;
4455
4456 // some hash-dependent functions
4457 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4458 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4459
4460 // buffers
4461 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4462
4463 hash_buf.digest = mymalloc (dgst_size);
4464
4465 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4466
4467 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4468
4469 uint digest_buf[64] = { 0 };
4470
4471 outfile_data_t *out_info = NULL;
4472
4473 char **out_files = NULL;
4474
4475 time_t folder_mtime = 0;
4476
4477 int out_cnt = 0;
4478
4479 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4480
4481 while (data.shutdown_inner == 0)
4482 {
4483 hc_sleep (1);
4484
4485 if (data.devices_status != STATUS_RUNNING) continue;
4486
4487 check_left--;
4488
4489 if (check_left == 0)
4490 {
4491 struct stat outfile_check_stat;
4492
4493 if (stat (outfile_dir, &outfile_check_stat) == 0)
4494 {
4495 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4496
4497 if (is_dir == 1)
4498 {
4499 if (outfile_check_stat.st_mtime > folder_mtime)
4500 {
4501 char **out_files_new = scan_directory (outfile_dir);
4502
4503 int out_cnt_new = count_dictionaries (out_files_new);
4504
4505 outfile_data_t *out_info_new = NULL;
4506
4507 if (out_cnt_new > 0)
4508 {
4509 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4510
4511 for (int i = 0; i < out_cnt_new; i++)
4512 {
4513 out_info_new[i].file_name = out_files_new[i];
4514
4515 // check if there are files that we have seen/checked before (and not changed)
4516
4517 for (int j = 0; j < out_cnt; j++)
4518 {
4519 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4520 {
4521 struct stat outfile_stat;
4522
4523 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4524 {
4525 if (outfile_stat.st_ctime == out_info[j].ctime)
4526 {
4527 out_info_new[i].ctime = out_info[j].ctime;
4528 out_info_new[i].seek = out_info[j].seek;
4529 }
4530 }
4531 }
4532 }
4533 }
4534 }
4535
4536 local_free (out_info);
4537 local_free (out_files);
4538
4539 out_files = out_files_new;
4540 out_cnt = out_cnt_new;
4541 out_info = out_info_new;
4542
4543 folder_mtime = outfile_check_stat.st_mtime;
4544 }
4545
4546 for (int j = 0; j < out_cnt; j++)
4547 {
4548 FILE *fp = fopen (out_info[j].file_name, "rb");
4549
4550 if (fp != NULL)
4551 {
4552 //hc_thread_mutex_lock (mux_display);
4553
4554 #ifdef _POSIX
4555 struct stat outfile_stat;
4556
4557 fstat (fileno (fp), &outfile_stat);
4558 #endif
4559
4560 #ifdef _WIN
4561 struct stat64 outfile_stat;
4562
4563 _fstat64 (fileno (fp), &outfile_stat);
4564 #endif
4565
4566 if (outfile_stat.st_ctime > out_info[j].ctime)
4567 {
4568 out_info[j].ctime = outfile_stat.st_ctime;
4569 out_info[j].seek = 0;
4570 }
4571
4572 fseek (fp, out_info[j].seek, SEEK_SET);
4573
4574 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4575
4576 while (!feof (fp))
4577 {
4578 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4579
4580 if (ptr == NULL) break;
4581
4582 int line_len = strlen (line_buf);
4583
4584 if (line_len <= 0) continue;
4585
4586 int iter = MAX_CUT_TRIES;
4587
4588 for (uint i = line_len - 1; i && iter; i--, line_len--)
4589 {
4590 if (line_buf[i] != separator) continue;
4591
4592 int parser_status = PARSER_OK;
4593
4594 if ((hash_mode != 2500) && (hash_mode != 6800))
4595 {
4596 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4597 }
4598
4599 uint found = 0;
4600
4601 if (parser_status == PARSER_OK)
4602 {
4603 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4604 {
4605 if (data.salts_shown[salt_pos] == 1) continue;
4606
4607 salt_t *salt_buf = &data.salts_buf[salt_pos];
4608
4609 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4610 {
4611 uint idx = salt_buf->digests_offset + digest_pos;
4612
4613 if (data.digests_shown[idx] == 1) continue;
4614
4615 uint cracked = 0;
4616
4617 if (hash_mode == 6800)
4618 {
4619 if (i == salt_buf->salt_len)
4620 {
4621 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4622 }
4623 }
4624 else if (hash_mode == 2500)
4625 {
4626 // BSSID : MAC1 : MAC2 (:plain)
4627 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4628 {
4629 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4630
4631 if (!cracked) continue;
4632
4633 // now compare MAC1 and MAC2 too, since we have this additional info
4634 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4635 char *mac2_pos = mac1_pos + 12 + 1;
4636
4637 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4638 wpa_t *wpa = &wpas[salt_pos];
4639
4640 // compare hex string(s) vs binary MAC address(es)
4641
4642 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4643 {
4644 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4645 {
4646 cracked = 0;
4647
4648 break;
4649 }
4650 }
4651
4652 // early skip ;)
4653 if (!cracked) continue;
4654
4655 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4656 {
4657 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4658 {
4659 cracked = 0;
4660
4661 break;
4662 }
4663 }
4664 }
4665 }
4666 else
4667 {
4668 char *digests_buf_ptr = (char *) data.digests_buf;
4669
4670 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4671
4672 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4673 }
4674
4675 if (cracked == 1)
4676 {
4677 found = 1;
4678
4679 data.digests_shown[idx] = 1;
4680
4681 data.digests_done++;
4682
4683 salt_buf->digests_done++;
4684
4685 if (salt_buf->digests_done == salt_buf->digests_cnt)
4686 {
4687 data.salts_shown[salt_pos] = 1;
4688
4689 data.salts_done++;
4690
4691 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4692 }
4693 }
4694 }
4695
4696 if (data.devices_status == STATUS_CRACKED) break;
4697 }
4698 }
4699
4700 if (found) break;
4701
4702 if (data.devices_status == STATUS_CRACKED) break;
4703
4704 iter--;
4705 }
4706
4707 if (data.devices_status == STATUS_CRACKED) break;
4708 }
4709
4710 myfree (line_buf);
4711
4712 out_info[j].seek = ftell (fp);
4713
4714 //hc_thread_mutex_unlock (mux_display);
4715
4716 fclose (fp);
4717 }
4718 }
4719 }
4720 }
4721
4722 check_left = outfile_check_timer;
4723 }
4724 }
4725
4726 if (esalt_size) local_free (hash_buf.esalt);
4727
4728 if (isSalted) local_free (hash_buf.salt);
4729
4730 local_free (hash_buf.digest);
4731
4732 local_free (out_info);
4733
4734 local_free (out_files);
4735
4736 p = NULL;
4737
4738 return (p);
4739 }
4740
4741 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4742 {
4743 //if (device_param->pws_cnt < device_param->kernel_power)
4744 //{
4745 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4746
4747 u8 *ptr = (u8 *) pw->i;
4748
4749 memcpy (ptr, pw_buf, pw_len);
4750
4751 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4752
4753 pw->pw_len = pw_len;
4754
4755 device_param->pws_cnt++;
4756 //}
4757 //else
4758 //{
4759 // fprintf (stderr, "BUG pw_add()!!\n");
4760 //
4761 // return;
4762 //}
4763 }
4764
4765 static void set_kernel_power_final (const u64 kernel_power_final)
4766 {
4767 if (data.quiet == 0)
4768 {
4769 clear_prompt ();
4770
4771 //log_info ("");
4772
4773 log_info ("INFO: approaching final keyspace, workload adjusted");
4774 log_info ("");
4775
4776 fprintf (stdout, "%s", PROMPT);
4777
4778 fflush (stdout);
4779 }
4780
4781 data.kernel_power_final = kernel_power_final;
4782 }
4783
4784 static u32 get_power (hc_device_param_t *device_param)
4785 {
4786 const u64 kernel_power_final = data.kernel_power_final;
4787
4788 if (kernel_power_final)
4789 {
4790 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4791
4792 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4793
4794 // work should be at least the hardware power available without any accelerator
4795
4796 const u64 work = MAX (words_left_device, device_param->hardware_power);
4797
4798 return work;
4799 }
4800
4801 return device_param->kernel_power;
4802 }
4803
4804 static uint get_work (hc_device_param_t *device_param, const u64 max)
4805 {
4806 hc_thread_mutex_lock (mux_dispatcher);
4807
4808 const u64 words_cur = data.words_cur;
4809 const u64 words_base = (data.limit == 0) ? data.words_base : MIN (data.limit, data.words_base);
4810
4811 device_param->words_off = words_cur;
4812
4813 const u64 kernel_power_all = data.kernel_power_all;
4814
4815 const u64 words_left = words_base - words_cur;
4816
4817 if (words_left < kernel_power_all)
4818 {
4819 if (data.kernel_power_final == 0)
4820 {
4821 set_kernel_power_final (words_left);
4822 }
4823 }
4824
4825 const u32 kernel_power = get_power (device_param);
4826
4827 uint work = MIN (words_left, kernel_power);
4828
4829 work = MIN (work, max);
4830
4831 data.words_cur += work;
4832
4833 hc_thread_mutex_unlock (mux_dispatcher);
4834
4835 return work;
4836 }
4837
4838 static void *thread_autotune (void *p)
4839 {
4840 hc_device_param_t *device_param = (hc_device_param_t *) p;
4841
4842 if (device_param->skipped) return NULL;
4843
4844 autotune (device_param);
4845
4846 return NULL;
4847 }
4848
4849 static void *thread_calc_stdin (void *p)
4850 {
4851 hc_device_param_t *device_param = (hc_device_param_t *) p;
4852
4853 if (device_param->skipped) return NULL;
4854
4855 char *buf = (char *) mymalloc (HCBUFSIZ);
4856
4857 const uint attack_kern = data.attack_kern;
4858
4859 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4860 {
4861 hc_thread_mutex_lock (mux_dispatcher);
4862
4863 if (feof (stdin) != 0)
4864 {
4865 hc_thread_mutex_unlock (mux_dispatcher);
4866
4867 break;
4868 }
4869
4870 uint words_cur = 0;
4871
4872 while (words_cur < device_param->kernel_power)
4873 {
4874 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4875
4876 if (line_buf == NULL) break;
4877
4878 uint line_len = in_superchop (line_buf);
4879
4880 line_len = convert_from_hex (line_buf, line_len);
4881
4882 // post-process rule engine
4883
4884 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4885 {
4886 char rule_buf_out[BLOCK_SIZE] = { 0 };
4887
4888 int rule_len_out = -1;
4889
4890 if (line_len < BLOCK_SIZE)
4891 {
4892 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4893 }
4894
4895 if (rule_len_out < 0) continue;
4896
4897 line_buf = rule_buf_out;
4898 line_len = rule_len_out;
4899 }
4900
4901 if (line_len > PW_MAX)
4902 {
4903 continue;
4904 }
4905
4906 // hmm that's always the case, or?
4907
4908 if (attack_kern == ATTACK_KERN_STRAIGHT)
4909 {
4910 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4911 {
4912 hc_thread_mutex_lock (mux_counter);
4913
4914 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4915 {
4916 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4917 }
4918
4919 hc_thread_mutex_unlock (mux_counter);
4920
4921 continue;
4922 }
4923 }
4924
4925 pw_add (device_param, (u8 *) line_buf, line_len);
4926
4927 words_cur++;
4928
4929 if (data.devices_status == STATUS_CRACKED) break;
4930 if (data.devices_status == STATUS_ABORTED) break;
4931 if (data.devices_status == STATUS_QUIT) break;
4932 if (data.devices_status == STATUS_BYPASS) break;
4933 }
4934
4935 hc_thread_mutex_unlock (mux_dispatcher);
4936
4937 if (data.devices_status == STATUS_CRACKED) break;
4938 if (data.devices_status == STATUS_ABORTED) break;
4939 if (data.devices_status == STATUS_QUIT) break;
4940 if (data.devices_status == STATUS_BYPASS) break;
4941
4942 // flush
4943
4944 const uint pws_cnt = device_param->pws_cnt;
4945
4946 if (pws_cnt)
4947 {
4948 run_copy (device_param, pws_cnt);
4949
4950 run_cracker (device_param, pws_cnt);
4951
4952 device_param->pws_cnt = 0;
4953
4954 /*
4955 still required?
4956 if (attack_kern == ATTACK_KERN_STRAIGHT)
4957 {
4958 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4959 }
4960 else if (attack_kern == ATTACK_KERN_COMBI)
4961 {
4962 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4963 }
4964 */
4965 }
4966 }
4967
4968 device_param->kernel_accel = 0;
4969 device_param->kernel_loops = 0;
4970
4971 myfree (buf);
4972
4973 return NULL;
4974 }
4975
4976 static void *thread_calc (void *p)
4977 {
4978 hc_device_param_t *device_param = (hc_device_param_t *) p;
4979
4980 if (device_param->skipped) return NULL;
4981
4982 const uint attack_mode = data.attack_mode;
4983 const uint attack_kern = data.attack_kern;
4984
4985 if (attack_mode == ATTACK_MODE_BF)
4986 {
4987 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4988 {
4989 const uint work = get_work (device_param, -1);
4990
4991 if (work == 0) break;
4992
4993 const u64 words_off = device_param->words_off;
4994 const u64 words_fin = words_off + work;
4995
4996 const uint pws_cnt = work;
4997
4998 device_param->pws_cnt = pws_cnt;
4999
5000 if (pws_cnt)
5001 {
5002 run_copy (device_param, pws_cnt);
5003
5004 run_cracker (device_param, pws_cnt);
5005
5006 device_param->pws_cnt = 0;
5007
5008 /*
5009 still required?
5010 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
5011 */
5012 }
5013
5014 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5015
5016 if (data.devices_status == STATUS_CRACKED) break;
5017 if (data.devices_status == STATUS_ABORTED) break;
5018 if (data.devices_status == STATUS_QUIT) break;
5019 if (data.devices_status == STATUS_BYPASS) break;
5020
5021 if (data.benchmark == 1) break;
5022
5023 device_param->words_done = words_fin;
5024 }
5025 }
5026 else
5027 {
5028 const uint segment_size = data.segment_size;
5029
5030 char *dictfile = data.dictfile;
5031
5032 if (attack_mode == ATTACK_MODE_COMBI)
5033 {
5034 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5035 {
5036 dictfile = data.dictfile2;
5037 }
5038 }
5039
5040 FILE *fd = fopen (dictfile, "rb");
5041
5042 if (fd == NULL)
5043 {
5044 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
5045
5046 return NULL;
5047 }
5048
5049 if (attack_mode == ATTACK_MODE_COMBI)
5050 {
5051 const uint combs_mode = data.combs_mode;
5052
5053 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
5054 {
5055 const char *dictfilec = data.dictfile2;
5056
5057 FILE *combs_fp = fopen (dictfilec, "rb");
5058
5059 if (combs_fp == NULL)
5060 {
5061 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5062
5063 fclose (fd);
5064
5065 return NULL;
5066 }
5067
5068 device_param->combs_fp = combs_fp;
5069 }
5070 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5071 {
5072 const char *dictfilec = data.dictfile;
5073
5074 FILE *combs_fp = fopen (dictfilec, "rb");
5075
5076 if (combs_fp == NULL)
5077 {
5078 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5079
5080 fclose (fd);
5081
5082 return NULL;
5083 }
5084
5085 device_param->combs_fp = combs_fp;
5086 }
5087 }
5088
5089 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5090
5091 wl_data->buf = (char *) mymalloc (segment_size);
5092 wl_data->avail = segment_size;
5093 wl_data->incr = segment_size;
5094 wl_data->cnt = 0;
5095 wl_data->pos = 0;
5096
5097 u64 words_cur = 0;
5098
5099 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5100 {
5101 u64 words_off = 0;
5102 u64 words_fin = 0;
5103
5104 u64 max = -1;
5105
5106 while (max)
5107 {
5108 const uint work = get_work (device_param, max);
5109
5110 if (work == 0) break;
5111
5112 max = 0;
5113
5114 words_off = device_param->words_off;
5115 words_fin = words_off + work;
5116
5117 char *line_buf;
5118 uint line_len;
5119
5120 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5121
5122 for ( ; words_cur < words_fin; words_cur++)
5123 {
5124 get_next_word (wl_data, fd, &line_buf, &line_len);
5125
5126 line_len = convert_from_hex (line_buf, line_len);
5127
5128 // post-process rule engine
5129
5130 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5131 {
5132 char rule_buf_out[BLOCK_SIZE] = { 0 };
5133
5134 int rule_len_out = -1;
5135
5136 if (line_len < BLOCK_SIZE)
5137 {
5138 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5139 }
5140
5141 if (rule_len_out < 0) continue;
5142
5143 line_buf = rule_buf_out;
5144 line_len = rule_len_out;
5145 }
5146
5147 if (attack_kern == ATTACK_KERN_STRAIGHT)
5148 {
5149 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5150 {
5151 max++;
5152
5153 hc_thread_mutex_lock (mux_counter);
5154
5155 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5156 {
5157 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5158 }
5159
5160 hc_thread_mutex_unlock (mux_counter);
5161
5162 continue;
5163 }
5164 }
5165 else if (attack_kern == ATTACK_KERN_COMBI)
5166 {
5167 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5168 // since we still need to combine the plains
5169
5170 if (line_len > data.pw_max)
5171 {
5172 max++;
5173
5174 hc_thread_mutex_lock (mux_counter);
5175
5176 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5177 {
5178 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5179 }
5180
5181 hc_thread_mutex_unlock (mux_counter);
5182
5183 continue;
5184 }
5185 }
5186
5187 pw_add (device_param, (u8 *) line_buf, line_len);
5188
5189 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5190
5191 if (data.devices_status == STATUS_CRACKED) break;
5192 if (data.devices_status == STATUS_ABORTED) break;
5193 if (data.devices_status == STATUS_QUIT) break;
5194 if (data.devices_status == STATUS_BYPASS) break;
5195 }
5196
5197 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5198
5199 if (data.devices_status == STATUS_CRACKED) break;
5200 if (data.devices_status == STATUS_ABORTED) break;
5201 if (data.devices_status == STATUS_QUIT) break;
5202 if (data.devices_status == STATUS_BYPASS) break;
5203 }
5204
5205 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5206
5207 if (data.devices_status == STATUS_CRACKED) break;
5208 if (data.devices_status == STATUS_ABORTED) break;
5209 if (data.devices_status == STATUS_QUIT) break;
5210 if (data.devices_status == STATUS_BYPASS) break;
5211
5212 //
5213 // flush
5214 //
5215
5216 const uint pws_cnt = device_param->pws_cnt;
5217
5218 if (pws_cnt)
5219 {
5220 run_copy (device_param, pws_cnt);
5221
5222 run_cracker (device_param, pws_cnt);
5223
5224 device_param->pws_cnt = 0;
5225
5226 /*
5227 still required?
5228 if (attack_kern == ATTACK_KERN_STRAIGHT)
5229 {
5230 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5231 }
5232 else if (attack_kern == ATTACK_KERN_COMBI)
5233 {
5234 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5235 }
5236 */
5237 }
5238
5239 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5240
5241 if (data.devices_status == STATUS_CRACKED) break;
5242 if (data.devices_status == STATUS_ABORTED) break;
5243 if (data.devices_status == STATUS_QUIT) break;
5244 if (data.devices_status == STATUS_BYPASS) break;
5245
5246 if (words_fin == 0) break;
5247
5248 device_param->words_done = words_fin;
5249 }
5250
5251 if (attack_mode == ATTACK_MODE_COMBI)
5252 {
5253 fclose (device_param->combs_fp);
5254 }
5255
5256 free (wl_data->buf);
5257 free (wl_data);
5258
5259 fclose (fd);
5260 }
5261
5262 device_param->kernel_accel = 0;
5263 device_param->kernel_loops = 0;
5264
5265 return NULL;
5266 }
5267
5268 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5269 {
5270 if (!device_param)
5271 {
5272 log_error ("ERROR: %s : Invalid argument", __func__);
5273
5274 exit (-1);
5275 }
5276
5277 salt_t *salt_buf = &data.salts_buf[salt_pos];
5278
5279 device_param->kernel_params_buf32[27] = salt_pos;
5280 device_param->kernel_params_buf32[30] = 1;
5281 device_param->kernel_params_buf32[31] = salt_buf->digests_cnt;
5282 device_param->kernel_params_buf32[32] = salt_buf->digests_offset;
5283 device_param->kernel_params_buf32[33] = 0;
5284 device_param->kernel_params_buf32[34] = 1;
5285
5286 char *dictfile_old = data.dictfile;
5287
5288 const char *weak_hash_check = "weak-hash-check";
5289
5290 data.dictfile = (char *) weak_hash_check;
5291
5292 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5293
5294 data.kernel_rules_buf[0].cmds[0] = 0;
5295
5296 /**
5297 * run the kernel
5298 */
5299
5300 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5301 {
5302 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5303 }
5304 else
5305 {
5306 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5307
5308 uint loop_step = 16;
5309
5310 const uint iter = salt_buf->salt_iter;
5311
5312 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5313 {
5314 uint loop_left = iter - loop_pos;
5315
5316 loop_left = MIN (loop_left, loop_step);
5317
5318 device_param->kernel_params_buf32[28] = loop_pos;
5319 device_param->kernel_params_buf32[29] = loop_left;
5320
5321 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5322 }
5323
5324 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5325 }
5326
5327 /**
5328 * result
5329 */
5330
5331 check_cracked (device_param, salt_pos);
5332
5333 /**
5334 * cleanup
5335 */
5336
5337 device_param->kernel_params_buf32[27] = 0;
5338 device_param->kernel_params_buf32[28] = 0;
5339 device_param->kernel_params_buf32[29] = 0;
5340 device_param->kernel_params_buf32[30] = 0;
5341 device_param->kernel_params_buf32[31] = 0;
5342 device_param->kernel_params_buf32[32] = 0;
5343 device_param->kernel_params_buf32[33] = 0;
5344 device_param->kernel_params_buf32[34] = 0;
5345
5346 data.dictfile = dictfile_old;
5347
5348 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5349 }
5350
5351 // hlfmt hashcat
5352
5353 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5354 {
5355 if (data.username == 0)
5356 {
5357 *hashbuf_pos = line_buf;
5358 *hashbuf_len = line_len;
5359 }
5360 else
5361 {
5362 char *pos = line_buf;
5363 int len = line_len;
5364
5365 for (int i = 0; i < line_len; i++, pos++, len--)
5366 {
5367 if (line_buf[i] == data.separator)
5368 {
5369 pos++;
5370
5371 len--;
5372
5373 break;
5374 }
5375 }
5376
5377 *hashbuf_pos = pos;
5378 *hashbuf_len = len;
5379 }
5380 }
5381
5382 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5383 {
5384 char *pos = NULL;
5385 int len = 0;
5386
5387 int sep_cnt = 0;
5388
5389 for (int i = 0; i < line_len; i++)
5390 {
5391 if (line_buf[i] == data.separator)
5392 {
5393 sep_cnt++;
5394
5395 continue;
5396 }
5397
5398 if (sep_cnt == 0)
5399 {
5400 if (pos == NULL) pos = line_buf + i;
5401
5402 len++;
5403 }
5404 }
5405
5406 *userbuf_pos = pos;
5407 *userbuf_len = len;
5408 }
5409
5410 // hlfmt pwdump
5411
5412 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5413 {
5414 int sep_cnt = 0;
5415
5416 int sep2_len = 0;
5417 int sep3_len = 0;
5418
5419 for (int i = 0; i < line_len; i++)
5420 {
5421 if (line_buf[i] == ':')
5422 {
5423 sep_cnt++;
5424
5425 continue;
5426 }
5427
5428 if (sep_cnt == 2) sep2_len++;
5429 if (sep_cnt == 3) sep3_len++;
5430 }
5431
5432 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5433
5434 return 0;
5435 }
5436
5437 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5438 {
5439 char *pos = NULL;
5440 int len = 0;
5441
5442 int sep_cnt = 0;
5443
5444 for (int i = 0; i < line_len; i++)
5445 {
5446 if (line_buf[i] == ':')
5447 {
5448 sep_cnt++;
5449
5450 continue;
5451 }
5452
5453 if (data.hash_mode == 1000)
5454 {
5455 if (sep_cnt == 3)
5456 {
5457 if (pos == NULL) pos = line_buf + i;
5458
5459 len++;
5460 }
5461 }
5462 else if (data.hash_mode == 3000)
5463 {
5464 if (sep_cnt == 2)
5465 {
5466 if (pos == NULL) pos = line_buf + i;
5467
5468 len++;
5469 }
5470 }
5471 }
5472
5473 *hashbuf_pos = pos;
5474 *hashbuf_len = len;
5475 }
5476
5477 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5478 {
5479 char *pos = NULL;
5480 int len = 0;
5481
5482 int sep_cnt = 0;
5483
5484 for (int i = 0; i < line_len; i++)
5485 {
5486 if (line_buf[i] == ':')
5487 {
5488 sep_cnt++;
5489
5490 continue;
5491 }
5492
5493 if (sep_cnt == 0)
5494 {
5495 if (pos == NULL) pos = line_buf + i;
5496
5497 len++;
5498 }
5499 }
5500
5501 *userbuf_pos = pos;
5502 *userbuf_len = len;
5503 }
5504
5505 // hlfmt passwd
5506
5507 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5508 {
5509 int sep_cnt = 0;
5510
5511 char sep5_first = 0;
5512 char sep6_first = 0;
5513
5514 for (int i = 0; i < line_len; i++)
5515 {
5516 if (line_buf[i] == ':')
5517 {
5518 sep_cnt++;
5519
5520 continue;
5521 }
5522
5523 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5524 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5525 }
5526
5527 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5528
5529 return 0;
5530 }
5531
5532 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5533 {
5534 char *pos = NULL;
5535 int len = 0;
5536
5537 int sep_cnt = 0;
5538
5539 for (int i = 0; i < line_len; i++)
5540 {
5541 if (line_buf[i] == ':')
5542 {
5543 sep_cnt++;
5544
5545 continue;
5546 }
5547
5548 if (sep_cnt == 1)
5549 {
5550 if (pos == NULL) pos = line_buf + i;
5551
5552 len++;
5553 }
5554 }
5555
5556 *hashbuf_pos = pos;
5557 *hashbuf_len = len;
5558 }
5559
5560 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5561 {
5562 char *pos = NULL;
5563 int len = 0;
5564
5565 int sep_cnt = 0;
5566
5567 for (int i = 0; i < line_len; i++)
5568 {
5569 if (line_buf[i] == ':')
5570 {
5571 sep_cnt++;
5572
5573 continue;
5574 }
5575
5576 if (sep_cnt == 0)
5577 {
5578 if (pos == NULL) pos = line_buf + i;
5579
5580 len++;
5581 }
5582 }
5583
5584 *userbuf_pos = pos;
5585 *userbuf_len = len;
5586 }
5587
5588 // hlfmt shadow
5589
5590 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5591 {
5592 int sep_cnt = 0;
5593
5594 for (int i = 0; i < line_len; i++)
5595 {
5596 if (line_buf[i] == ':') sep_cnt++;
5597 }
5598
5599 if (sep_cnt == 8) return 1;
5600
5601 return 0;
5602 }
5603
5604 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5605 {
5606 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5607 }
5608
5609 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5610 {
5611 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5612 }
5613
5614 // hlfmt main
5615
5616 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5617 {
5618 switch (hashfile_format)
5619 {
5620 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5621 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5622 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5623 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5624 }
5625 }
5626
5627 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5628 {
5629 switch (hashfile_format)
5630 {
5631 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5632 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5633 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5634 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5635 }
5636 }
5637
5638 char *strhlfmt (const uint hashfile_format)
5639 {
5640 switch (hashfile_format)
5641 {
5642 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5643 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5644 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5645 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5646 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5647 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5648 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5649 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5650 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5651 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5652 }
5653
5654 return ((char *) "Unknown");
5655 }
5656
5657 static uint hlfmt_detect (FILE *fp, uint max_check)
5658 {
5659 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5660
5661 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5662 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5663
5664 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5665
5666 uint num_check = 0;
5667
5668 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5669
5670 while (!feof (fp))
5671 {
5672 int line_len = fgetl (fp, line_buf);
5673
5674 if (line_len == 0) continue;
5675
5676 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5677 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5678 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5679
5680 if (num_check == max_check) break;
5681
5682 num_check++;
5683 }
5684
5685 myfree (line_buf);
5686
5687 uint hashlist_format = HLFMT_HASHCAT;
5688
5689 for (int i = 1; i < HLFMTS_CNT; i++)
5690 {
5691 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5692
5693 hashlist_format = i;
5694 }
5695
5696 free (formats_cnt);
5697
5698 return hashlist_format;
5699 }
5700
5701 /**
5702 * some further helper function
5703 */
5704
5705 // wrapper around mymalloc for ADL
5706
5707 #if defined(HAVE_HWMON)
5708 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5709 {
5710 return mymalloc (iSize);
5711 }
5712 #endif
5713
5714 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)
5715 {
5716 u64 collisions = 0;
5717
5718 const uint dgst_pos0 = data.dgst_pos0;
5719 const uint dgst_pos1 = data.dgst_pos1;
5720 const uint dgst_pos2 = data.dgst_pos2;
5721 const uint dgst_pos3 = data.dgst_pos3;
5722
5723 memset (bitmap_a, 0, bitmap_size);
5724 memset (bitmap_b, 0, bitmap_size);
5725 memset (bitmap_c, 0, bitmap_size);
5726 memset (bitmap_d, 0, bitmap_size);
5727
5728 for (uint i = 0; i < digests_cnt; i++)
5729 {
5730 uint *digest_ptr = (uint *) digests_buf_ptr;
5731
5732 digests_buf_ptr += dgst_size;
5733
5734 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5735 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5736 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5737 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5738
5739 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5740 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5741 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5742 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5743
5744 if (bitmap_a[idx0] & val0) collisions++;
5745 if (bitmap_b[idx1] & val1) collisions++;
5746 if (bitmap_c[idx2] & val2) collisions++;
5747 if (bitmap_d[idx3] & val3) collisions++;
5748
5749 bitmap_a[idx0] |= val0;
5750 bitmap_b[idx1] |= val1;
5751 bitmap_c[idx2] |= val2;
5752 bitmap_d[idx3] |= val3;
5753
5754 if (collisions >= collisions_max) return 0x7fffffff;
5755 }
5756
5757 return collisions;
5758 }
5759
5760 /**
5761 * main
5762 */
5763
5764 #ifdef WIN
5765 void SetConsoleWindowSize (const int x)
5766 {
5767 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5768
5769 if (h == INVALID_HANDLE_VALUE) return;
5770
5771 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5772
5773 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5774
5775 SMALL_RECT *sr = &bufferInfo.srWindow;
5776
5777 sr->Right = MAX (sr->Right, x - 1);
5778
5779 COORD co;
5780
5781 co.X = sr->Right + 1;
5782 co.Y = 9999;
5783
5784 if (!SetConsoleScreenBufferSize (h, co)) return;
5785
5786 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5787 }
5788 #endif
5789
5790 int main (int argc, char **argv)
5791 {
5792 #ifdef WIN
5793 SetConsoleWindowSize (132);
5794 #endif
5795
5796 /**
5797 * To help users a bit
5798 */
5799
5800 char *compute = getenv ("COMPUTE");
5801
5802 if (compute)
5803 {
5804 static char display[100];
5805
5806 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5807
5808 putenv (display);
5809 }
5810 else
5811 {
5812 if (getenv ("DISPLAY") == NULL)
5813 putenv ((char *) "DISPLAY=:0");
5814 }
5815
5816 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5817 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5818
5819 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5820 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5821
5822 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5823 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5824
5825 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5826 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5827
5828 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5829 putenv ((char *) "POCL_KERNEL_CACHE=0");
5830
5831 umask (077);
5832
5833 /**
5834 * Real init
5835 */
5836
5837 memset (&data, 0, sizeof (hc_global_data_t));
5838
5839 time_t proc_start;
5840
5841 time (&proc_start);
5842
5843 data.proc_start = proc_start;
5844
5845 int myargc = argc;
5846 char **myargv = argv;
5847
5848 hc_thread_mutex_init (mux_dispatcher);
5849 hc_thread_mutex_init (mux_counter);
5850 hc_thread_mutex_init (mux_display);
5851 hc_thread_mutex_init (mux_adl);
5852
5853 /**
5854 * commandline parameters
5855 */
5856
5857 uint usage = USAGE;
5858 uint version = VERSION;
5859 uint quiet = QUIET;
5860 uint benchmark = BENCHMARK;
5861 uint stdout_flag = STDOUT_FLAG;
5862 uint show = SHOW;
5863 uint left = LEFT;
5864 uint username = USERNAME;
5865 uint remove = REMOVE;
5866 uint remove_timer = REMOVE_TIMER;
5867 u64 skip = SKIP;
5868 u64 limit = LIMIT;
5869 uint keyspace = KEYSPACE;
5870 uint potfile_disable = POTFILE_DISABLE;
5871 char *potfile_path = NULL;
5872 uint debug_mode = DEBUG_MODE;
5873 char *debug_file = NULL;
5874 char *induction_dir = NULL;
5875 char *outfile_check_dir = NULL;
5876 uint force = FORCE;
5877 uint runtime = RUNTIME;
5878 uint hash_mode = HASH_MODE;
5879 uint attack_mode = ATTACK_MODE;
5880 uint markov_disable = MARKOV_DISABLE;
5881 uint markov_classic = MARKOV_CLASSIC;
5882 uint markov_threshold = MARKOV_THRESHOLD;
5883 char *markov_hcstat = NULL;
5884 char *outfile = NULL;
5885 uint outfile_format = OUTFILE_FORMAT;
5886 uint outfile_autohex = OUTFILE_AUTOHEX;
5887 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5888 uint restore = RESTORE;
5889 uint restore_timer = RESTORE_TIMER;
5890 uint restore_disable = RESTORE_DISABLE;
5891 uint status = STATUS;
5892 uint status_timer = STATUS_TIMER;
5893 uint machine_readable = MACHINE_READABLE;
5894 uint loopback = LOOPBACK;
5895 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5896 char *session = NULL;
5897 uint hex_charset = HEX_CHARSET;
5898 uint hex_salt = HEX_SALT;
5899 uint hex_wordlist = HEX_WORDLIST;
5900 uint rp_gen = RP_GEN;
5901 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5902 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5903 uint rp_gen_seed = RP_GEN_SEED;
5904 char *rule_buf_l = (char *) RULE_BUF_L;
5905 char *rule_buf_r = (char *) RULE_BUF_R;
5906 uint increment = INCREMENT;
5907 uint increment_min = INCREMENT_MIN;
5908 uint increment_max = INCREMENT_MAX;
5909 char *cpu_affinity = NULL;
5910 OCL_PTR *ocl = NULL;
5911 char *opencl_devices = NULL;
5912 char *opencl_platforms = NULL;
5913 char *opencl_device_types = NULL;
5914 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5915 char *truecrypt_keyfiles = NULL;
5916 char *veracrypt_keyfiles = NULL;
5917 uint veracrypt_pim = 0;
5918 uint workload_profile = WORKLOAD_PROFILE;
5919 uint kernel_accel = KERNEL_ACCEL;
5920 uint kernel_loops = KERNEL_LOOPS;
5921 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
5922 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5923 #ifdef HAVE_HWMON
5924 uint gpu_temp_abort = GPU_TEMP_ABORT;
5925 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5926 uint powertune_enable = POWERTUNE_ENABLE;
5927 #endif
5928 uint logfile_disable = LOGFILE_DISABLE;
5929 uint segment_size = SEGMENT_SIZE;
5930 uint scrypt_tmto = SCRYPT_TMTO;
5931 char separator = SEPARATOR;
5932 uint bitmap_min = BITMAP_MIN;
5933 uint bitmap_max = BITMAP_MAX;
5934 char *custom_charset_1 = NULL;
5935 char *custom_charset_2 = NULL;
5936 char *custom_charset_3 = NULL;
5937 char *custom_charset_4 = NULL;
5938
5939 #define IDX_HELP 'h'
5940 #define IDX_VERSION 'V'
5941 #define IDX_VERSION_LOWER 'v'
5942 #define IDX_QUIET 0xff02
5943 #define IDX_SHOW 0xff03
5944 #define IDX_LEFT 0xff04
5945 #define IDX_REMOVE 0xff05
5946 #define IDX_REMOVE_TIMER 0xff37
5947 #define IDX_SKIP 's'
5948 #define IDX_LIMIT 'l'
5949 #define IDX_KEYSPACE 0xff35
5950 #define IDX_POTFILE_DISABLE 0xff06
5951 #define IDX_POTFILE_PATH 0xffe0
5952 #define IDX_DEBUG_MODE 0xff43
5953 #define IDX_DEBUG_FILE 0xff44
5954 #define IDX_INDUCTION_DIR 0xff46
5955 #define IDX_OUTFILE_CHECK_DIR 0xff47
5956 #define IDX_USERNAME 0xff07
5957 #define IDX_FORCE 0xff08
5958 #define IDX_RUNTIME 0xff09
5959 #define IDX_BENCHMARK 'b'
5960 #define IDX_STDOUT_FLAG 0xff77
5961 #define IDX_HASH_MODE 'm'
5962 #define IDX_ATTACK_MODE 'a'
5963 #define IDX_RP_FILE 'r'
5964 #define IDX_RP_GEN 'g'
5965 #define IDX_RP_GEN_FUNC_MIN 0xff10
5966 #define IDX_RP_GEN_FUNC_MAX 0xff11
5967 #define IDX_RP_GEN_SEED 0xff34
5968 #define IDX_RULE_BUF_L 'j'
5969 #define IDX_RULE_BUF_R 'k'
5970 #define IDX_INCREMENT 'i'
5971 #define IDX_INCREMENT_MIN 0xff12
5972 #define IDX_INCREMENT_MAX 0xff13
5973 #define IDX_OUTFILE 'o'
5974 #define IDX_OUTFILE_FORMAT 0xff14
5975 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5976 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5977 #define IDX_RESTORE 0xff15
5978 #define IDX_RESTORE_DISABLE 0xff27
5979 #define IDX_STATUS 0xff17
5980 #define IDX_STATUS_TIMER 0xff18
5981 #define IDX_MACHINE_READABLE 0xff50
5982 #define IDX_LOOPBACK 0xff38
5983 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5984 #define IDX_SESSION 0xff19
5985 #define IDX_HEX_CHARSET 0xff20
5986 #define IDX_HEX_SALT 0xff21
5987 #define IDX_HEX_WORDLIST 0xff40
5988 #define IDX_MARKOV_DISABLE 0xff22
5989 #define IDX_MARKOV_CLASSIC 0xff23
5990 #define IDX_MARKOV_THRESHOLD 't'
5991 #define IDX_MARKOV_HCSTAT 0xff24
5992 #define IDX_CPU_AFFINITY 0xff25
5993 #define IDX_OPENCL_DEVICES 'd'
5994 #define IDX_OPENCL_PLATFORMS 0xff72
5995 #define IDX_OPENCL_DEVICE_TYPES 'D'
5996 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5997 #define IDX_WORKLOAD_PROFILE 'w'
5998 #define IDX_KERNEL_ACCEL 'n'
5999 #define IDX_KERNEL_LOOPS 'u'
6000 #define IDX_NVIDIA_SPIN_DAMP 0xff79
6001 #define IDX_GPU_TEMP_DISABLE 0xff29
6002 #define IDX_GPU_TEMP_ABORT 0xff30
6003 #define IDX_GPU_TEMP_RETAIN 0xff31
6004 #define IDX_POWERTUNE_ENABLE 0xff41
6005 #define IDX_LOGFILE_DISABLE 0xff51
6006 #define IDX_TRUECRYPT_KEYFILES 0xff52
6007 #define IDX_VERACRYPT_KEYFILES 0xff53
6008 #define IDX_VERACRYPT_PIM 0xff54
6009 #define IDX_SCRYPT_TMTO 0xff61
6010 #define IDX_SEGMENT_SIZE 'c'
6011 #define IDX_SEPARATOR 'p'
6012 #define IDX_BITMAP_MIN 0xff70
6013 #define IDX_BITMAP_MAX 0xff71
6014 #define IDX_CUSTOM_CHARSET_1 '1'
6015 #define IDX_CUSTOM_CHARSET_2 '2'
6016 #define IDX_CUSTOM_CHARSET_3 '3'
6017 #define IDX_CUSTOM_CHARSET_4 '4'
6018
6019 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:D:n:u:c:p:s:l:1:2:3:4:ibw:";
6020
6021 struct option long_options[] =
6022 {
6023 {"help", no_argument, 0, IDX_HELP},
6024 {"version", no_argument, 0, IDX_VERSION},
6025 {"quiet", no_argument, 0, IDX_QUIET},
6026 {"show", no_argument, 0, IDX_SHOW},
6027 {"left", no_argument, 0, IDX_LEFT},
6028 {"username", no_argument, 0, IDX_USERNAME},
6029 {"remove", no_argument, 0, IDX_REMOVE},
6030 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
6031 {"skip", required_argument, 0, IDX_SKIP},
6032 {"limit", required_argument, 0, IDX_LIMIT},
6033 {"keyspace", no_argument, 0, IDX_KEYSPACE},
6034 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
6035 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
6036 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
6037 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
6038 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
6039 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
6040 {"force", no_argument, 0, IDX_FORCE},
6041 {"benchmark", no_argument, 0, IDX_BENCHMARK},
6042 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
6043 {"restore", no_argument, 0, IDX_RESTORE},
6044 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
6045 {"status", no_argument, 0, IDX_STATUS},
6046 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
6047 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
6048 {"loopback", no_argument, 0, IDX_LOOPBACK},
6049 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
6050 {"session", required_argument, 0, IDX_SESSION},
6051 {"runtime", required_argument, 0, IDX_RUNTIME},
6052 {"generate-rules", required_argument, 0, IDX_RP_GEN},
6053 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
6054 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
6055 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
6056 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
6057 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
6058 {"hash-type", required_argument, 0, IDX_HASH_MODE},
6059 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
6060 {"rules-file", required_argument, 0, IDX_RP_FILE},
6061 {"outfile", required_argument, 0, IDX_OUTFILE},
6062 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
6063 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
6064 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
6065 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
6066 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
6067 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
6068 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
6069 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
6070 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
6071 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
6072 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
6073 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
6074 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
6075 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
6076 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
6077 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
6078 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
6079 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
6080 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6081 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
6082 #ifdef HAVE_HWMON
6083 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
6084 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
6085 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
6086 #endif // HAVE_HWMON
6087 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
6088 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6089 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
6090 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
6091 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
6092 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
6093 {"seperator", required_argument, 0, IDX_SEPARATOR},
6094 {"separator", required_argument, 0, IDX_SEPARATOR},
6095 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
6096 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
6097 {"increment", no_argument, 0, IDX_INCREMENT},
6098 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
6099 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
6100 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
6101 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
6102 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6103 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6104 {0, 0, 0, 0}
6105 };
6106
6107 uint rp_files_cnt = 0;
6108
6109 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6110
6111 int option_index = 0;
6112 int c = -1;
6113
6114 optind = 1;
6115 optopt = 0;
6116
6117 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6118 {
6119 switch (c)
6120 {
6121 case IDX_HELP: usage = 1; break;
6122 case IDX_VERSION:
6123 case IDX_VERSION_LOWER: version = 1; break;
6124 case IDX_RESTORE: restore = 1; break;
6125 case IDX_SESSION: session = optarg; break;
6126 case IDX_SHOW: show = 1; break;
6127 case IDX_LEFT: left = 1; break;
6128 case '?': return (-1);
6129 }
6130 }
6131
6132 if (optopt != 0)
6133 {
6134 log_error ("ERROR: Invalid argument specified");
6135
6136 return (-1);
6137 }
6138
6139 /**
6140 * exit functions
6141 */
6142
6143 if (version)
6144 {
6145 log_info ("%s", VERSION_TAG);
6146
6147 return (0);
6148 }
6149
6150 if (usage)
6151 {
6152 usage_big_print (PROGNAME);
6153
6154 return (0);
6155 }
6156
6157 /**
6158 * session needs to be set, always!
6159 */
6160
6161 if (session == NULL) session = (char *) PROGNAME;
6162
6163 /**
6164 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6165 */
6166
6167 char *exec_path = get_exec_path ();
6168
6169 #ifdef LINUX
6170
6171 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6172 char *resolved_exec_path = realpath (exec_path, NULL);
6173
6174 if (resolved_install_folder == NULL)
6175 {
6176 log_error ("ERROR: %s: %s", resolved_install_folder, strerror (errno));
6177
6178 return (-1);
6179 }
6180
6181 if (resolved_exec_path == NULL)
6182 {
6183 log_error ("ERROR: %s: %s", resolved_exec_path, strerror (errno));
6184
6185 return (-1);
6186 }
6187
6188 char *install_dir = get_install_dir (resolved_exec_path);
6189 char *profile_dir = NULL;
6190 char *session_dir = NULL;
6191 char *shared_dir = NULL;
6192
6193 if (strcmp (install_dir, resolved_install_folder) == 0)
6194 {
6195 struct passwd *pw = getpwuid (getuid ());
6196
6197 const char *homedir = pw->pw_dir;
6198
6199 profile_dir = get_profile_dir (homedir);
6200 session_dir = get_session_dir (profile_dir);
6201 shared_dir = strdup (SHARED_FOLDER);
6202
6203 mkdir (profile_dir, 0700);
6204 mkdir (session_dir, 0700);
6205 }
6206 else
6207 {
6208 profile_dir = install_dir;
6209 session_dir = install_dir;
6210 shared_dir = install_dir;
6211 }
6212
6213 myfree (resolved_install_folder);
6214 myfree (resolved_exec_path);
6215
6216 #else
6217
6218 char *install_dir = get_install_dir (exec_path);
6219 char *profile_dir = install_dir;
6220 char *session_dir = install_dir;
6221 char *shared_dir = install_dir;
6222
6223 #endif
6224
6225 data.install_dir = install_dir;
6226 data.profile_dir = profile_dir;
6227 data.session_dir = session_dir;
6228 data.shared_dir = shared_dir;
6229
6230 myfree (exec_path);
6231
6232 /**
6233 * kernel cache, we need to make sure folder exist
6234 */
6235
6236 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6237
6238 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6239
6240 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6241
6242 mkdir (kernels_folder, 0700);
6243
6244 myfree (kernels_folder);
6245
6246 /**
6247 * session
6248 */
6249
6250 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6251
6252 data.session = session;
6253
6254 char *eff_restore_file = (char *) mymalloc (session_size);
6255 char *new_restore_file = (char *) mymalloc (session_size);
6256
6257 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6258 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6259
6260 data.eff_restore_file = eff_restore_file;
6261 data.new_restore_file = new_restore_file;
6262
6263 if (((show == 1) || (left == 1)) && (restore == 1))
6264 {
6265 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6266 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6267
6268 return (-1);
6269 }
6270
6271 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6272 if ((show == 1) || (left == 1))
6273 {
6274 restore_disable = 1;
6275
6276 restore = 0;
6277 }
6278
6279 data.restore_disable = restore_disable;
6280
6281 restore_data_t *rd = init_restore (argc, argv);
6282
6283 data.rd = rd;
6284
6285 /**
6286 * restore file
6287 */
6288
6289 if (restore == 1)
6290 {
6291 read_restore (eff_restore_file, rd);
6292
6293 if (rd->version_bin < RESTORE_MIN)
6294 {
6295 log_error ("ERROR: Incompatible restore-file version");
6296
6297 return (-1);
6298 }
6299
6300 myargc = rd->argc;
6301 myargv = rd->argv;
6302
6303 #ifdef _POSIX
6304 rd->pid = getpid ();
6305 #elif _WIN
6306 rd->pid = GetCurrentProcessId ();
6307 #endif
6308 }
6309
6310 uint hash_mode_chgd = 0;
6311 uint runtime_chgd = 0;
6312 uint kernel_loops_chgd = 0;
6313 uint kernel_accel_chgd = 0;
6314 uint nvidia_spin_damp_chgd = 0;
6315 uint attack_mode_chgd = 0;
6316 uint outfile_format_chgd = 0;
6317 uint rp_gen_seed_chgd = 0;
6318 uint remove_timer_chgd = 0;
6319 uint increment_min_chgd = 0;
6320 uint increment_max_chgd = 0;
6321 uint workload_profile_chgd = 0;
6322 uint opencl_vector_width_chgd = 0;
6323
6324 optind = 1;
6325 optopt = 0;
6326 option_index = 0;
6327
6328 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6329 {
6330 switch (c)
6331 {
6332 //case IDX_HELP: usage = 1; break;
6333 //case IDX_VERSION: version = 1; break;
6334 //case IDX_RESTORE: restore = 1; break;
6335 case IDX_QUIET: quiet = 1; break;
6336 //case IDX_SHOW: show = 1; break;
6337 case IDX_SHOW: break;
6338 //case IDX_LEFT: left = 1; break;
6339 case IDX_LEFT: break;
6340 case IDX_USERNAME: username = 1; break;
6341 case IDX_REMOVE: remove = 1; break;
6342 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6343 remove_timer_chgd = 1; break;
6344 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6345 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6346 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6347 case IDX_DEBUG_FILE: debug_file = optarg; break;
6348 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6349 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6350 case IDX_FORCE: force = 1; break;
6351 case IDX_SKIP: skip = atoll (optarg); break;
6352 case IDX_LIMIT: limit = atoll (optarg); break;
6353 case IDX_KEYSPACE: keyspace = 1; break;
6354 case IDX_BENCHMARK: benchmark = 1; break;
6355 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6356 case IDX_RESTORE: break;
6357 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6358 case IDX_STATUS: status = 1; break;
6359 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6360 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6361 case IDX_LOOPBACK: loopback = 1; break;
6362 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6363 //case IDX_SESSION: session = optarg; break;
6364 case IDX_SESSION: break;
6365 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6366 hash_mode_chgd = 1; break;
6367 case IDX_RUNTIME: runtime = atoi (optarg);
6368 runtime_chgd = 1; break;
6369 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6370 attack_mode_chgd = 1; break;
6371 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6372 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6373 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6374 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6375 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6376 rp_gen_seed_chgd = 1; break;
6377 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6378 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6379 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6380 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6381 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6382 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6383 case IDX_OUTFILE: outfile = optarg; break;
6384 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6385 outfile_format_chgd = 1; break;
6386 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6387 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6388 case IDX_HEX_CHARSET: hex_charset = 1; break;
6389 case IDX_HEX_SALT: hex_salt = 1; break;
6390 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6391 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6392 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6393 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6394 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6395 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6396 opencl_vector_width_chgd = 1; break;
6397 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6398 workload_profile_chgd = 1; break;
6399 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6400 kernel_accel_chgd = 1; break;
6401 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6402 kernel_loops_chgd = 1; break;
6403 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6404 nvidia_spin_damp_chgd = 1; break;
6405 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6406 #ifdef HAVE_HWMON
6407 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6408 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6409 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6410 #endif // HAVE_HWMON
6411 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6412 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6413 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6414 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6415 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6416 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6417 case IDX_SEPARATOR: separator = optarg[0]; break;
6418 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6419 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6420 case IDX_INCREMENT: increment = 1; break;
6421 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6422 increment_min_chgd = 1; break;
6423 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6424 increment_max_chgd = 1; break;
6425 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6426 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6427 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6428 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6429
6430 default:
6431 log_error ("ERROR: Invalid argument specified");
6432 return (-1);
6433 }
6434 }
6435
6436 if (optopt != 0)
6437 {
6438 log_error ("ERROR: Invalid argument specified");
6439
6440 return (-1);
6441 }
6442
6443 /**
6444 * Inform user things getting started,
6445 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6446 * - we do not need to check algorithm_pos
6447 */
6448
6449 if (quiet == 0)
6450 {
6451 if (benchmark == 1)
6452 {
6453 if (machine_readable == 0)
6454 {
6455 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6456 log_info ("");
6457 }
6458 else
6459 {
6460 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6461 }
6462 }
6463 else if (restore == 1)
6464 {
6465 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6466 log_info ("");
6467 }
6468 else if (stdout_flag == 1)
6469 {
6470 // do nothing
6471 }
6472 else if (keyspace == 1)
6473 {
6474 // do nothing
6475 }
6476 else
6477 {
6478 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6479 log_info ("");
6480 }
6481 }
6482
6483 /**
6484 * sanity check
6485 */
6486
6487 if (attack_mode > 7)
6488 {
6489 log_error ("ERROR: Invalid attack-mode specified");
6490
6491 return (-1);
6492 }
6493
6494 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6495 {
6496 log_error ("ERROR: Invalid runtime specified");
6497
6498 return (-1);
6499 }
6500
6501 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6502 {
6503 log_error ("ERROR: Invalid hash-type specified");
6504
6505 return (-1);
6506 }
6507
6508 // renamed hash modes
6509
6510 if (hash_mode_chgd)
6511 {
6512 int n = -1;
6513
6514 switch (hash_mode)
6515 {
6516 case 123: n = 124;
6517 break;
6518 }
6519
6520 if (n >= 0)
6521 {
6522 log_error ("Old -m specified, use -m %d instead", n);
6523
6524 return (-1);
6525 }
6526 }
6527
6528 if (username == 1)
6529 {
6530 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6531 {
6532 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6533
6534 return (-1);
6535 }
6536 }
6537
6538 if (outfile_format > 16)
6539 {
6540 log_error ("ERROR: Invalid outfile-format specified");
6541
6542 return (-1);
6543 }
6544
6545 if (left == 1)
6546 {
6547 if (outfile_format_chgd == 1)
6548 {
6549 if (outfile_format > 1)
6550 {
6551 log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
6552
6553 return (-1);
6554 }
6555 }
6556 else
6557 {
6558 outfile_format = OUTFILE_FMT_HASH;
6559 }
6560 }
6561
6562 if (show == 1)
6563 {
6564 if (outfile_format_chgd == 1)
6565 {
6566 if ((outfile_format > 7) && (outfile_format < 16))
6567 {
6568 log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
6569
6570 return (-1);
6571 }
6572 }
6573 }
6574
6575 if (increment_min < INCREMENT_MIN)
6576 {
6577 log_error ("ERROR: Invalid increment-min specified");
6578
6579 return (-1);
6580 }
6581
6582 if (increment_max > INCREMENT_MAX)
6583 {
6584 log_error ("ERROR: Invalid increment-max specified");
6585
6586 return (-1);
6587 }
6588
6589 if (increment_min > increment_max)
6590 {
6591 log_error ("ERROR: Invalid increment-min specified");
6592
6593 return (-1);
6594 }
6595
6596 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6597 {
6598 log_error ("ERROR: Increment is not allowed in attack-mode 0");
6599
6600 return (-1);
6601 }
6602
6603 if ((increment == 0) && (increment_min_chgd == 1))
6604 {
6605 log_error ("ERROR: Increment-min is only supported combined with increment switch");
6606
6607 return (-1);
6608 }
6609
6610 if ((increment == 0) && (increment_max_chgd == 1))
6611 {
6612 log_error ("ERROR: Increment-max is only supported combined with increment switch");
6613
6614 return (-1);
6615 }
6616
6617 if (rp_files_cnt && rp_gen)
6618 {
6619 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6620
6621 return (-1);
6622 }
6623
6624 if (rp_files_cnt || rp_gen)
6625 {
6626 if (attack_mode != ATTACK_MODE_STRAIGHT)
6627 {
6628 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6629
6630 return (-1);
6631 }
6632 }
6633
6634 if (rp_gen_func_min > rp_gen_func_max)
6635 {
6636 log_error ("ERROR: Invalid rp-gen-func-min specified");
6637
6638 return (-1);
6639 }
6640
6641 if (kernel_accel_chgd == 1)
6642 {
6643 if (force == 0)
6644 {
6645 log_info ("The manual use of the -n option (or --kernel-accel) is outdated");
6646 log_info ("Please consider using the -w option instead");
6647 log_info ("You can use --force to override this but do not post error reports if you do so");
6648 log_info ("");
6649
6650 return (-1);
6651 }
6652
6653 if (kernel_accel < 1)
6654 {
6655 log_error ("ERROR: Invalid kernel-accel specified");
6656
6657 return (-1);
6658 }
6659
6660 if (kernel_accel > 1024)
6661 {
6662 log_error ("ERROR: Invalid kernel-accel specified");
6663
6664 return (-1);
6665 }
6666 }
6667
6668 if (kernel_loops_chgd == 1)
6669 {
6670 if (force == 0)
6671 {
6672 log_info ("The manual use of the -u option (or --kernel-loops) is outdated");
6673 log_info ("Please consider using the -w option instead");
6674 log_info ("You can use --force to override this but do not post error reports if you do so");
6675 log_info ("");
6676
6677 return (-1);
6678 }
6679
6680 if (kernel_loops < 1)
6681 {
6682 log_error ("ERROR: Invalid kernel-loops specified");
6683
6684 return (-1);
6685 }
6686
6687 if (kernel_loops > 1024)
6688 {
6689 log_error ("ERROR: Invalid kernel-loops specified");
6690
6691 return (-1);
6692 }
6693 }
6694
6695 if ((workload_profile < 1) || (workload_profile > 4))
6696 {
6697 log_error ("ERROR: workload-profile %i not available", workload_profile);
6698
6699 return (-1);
6700 }
6701
6702 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6703 {
6704 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6705
6706 return (-1);
6707 }
6708
6709 if (show == 1 || left == 1)
6710 {
6711 attack_mode = ATTACK_MODE_NONE;
6712
6713 if (remove == 1)
6714 {
6715 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6716
6717 return (-1);
6718 }
6719
6720 if (potfile_disable == 1)
6721 {
6722 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6723
6724 return (-1);
6725 }
6726 }
6727
6728 uint attack_kern = ATTACK_KERN_NONE;
6729
6730 switch (attack_mode)
6731 {
6732 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6733 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6734 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6735 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6736 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6737 }
6738
6739 if (benchmark == 1)
6740 {
6741 if (myargv[optind] != 0)
6742 {
6743 log_error ("ERROR: Invalid argument for benchmark mode specified");
6744
6745 return (-1);
6746 }
6747
6748 if (attack_mode_chgd == 1)
6749 {
6750 if (attack_mode != ATTACK_MODE_BF)
6751 {
6752 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6753
6754 return (-1);
6755 }
6756 }
6757 }
6758 else
6759 {
6760 if (stdout_flag == 1) // no hash here
6761 {
6762 optind--;
6763 }
6764
6765 if (keyspace == 1)
6766 {
6767 int num_additional_params = 1;
6768
6769 if (attack_kern == ATTACK_KERN_COMBI)
6770 {
6771 num_additional_params = 2;
6772 }
6773
6774 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6775
6776 if (keyspace_wordlist_specified == 0) optind--;
6777 }
6778
6779 if (attack_kern == ATTACK_KERN_NONE)
6780 {
6781 if ((optind + 1) != myargc)
6782 {
6783 usage_mini_print (myargv[0]);
6784
6785 return (-1);
6786 }
6787 }
6788 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6789 {
6790 if ((optind + 1) > myargc)
6791 {
6792 usage_mini_print (myargv[0]);
6793
6794 return (-1);
6795 }
6796 }
6797 else if (attack_kern == ATTACK_KERN_COMBI)
6798 {
6799 if ((optind + 3) != myargc)
6800 {
6801 usage_mini_print (myargv[0]);
6802
6803 return (-1);
6804 }
6805 }
6806 else if (attack_kern == ATTACK_KERN_BF)
6807 {
6808 if ((optind + 1) > myargc)
6809 {
6810 usage_mini_print (myargv[0]);
6811
6812 return (-1);
6813 }
6814 }
6815 else
6816 {
6817 usage_mini_print (myargv[0]);
6818
6819 return (-1);
6820 }
6821 }
6822
6823 if (skip != 0 && limit != 0)
6824 {
6825 limit += skip;
6826 }
6827
6828 if (keyspace == 1)
6829 {
6830 if (show == 1)
6831 {
6832 log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
6833
6834 return (-1);
6835 }
6836 else if (left == 1)
6837 {
6838 log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
6839
6840 return (-1);
6841 }
6842
6843 potfile_disable = 1;
6844
6845 restore_disable = 1;
6846
6847 restore = 0;
6848
6849 weak_hash_threshold = 0;
6850
6851 quiet = 1;
6852 }
6853
6854 if (stdout_flag == 1)
6855 {
6856 status_timer = 0;
6857 restore_timer = 0;
6858 restore_disable = 1;
6859 restore = 0;
6860 potfile_disable = 1;
6861 weak_hash_threshold = 0;
6862 gpu_temp_disable = 1;
6863 hash_mode = 2000;
6864 quiet = 1;
6865 outfile_format = OUTFILE_FMT_PLAIN;
6866 kernel_accel = 1024;
6867 kernel_loops = 1024;
6868 force = 1;
6869 outfile_check_timer = 0;
6870 session = "stdout";
6871 opencl_vector_width = 1;
6872 }
6873
6874 if (remove_timer_chgd == 1)
6875 {
6876 if (remove == 0)
6877 {
6878 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6879
6880 return (-1);
6881 }
6882
6883 if (remove_timer < 1)
6884 {
6885 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6886
6887 return (-1);
6888 }
6889 }
6890
6891 if (loopback == 1)
6892 {
6893 if (attack_mode == ATTACK_MODE_STRAIGHT)
6894 {
6895 if ((rp_files_cnt == 0) && (rp_gen == 0))
6896 {
6897 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6898
6899 return (-1);
6900 }
6901 }
6902 else
6903 {
6904 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6905
6906 return (-1);
6907 }
6908 }
6909
6910 if (debug_mode > 0)
6911 {
6912 if (attack_mode != ATTACK_MODE_STRAIGHT)
6913 {
6914 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6915
6916 return (-1);
6917 }
6918
6919 if ((rp_files_cnt == 0) && (rp_gen == 0))
6920 {
6921 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6922
6923 return (-1);
6924 }
6925 }
6926
6927 if (debug_mode > 4)
6928 {
6929 log_error ("ERROR: Invalid debug-mode specified");
6930
6931 return (-1);
6932 }
6933
6934 if (debug_file != NULL)
6935 {
6936 if (debug_mode < 1)
6937 {
6938 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6939
6940 return (-1);
6941 }
6942 }
6943
6944 if (induction_dir != NULL)
6945 {
6946 if (attack_mode == ATTACK_MODE_BF)
6947 {
6948 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6949
6950 return (-1);
6951 }
6952 }
6953
6954 if (attack_mode != ATTACK_MODE_STRAIGHT)
6955 {
6956 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6957 {
6958 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6959
6960 return (-1);
6961 }
6962
6963 weak_hash_threshold = 0;
6964 }
6965
6966 if (nvidia_spin_damp > 100)
6967 {
6968 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6969
6970 return (-1);
6971 }
6972
6973
6974 /**
6975 * induction directory
6976 */
6977
6978 char *induction_directory = NULL;
6979
6980 if (attack_mode != ATTACK_MODE_BF)
6981 {
6982 if (induction_dir == NULL)
6983 {
6984 induction_directory = (char *) mymalloc (session_size);
6985
6986 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6987
6988 // create induction folder if it does not already exist
6989
6990 if (keyspace == 0)
6991 {
6992 if (rmdir (induction_directory) == -1)
6993 {
6994 if (errno == ENOENT)
6995 {
6996 // good, we can ignore
6997 }
6998 else if (errno == ENOTEMPTY)
6999 {
7000 char *induction_directory_mv = (char *) mymalloc (session_size);
7001
7002 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
7003
7004 if (rename (induction_directory, induction_directory_mv) != 0)
7005 {
7006 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
7007
7008 return (-1);
7009 }
7010 }
7011 else
7012 {
7013 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
7014
7015 return (-1);
7016 }
7017 }
7018
7019 if (mkdir (induction_directory, 0700) == -1)
7020 {
7021 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
7022
7023 return (-1);
7024 }
7025 }
7026 }
7027 else
7028 {
7029 induction_directory = induction_dir;
7030 }
7031 }
7032
7033 data.induction_directory = induction_directory;
7034
7035 /**
7036 * loopback
7037 */
7038
7039 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
7040
7041 char *loopback_file = (char *) mymalloc (loopback_size);
7042
7043 /**
7044 * tuning db
7045 */
7046
7047 char tuning_db_file[256] = { 0 };
7048
7049 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
7050
7051 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
7052
7053 /**
7054 * outfile-check directory
7055 */
7056
7057 char *outfile_check_directory = NULL;
7058
7059 if (outfile_check_dir == NULL)
7060 {
7061 outfile_check_directory = (char *) mymalloc (session_size);
7062
7063 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
7064 }
7065 else
7066 {
7067 outfile_check_directory = outfile_check_dir;
7068 }
7069
7070 data.outfile_check_directory = outfile_check_directory;
7071
7072 if (keyspace == 0)
7073 {
7074 struct stat outfile_check_stat;
7075
7076 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
7077 {
7078 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
7079
7080 if (is_dir == 0)
7081 {
7082 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
7083
7084 return (-1);
7085 }
7086 }
7087 else if (outfile_check_dir == NULL)
7088 {
7089 if (mkdir (outfile_check_directory, 0700) == -1)
7090 {
7091 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
7092
7093 return (-1);
7094 }
7095 }
7096 }
7097
7098 /**
7099 * special other stuff
7100 */
7101
7102 if (hash_mode == 9710)
7103 {
7104 outfile_format = 5;
7105 outfile_format_chgd = 1;
7106 }
7107
7108 if (hash_mode == 9810)
7109 {
7110 outfile_format = 5;
7111 outfile_format_chgd = 1;
7112 }
7113
7114 if (hash_mode == 10410)
7115 {
7116 outfile_format = 5;
7117 outfile_format_chgd = 1;
7118 }
7119
7120 /**
7121 * store stuff
7122 */
7123
7124 data.hash_mode = hash_mode;
7125 data.restore = restore;
7126 data.restore_timer = restore_timer;
7127 data.restore_disable = restore_disable;
7128 data.status = status;
7129 data.status_timer = status_timer;
7130 data.machine_readable = machine_readable;
7131 data.loopback = loopback;
7132 data.runtime = runtime;
7133 data.remove = remove;
7134 data.remove_timer = remove_timer;
7135 data.debug_mode = debug_mode;
7136 data.debug_file = debug_file;
7137 data.username = username;
7138 data.quiet = quiet;
7139 data.outfile = outfile;
7140 data.outfile_format = outfile_format;
7141 data.outfile_autohex = outfile_autohex;
7142 data.hex_charset = hex_charset;
7143 data.hex_salt = hex_salt;
7144 data.hex_wordlist = hex_wordlist;
7145 data.separator = separator;
7146 data.rp_files = rp_files;
7147 data.rp_files_cnt = rp_files_cnt;
7148 data.rp_gen = rp_gen;
7149 data.rp_gen_seed = rp_gen_seed;
7150 data.force = force;
7151 data.benchmark = benchmark;
7152 data.skip = skip;
7153 data.limit = limit;
7154 #ifdef HAVE_HWMON
7155 data.powertune_enable = powertune_enable;
7156 #endif
7157 data.logfile_disable = logfile_disable;
7158 data.truecrypt_keyfiles = truecrypt_keyfiles;
7159 data.veracrypt_keyfiles = veracrypt_keyfiles;
7160 data.veracrypt_pim = veracrypt_pim;
7161 data.scrypt_tmto = scrypt_tmto;
7162 data.workload_profile = workload_profile;
7163
7164 /**
7165 * cpu affinity
7166 */
7167
7168 if (cpu_affinity)
7169 {
7170 set_cpu_affinity (cpu_affinity);
7171 }
7172
7173 if (rp_gen_seed_chgd == 0)
7174 {
7175 srand (proc_start);
7176 }
7177 else
7178 {
7179 srand (rp_gen_seed);
7180 }
7181
7182 /**
7183 * logfile init
7184 */
7185
7186 if (logfile_disable == 0)
7187 {
7188 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7189
7190 char *logfile = (char *) mymalloc (logfile_size);
7191
7192 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7193
7194 data.logfile = logfile;
7195
7196 char *topid = logfile_generate_topid ();
7197
7198 data.topid = topid;
7199 }
7200
7201 // logfile_append() checks for logfile_disable internally to make it easier from here
7202
7203 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7204 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7205 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7206 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7207 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7208 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7209 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7210 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7211 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7212 #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));
7213
7214 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7215 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7216 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7217 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7218 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7219 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7220 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7221 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7222
7223 logfile_top_msg ("START");
7224
7225 logfile_top_uint (attack_mode);
7226 logfile_top_uint (attack_kern);
7227 logfile_top_uint (benchmark);
7228 logfile_top_uint (stdout_flag);
7229 logfile_top_uint (bitmap_min);
7230 logfile_top_uint (bitmap_max);
7231 logfile_top_uint (debug_mode);
7232 logfile_top_uint (force);
7233 logfile_top_uint (kernel_accel);
7234 logfile_top_uint (kernel_loops);
7235 logfile_top_uint (nvidia_spin_damp);
7236 logfile_top_uint (gpu_temp_disable);
7237 #ifdef HAVE_HWMON
7238 logfile_top_uint (gpu_temp_abort);
7239 logfile_top_uint (gpu_temp_retain);
7240 #endif
7241 logfile_top_uint (hash_mode);
7242 logfile_top_uint (hex_charset);
7243 logfile_top_uint (hex_salt);
7244 logfile_top_uint (hex_wordlist);
7245 logfile_top_uint (increment);
7246 logfile_top_uint (increment_max);
7247 logfile_top_uint (increment_min);
7248 logfile_top_uint (keyspace);
7249 logfile_top_uint (left);
7250 logfile_top_uint (logfile_disable);
7251 logfile_top_uint (loopback);
7252 logfile_top_uint (markov_classic);
7253 logfile_top_uint (markov_disable);
7254 logfile_top_uint (markov_threshold);
7255 logfile_top_uint (outfile_autohex);
7256 logfile_top_uint (outfile_check_timer);
7257 logfile_top_uint (outfile_format);
7258 logfile_top_uint (potfile_disable);
7259 logfile_top_string (potfile_path);
7260 #if defined(HAVE_HWMON)
7261 logfile_top_uint (powertune_enable);
7262 #endif
7263 logfile_top_uint (scrypt_tmto);
7264 logfile_top_uint (quiet);
7265 logfile_top_uint (remove);
7266 logfile_top_uint (remove_timer);
7267 logfile_top_uint (restore);
7268 logfile_top_uint (restore_disable);
7269 logfile_top_uint (restore_timer);
7270 logfile_top_uint (rp_gen);
7271 logfile_top_uint (rp_gen_func_max);
7272 logfile_top_uint (rp_gen_func_min);
7273 logfile_top_uint (rp_gen_seed);
7274 logfile_top_uint (runtime);
7275 logfile_top_uint (segment_size);
7276 logfile_top_uint (show);
7277 logfile_top_uint (status);
7278 logfile_top_uint (machine_readable);
7279 logfile_top_uint (status_timer);
7280 logfile_top_uint (usage);
7281 logfile_top_uint (username);
7282 logfile_top_uint (version);
7283 logfile_top_uint (weak_hash_threshold);
7284 logfile_top_uint (workload_profile);
7285 logfile_top_uint64 (limit);
7286 logfile_top_uint64 (skip);
7287 logfile_top_char (separator);
7288 logfile_top_string (cpu_affinity);
7289 logfile_top_string (custom_charset_1);
7290 logfile_top_string (custom_charset_2);
7291 logfile_top_string (custom_charset_3);
7292 logfile_top_string (custom_charset_4);
7293 logfile_top_string (debug_file);
7294 logfile_top_string (opencl_devices);
7295 logfile_top_string (opencl_platforms);
7296 logfile_top_string (opencl_device_types);
7297 logfile_top_uint (opencl_vector_width);
7298 logfile_top_string (induction_dir);
7299 logfile_top_string (markov_hcstat);
7300 logfile_top_string (outfile);
7301 logfile_top_string (outfile_check_dir);
7302 logfile_top_string (rule_buf_l);
7303 logfile_top_string (rule_buf_r);
7304 logfile_top_string (session);
7305 logfile_top_string (truecrypt_keyfiles);
7306 logfile_top_string (veracrypt_keyfiles);
7307 logfile_top_uint (veracrypt_pim);
7308
7309 /**
7310 * Init OpenCL library loader
7311 */
7312
7313 if (keyspace == 0)
7314 {
7315 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7316
7317 ocl_init (ocl);
7318
7319 data.ocl = ocl;
7320 }
7321
7322 /**
7323 * OpenCL platform selection
7324 */
7325
7326 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7327
7328 /**
7329 * OpenCL device selection
7330 */
7331
7332 u32 devices_filter = setup_devices_filter (opencl_devices);
7333
7334 /**
7335 * OpenCL device type selection
7336 */
7337
7338 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7339
7340 /**
7341 * benchmark
7342 */
7343
7344 if (benchmark == 1)
7345 {
7346 /**
7347 * disable useless stuff for benchmark
7348 */
7349
7350 status_timer = 0;
7351 restore_timer = 0;
7352 restore_disable = 1;
7353 potfile_disable = 1;
7354 weak_hash_threshold = 0;
7355 nvidia_spin_damp = 0;
7356 gpu_temp_disable = 1;
7357 outfile_check_timer = 0;
7358
7359 #ifdef HAVE_HWMON
7360 if (powertune_enable == 1)
7361 {
7362 gpu_temp_disable = 0;
7363 }
7364 #endif
7365
7366 data.status_timer = status_timer;
7367 data.restore_timer = restore_timer;
7368 data.restore_disable = restore_disable;
7369 data.outfile_check_timer = outfile_check_timer;
7370
7371 /**
7372 * force attack mode to be bruteforce
7373 */
7374
7375 attack_mode = ATTACK_MODE_BF;
7376 attack_kern = ATTACK_KERN_BF;
7377
7378 if (workload_profile_chgd == 0)
7379 {
7380 workload_profile = 3;
7381
7382 data.workload_profile = workload_profile;
7383 }
7384 }
7385
7386 /**
7387 * status, monitor and outfile remove threads
7388 */
7389
7390 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
7391
7392 data.wordlist_mode = wordlist_mode;
7393
7394 if (wordlist_mode == WL_MODE_STDIN)
7395 {
7396 status = 1;
7397
7398 data.status = status;
7399 }
7400
7401 uint outer_threads_cnt = 0;
7402
7403 hc_thread_t *outer_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
7404
7405 data.shutdown_outer = 0;
7406
7407 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
7408 {
7409 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
7410 {
7411 hc_thread_create (outer_threads[outer_threads_cnt], thread_keypress, NULL);
7412
7413 outer_threads_cnt++;
7414 }
7415 }
7416
7417 /**
7418 * config
7419 */
7420
7421 uint hash_type = 0;
7422 uint salt_type = 0;
7423 uint attack_exec = 0;
7424 uint opts_type = 0;
7425 uint kern_type = 0;
7426 uint dgst_size = 0;
7427 uint esalt_size = 0;
7428 uint opti_type = 0;
7429 uint dgst_pos0 = -1;
7430 uint dgst_pos1 = -1;
7431 uint dgst_pos2 = -1;
7432 uint dgst_pos3 = -1;
7433
7434 int (*parse_func) (char *, uint, hash_t *);
7435 int (*sort_by_digest) (const void *, const void *);
7436
7437 uint algorithm_pos = 0;
7438 uint algorithm_max = 1;
7439
7440 uint *algorithms = default_benchmark_algorithms;
7441
7442 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7443
7444 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7445 {
7446 /*
7447 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7448 * the following algos are skipped entirely
7449 */
7450
7451 if (algorithm_pos > 0)
7452 {
7453 local_free (rd);
7454
7455 rd = init_restore (argc, argv);
7456
7457 data.rd = rd;
7458 }
7459
7460 /**
7461 * update hash_mode in case of multihash benchmark
7462 */
7463
7464 if (benchmark == 1)
7465 {
7466 if (hash_mode_chgd == 0)
7467 {
7468 hash_mode = algorithms[algorithm_pos];
7469
7470 data.hash_mode = hash_mode;
7471 }
7472
7473 quiet = 1;
7474
7475 data.quiet = quiet;
7476 }
7477
7478 switch (hash_mode)
7479 {
7480 case 0: hash_type = HASH_TYPE_MD5;
7481 salt_type = SALT_TYPE_NONE;
7482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7483 opts_type = OPTS_TYPE_PT_GENERATE_LE
7484 | OPTS_TYPE_PT_ADD80
7485 | OPTS_TYPE_PT_ADDBITS14;
7486 kern_type = KERN_TYPE_MD5;
7487 dgst_size = DGST_SIZE_4_4;
7488 parse_func = md5_parse_hash;
7489 sort_by_digest = sort_by_digest_4_4;
7490 opti_type = OPTI_TYPE_ZERO_BYTE
7491 | OPTI_TYPE_PRECOMPUTE_INIT
7492 | OPTI_TYPE_PRECOMPUTE_MERKLE
7493 | OPTI_TYPE_MEET_IN_MIDDLE
7494 | OPTI_TYPE_EARLY_SKIP
7495 | OPTI_TYPE_NOT_ITERATED
7496 | OPTI_TYPE_NOT_SALTED
7497 | OPTI_TYPE_RAW_HASH;
7498 dgst_pos0 = 0;
7499 dgst_pos1 = 3;
7500 dgst_pos2 = 2;
7501 dgst_pos3 = 1;
7502 break;
7503
7504 case 10: hash_type = HASH_TYPE_MD5;
7505 salt_type = SALT_TYPE_INTERN;
7506 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7507 opts_type = OPTS_TYPE_PT_GENERATE_LE
7508 | OPTS_TYPE_ST_ADD80
7509 | OPTS_TYPE_ST_ADDBITS14;
7510 kern_type = KERN_TYPE_MD5_PWSLT;
7511 dgst_size = DGST_SIZE_4_4;
7512 parse_func = md5s_parse_hash;
7513 sort_by_digest = sort_by_digest_4_4;
7514 opti_type = OPTI_TYPE_ZERO_BYTE
7515 | OPTI_TYPE_PRECOMPUTE_INIT
7516 | OPTI_TYPE_PRECOMPUTE_MERKLE
7517 | OPTI_TYPE_MEET_IN_MIDDLE
7518 | OPTI_TYPE_EARLY_SKIP
7519 | OPTI_TYPE_NOT_ITERATED
7520 | OPTI_TYPE_APPENDED_SALT
7521 | OPTI_TYPE_RAW_HASH;
7522 dgst_pos0 = 0;
7523 dgst_pos1 = 3;
7524 dgst_pos2 = 2;
7525 dgst_pos3 = 1;
7526 break;
7527
7528 case 11: hash_type = HASH_TYPE_MD5;
7529 salt_type = SALT_TYPE_INTERN;
7530 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7531 opts_type = OPTS_TYPE_PT_GENERATE_LE
7532 | OPTS_TYPE_ST_ADD80
7533 | OPTS_TYPE_ST_ADDBITS14;
7534 kern_type = KERN_TYPE_MD5_PWSLT;
7535 dgst_size = DGST_SIZE_4_4;
7536 parse_func = joomla_parse_hash;
7537 sort_by_digest = sort_by_digest_4_4;
7538 opti_type = OPTI_TYPE_ZERO_BYTE
7539 | OPTI_TYPE_PRECOMPUTE_INIT
7540 | OPTI_TYPE_PRECOMPUTE_MERKLE
7541 | OPTI_TYPE_MEET_IN_MIDDLE
7542 | OPTI_TYPE_EARLY_SKIP
7543 | OPTI_TYPE_NOT_ITERATED
7544 | OPTI_TYPE_APPENDED_SALT
7545 | OPTI_TYPE_RAW_HASH;
7546 dgst_pos0 = 0;
7547 dgst_pos1 = 3;
7548 dgst_pos2 = 2;
7549 dgst_pos3 = 1;
7550 break;
7551
7552 case 12: hash_type = HASH_TYPE_MD5;
7553 salt_type = SALT_TYPE_INTERN;
7554 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7555 opts_type = OPTS_TYPE_PT_GENERATE_LE
7556 | OPTS_TYPE_ST_ADD80
7557 | OPTS_TYPE_ST_ADDBITS14;
7558 kern_type = KERN_TYPE_MD5_PWSLT;
7559 dgst_size = DGST_SIZE_4_4;
7560 parse_func = postgresql_parse_hash;
7561 sort_by_digest = sort_by_digest_4_4;
7562 opti_type = OPTI_TYPE_ZERO_BYTE
7563 | OPTI_TYPE_PRECOMPUTE_INIT
7564 | OPTI_TYPE_PRECOMPUTE_MERKLE
7565 | OPTI_TYPE_MEET_IN_MIDDLE
7566 | OPTI_TYPE_EARLY_SKIP
7567 | OPTI_TYPE_NOT_ITERATED
7568 | OPTI_TYPE_APPENDED_SALT
7569 | OPTI_TYPE_RAW_HASH;
7570 dgst_pos0 = 0;
7571 dgst_pos1 = 3;
7572 dgst_pos2 = 2;
7573 dgst_pos3 = 1;
7574 break;
7575
7576 case 20: hash_type = HASH_TYPE_MD5;
7577 salt_type = SALT_TYPE_INTERN;
7578 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7579 opts_type = OPTS_TYPE_PT_GENERATE_LE
7580 | OPTS_TYPE_PT_ADD80
7581 | OPTS_TYPE_PT_ADDBITS14;
7582 kern_type = KERN_TYPE_MD5_SLTPW;
7583 dgst_size = DGST_SIZE_4_4;
7584 parse_func = md5s_parse_hash;
7585 sort_by_digest = sort_by_digest_4_4;
7586 opti_type = OPTI_TYPE_ZERO_BYTE
7587 | OPTI_TYPE_PRECOMPUTE_INIT
7588 | OPTI_TYPE_PRECOMPUTE_MERKLE
7589 | OPTI_TYPE_EARLY_SKIP
7590 | OPTI_TYPE_NOT_ITERATED
7591 | OPTI_TYPE_PREPENDED_SALT
7592 | OPTI_TYPE_RAW_HASH;
7593 dgst_pos0 = 0;
7594 dgst_pos1 = 3;
7595 dgst_pos2 = 2;
7596 dgst_pos3 = 1;
7597 break;
7598
7599 case 21: hash_type = HASH_TYPE_MD5;
7600 salt_type = SALT_TYPE_INTERN;
7601 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7602 opts_type = OPTS_TYPE_PT_GENERATE_LE
7603 | OPTS_TYPE_PT_ADD80
7604 | OPTS_TYPE_PT_ADDBITS14;
7605 kern_type = KERN_TYPE_MD5_SLTPW;
7606 dgst_size = DGST_SIZE_4_4;
7607 parse_func = osc_parse_hash;
7608 sort_by_digest = sort_by_digest_4_4;
7609 opti_type = OPTI_TYPE_ZERO_BYTE
7610 | OPTI_TYPE_PRECOMPUTE_INIT
7611 | OPTI_TYPE_PRECOMPUTE_MERKLE
7612 | OPTI_TYPE_EARLY_SKIP
7613 | OPTI_TYPE_NOT_ITERATED
7614 | OPTI_TYPE_PREPENDED_SALT
7615 | OPTI_TYPE_RAW_HASH;
7616 dgst_pos0 = 0;
7617 dgst_pos1 = 3;
7618 dgst_pos2 = 2;
7619 dgst_pos3 = 1;
7620 break;
7621
7622 case 22: hash_type = HASH_TYPE_MD5;
7623 salt_type = SALT_TYPE_EMBEDDED;
7624 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7625 opts_type = OPTS_TYPE_PT_GENERATE_LE
7626 | OPTS_TYPE_PT_ADD80
7627 | OPTS_TYPE_PT_ADDBITS14;
7628 kern_type = KERN_TYPE_MD5_SLTPW;
7629 dgst_size = DGST_SIZE_4_4;
7630 parse_func = netscreen_parse_hash;
7631 sort_by_digest = sort_by_digest_4_4;
7632 opti_type = OPTI_TYPE_ZERO_BYTE
7633 | OPTI_TYPE_PRECOMPUTE_INIT
7634 | OPTI_TYPE_PRECOMPUTE_MERKLE
7635 | OPTI_TYPE_EARLY_SKIP
7636 | OPTI_TYPE_NOT_ITERATED
7637 | OPTI_TYPE_PREPENDED_SALT
7638 | OPTI_TYPE_RAW_HASH;
7639 dgst_pos0 = 0;
7640 dgst_pos1 = 3;
7641 dgst_pos2 = 2;
7642 dgst_pos3 = 1;
7643 break;
7644
7645 case 23: hash_type = HASH_TYPE_MD5;
7646 salt_type = SALT_TYPE_EMBEDDED;
7647 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7648 opts_type = OPTS_TYPE_PT_GENERATE_LE
7649 | OPTS_TYPE_PT_ADD80
7650 | OPTS_TYPE_PT_ADDBITS14;
7651 kern_type = KERN_TYPE_MD5_SLTPW;
7652 dgst_size = DGST_SIZE_4_4;
7653 parse_func = skype_parse_hash;
7654 sort_by_digest = sort_by_digest_4_4;
7655 opti_type = OPTI_TYPE_ZERO_BYTE
7656 | OPTI_TYPE_PRECOMPUTE_INIT
7657 | OPTI_TYPE_PRECOMPUTE_MERKLE
7658 | OPTI_TYPE_EARLY_SKIP
7659 | OPTI_TYPE_NOT_ITERATED
7660 | OPTI_TYPE_PREPENDED_SALT
7661 | OPTI_TYPE_RAW_HASH;
7662 dgst_pos0 = 0;
7663 dgst_pos1 = 3;
7664 dgst_pos2 = 2;
7665 dgst_pos3 = 1;
7666 break;
7667
7668 case 30: hash_type = HASH_TYPE_MD5;
7669 salt_type = SALT_TYPE_INTERN;
7670 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7671 opts_type = OPTS_TYPE_PT_GENERATE_LE
7672 | OPTS_TYPE_PT_UNICODE
7673 | OPTS_TYPE_ST_ADD80
7674 | OPTS_TYPE_ST_ADDBITS14;
7675 kern_type = KERN_TYPE_MD5_PWUSLT;
7676 dgst_size = DGST_SIZE_4_4;
7677 parse_func = md5s_parse_hash;
7678 sort_by_digest = sort_by_digest_4_4;
7679 opti_type = OPTI_TYPE_ZERO_BYTE
7680 | OPTI_TYPE_PRECOMPUTE_INIT
7681 | OPTI_TYPE_PRECOMPUTE_MERKLE
7682 | OPTI_TYPE_MEET_IN_MIDDLE
7683 | OPTI_TYPE_EARLY_SKIP
7684 | OPTI_TYPE_NOT_ITERATED
7685 | OPTI_TYPE_APPENDED_SALT
7686 | OPTI_TYPE_RAW_HASH;
7687 dgst_pos0 = 0;
7688 dgst_pos1 = 3;
7689 dgst_pos2 = 2;
7690 dgst_pos3 = 1;
7691 break;
7692
7693 case 40: hash_type = HASH_TYPE_MD5;
7694 salt_type = SALT_TYPE_INTERN;
7695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7696 opts_type = OPTS_TYPE_PT_GENERATE_LE
7697 | OPTS_TYPE_PT_ADD80
7698 | OPTS_TYPE_PT_ADDBITS14
7699 | OPTS_TYPE_PT_UNICODE;
7700 kern_type = KERN_TYPE_MD5_SLTPWU;
7701 dgst_size = DGST_SIZE_4_4;
7702 parse_func = md5s_parse_hash;
7703 sort_by_digest = sort_by_digest_4_4;
7704 opti_type = OPTI_TYPE_ZERO_BYTE
7705 | OPTI_TYPE_PRECOMPUTE_INIT
7706 | OPTI_TYPE_PRECOMPUTE_MERKLE
7707 | OPTI_TYPE_EARLY_SKIP
7708 | OPTI_TYPE_NOT_ITERATED
7709 | OPTI_TYPE_PREPENDED_SALT
7710 | OPTI_TYPE_RAW_HASH;
7711 dgst_pos0 = 0;
7712 dgst_pos1 = 3;
7713 dgst_pos2 = 2;
7714 dgst_pos3 = 1;
7715 break;
7716
7717 case 50: hash_type = HASH_TYPE_MD5;
7718 salt_type = SALT_TYPE_INTERN;
7719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7720 opts_type = OPTS_TYPE_PT_GENERATE_LE
7721 | OPTS_TYPE_ST_ADD80
7722 | OPTS_TYPE_ST_ADDBITS14;
7723 kern_type = KERN_TYPE_HMACMD5_PW;
7724 dgst_size = DGST_SIZE_4_4;
7725 parse_func = hmacmd5_parse_hash;
7726 sort_by_digest = sort_by_digest_4_4;
7727 opti_type = OPTI_TYPE_ZERO_BYTE
7728 | OPTI_TYPE_NOT_ITERATED;
7729 dgst_pos0 = 0;
7730 dgst_pos1 = 3;
7731 dgst_pos2 = 2;
7732 dgst_pos3 = 1;
7733 break;
7734
7735 case 60: hash_type = HASH_TYPE_MD5;
7736 salt_type = SALT_TYPE_INTERN;
7737 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7738 opts_type = OPTS_TYPE_PT_GENERATE_LE
7739 | OPTS_TYPE_PT_ADD80
7740 | OPTS_TYPE_PT_ADDBITS14;
7741 kern_type = KERN_TYPE_HMACMD5_SLT;
7742 dgst_size = DGST_SIZE_4_4;
7743 parse_func = hmacmd5_parse_hash;
7744 sort_by_digest = sort_by_digest_4_4;
7745 opti_type = OPTI_TYPE_ZERO_BYTE
7746 | OPTI_TYPE_NOT_ITERATED;
7747 dgst_pos0 = 0;
7748 dgst_pos1 = 3;
7749 dgst_pos2 = 2;
7750 dgst_pos3 = 1;
7751 break;
7752
7753 case 100: hash_type = HASH_TYPE_SHA1;
7754 salt_type = SALT_TYPE_NONE;
7755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7756 opts_type = OPTS_TYPE_PT_GENERATE_BE
7757 | OPTS_TYPE_PT_ADD80
7758 | OPTS_TYPE_PT_ADDBITS15;
7759 kern_type = KERN_TYPE_SHA1;
7760 dgst_size = DGST_SIZE_4_5;
7761 parse_func = sha1_parse_hash;
7762 sort_by_digest = sort_by_digest_4_5;
7763 opti_type = OPTI_TYPE_ZERO_BYTE
7764 | OPTI_TYPE_PRECOMPUTE_INIT
7765 | OPTI_TYPE_PRECOMPUTE_MERKLE
7766 | OPTI_TYPE_EARLY_SKIP
7767 | OPTI_TYPE_NOT_ITERATED
7768 | OPTI_TYPE_NOT_SALTED
7769 | OPTI_TYPE_RAW_HASH;
7770 dgst_pos0 = 3;
7771 dgst_pos1 = 4;
7772 dgst_pos2 = 2;
7773 dgst_pos3 = 1;
7774 break;
7775
7776 case 101: hash_type = HASH_TYPE_SHA1;
7777 salt_type = SALT_TYPE_NONE;
7778 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7779 opts_type = OPTS_TYPE_PT_GENERATE_BE
7780 | OPTS_TYPE_PT_ADD80
7781 | OPTS_TYPE_PT_ADDBITS15;
7782 kern_type = KERN_TYPE_SHA1;
7783 dgst_size = DGST_SIZE_4_5;
7784 parse_func = sha1b64_parse_hash;
7785 sort_by_digest = sort_by_digest_4_5;
7786 opti_type = OPTI_TYPE_ZERO_BYTE
7787 | OPTI_TYPE_PRECOMPUTE_INIT
7788 | OPTI_TYPE_PRECOMPUTE_MERKLE
7789 | OPTI_TYPE_EARLY_SKIP
7790 | OPTI_TYPE_NOT_ITERATED
7791 | OPTI_TYPE_NOT_SALTED
7792 | OPTI_TYPE_RAW_HASH;
7793 dgst_pos0 = 3;
7794 dgst_pos1 = 4;
7795 dgst_pos2 = 2;
7796 dgst_pos3 = 1;
7797 break;
7798
7799 case 110: hash_type = HASH_TYPE_SHA1;
7800 salt_type = SALT_TYPE_INTERN;
7801 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7802 opts_type = OPTS_TYPE_PT_GENERATE_BE
7803 | OPTS_TYPE_ST_ADD80
7804 | OPTS_TYPE_ST_ADDBITS15;
7805 kern_type = KERN_TYPE_SHA1_PWSLT;
7806 dgst_size = DGST_SIZE_4_5;
7807 parse_func = sha1s_parse_hash;
7808 sort_by_digest = sort_by_digest_4_5;
7809 opti_type = OPTI_TYPE_ZERO_BYTE
7810 | OPTI_TYPE_PRECOMPUTE_INIT
7811 | OPTI_TYPE_PRECOMPUTE_MERKLE
7812 | OPTI_TYPE_EARLY_SKIP
7813 | OPTI_TYPE_NOT_ITERATED
7814 | OPTI_TYPE_APPENDED_SALT
7815 | OPTI_TYPE_RAW_HASH;
7816 dgst_pos0 = 3;
7817 dgst_pos1 = 4;
7818 dgst_pos2 = 2;
7819 dgst_pos3 = 1;
7820 break;
7821
7822 case 111: hash_type = HASH_TYPE_SHA1;
7823 salt_type = SALT_TYPE_EMBEDDED;
7824 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7825 opts_type = OPTS_TYPE_PT_GENERATE_BE
7826 | OPTS_TYPE_ST_ADD80
7827 | OPTS_TYPE_ST_ADDBITS15;
7828 kern_type = KERN_TYPE_SHA1_PWSLT;
7829 dgst_size = DGST_SIZE_4_5;
7830 parse_func = sha1b64s_parse_hash;
7831 sort_by_digest = sort_by_digest_4_5;
7832 opti_type = OPTI_TYPE_ZERO_BYTE
7833 | OPTI_TYPE_PRECOMPUTE_INIT
7834 | OPTI_TYPE_PRECOMPUTE_MERKLE
7835 | OPTI_TYPE_EARLY_SKIP
7836 | OPTI_TYPE_NOT_ITERATED
7837 | OPTI_TYPE_APPENDED_SALT
7838 | OPTI_TYPE_RAW_HASH;
7839 dgst_pos0 = 3;
7840 dgst_pos1 = 4;
7841 dgst_pos2 = 2;
7842 dgst_pos3 = 1;
7843 break;
7844
7845 case 112: hash_type = HASH_TYPE_SHA1;
7846 salt_type = SALT_TYPE_INTERN;
7847 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7848 opts_type = OPTS_TYPE_PT_GENERATE_BE
7849 | OPTS_TYPE_ST_ADD80
7850 | OPTS_TYPE_ST_ADDBITS15
7851 | OPTS_TYPE_ST_HEX;
7852 kern_type = KERN_TYPE_SHA1_PWSLT;
7853 dgst_size = DGST_SIZE_4_5;
7854 parse_func = oracles_parse_hash;
7855 sort_by_digest = sort_by_digest_4_5;
7856 opti_type = OPTI_TYPE_ZERO_BYTE
7857 | OPTI_TYPE_PRECOMPUTE_INIT
7858 | OPTI_TYPE_PRECOMPUTE_MERKLE
7859 | OPTI_TYPE_EARLY_SKIP
7860 | OPTI_TYPE_NOT_ITERATED
7861 | OPTI_TYPE_APPENDED_SALT
7862 | OPTI_TYPE_RAW_HASH;
7863 dgst_pos0 = 3;
7864 dgst_pos1 = 4;
7865 dgst_pos2 = 2;
7866 dgst_pos3 = 1;
7867 break;
7868
7869 case 120: hash_type = HASH_TYPE_SHA1;
7870 salt_type = SALT_TYPE_INTERN;
7871 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7872 opts_type = OPTS_TYPE_PT_GENERATE_BE
7873 | OPTS_TYPE_PT_ADD80
7874 | OPTS_TYPE_PT_ADDBITS15;
7875 kern_type = KERN_TYPE_SHA1_SLTPW;
7876 dgst_size = DGST_SIZE_4_5;
7877 parse_func = sha1s_parse_hash;
7878 sort_by_digest = sort_by_digest_4_5;
7879 opti_type = OPTI_TYPE_ZERO_BYTE
7880 | OPTI_TYPE_PRECOMPUTE_INIT
7881 | OPTI_TYPE_PRECOMPUTE_MERKLE
7882 | OPTI_TYPE_EARLY_SKIP
7883 | OPTI_TYPE_NOT_ITERATED
7884 | OPTI_TYPE_PREPENDED_SALT
7885 | OPTI_TYPE_RAW_HASH;
7886 dgst_pos0 = 3;
7887 dgst_pos1 = 4;
7888 dgst_pos2 = 2;
7889 dgst_pos3 = 1;
7890 break;
7891
7892 case 121: hash_type = HASH_TYPE_SHA1;
7893 salt_type = SALT_TYPE_INTERN;
7894 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7895 opts_type = OPTS_TYPE_PT_GENERATE_BE
7896 | OPTS_TYPE_PT_ADD80
7897 | OPTS_TYPE_PT_ADDBITS15
7898 | OPTS_TYPE_ST_LOWER;
7899 kern_type = KERN_TYPE_SHA1_SLTPW;
7900 dgst_size = DGST_SIZE_4_5;
7901 parse_func = smf_parse_hash;
7902 sort_by_digest = sort_by_digest_4_5;
7903 opti_type = OPTI_TYPE_ZERO_BYTE
7904 | OPTI_TYPE_PRECOMPUTE_INIT
7905 | OPTI_TYPE_PRECOMPUTE_MERKLE
7906 | OPTI_TYPE_EARLY_SKIP
7907 | OPTI_TYPE_NOT_ITERATED
7908 | OPTI_TYPE_PREPENDED_SALT
7909 | OPTI_TYPE_RAW_HASH;
7910 dgst_pos0 = 3;
7911 dgst_pos1 = 4;
7912 dgst_pos2 = 2;
7913 dgst_pos3 = 1;
7914 break;
7915
7916 case 122: hash_type = HASH_TYPE_SHA1;
7917 salt_type = SALT_TYPE_EMBEDDED;
7918 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7919 opts_type = OPTS_TYPE_PT_GENERATE_BE
7920 | OPTS_TYPE_PT_ADD80
7921 | OPTS_TYPE_PT_ADDBITS15
7922 | OPTS_TYPE_ST_HEX;
7923 kern_type = KERN_TYPE_SHA1_SLTPW;
7924 dgst_size = DGST_SIZE_4_5;
7925 parse_func = osx1_parse_hash;
7926 sort_by_digest = sort_by_digest_4_5;
7927 opti_type = OPTI_TYPE_ZERO_BYTE
7928 | OPTI_TYPE_PRECOMPUTE_INIT
7929 | OPTI_TYPE_PRECOMPUTE_MERKLE
7930 | OPTI_TYPE_EARLY_SKIP
7931 | OPTI_TYPE_NOT_ITERATED
7932 | OPTI_TYPE_PREPENDED_SALT
7933 | OPTI_TYPE_RAW_HASH;
7934 dgst_pos0 = 3;
7935 dgst_pos1 = 4;
7936 dgst_pos2 = 2;
7937 dgst_pos3 = 1;
7938 break;
7939
7940 case 124: hash_type = HASH_TYPE_SHA1;
7941 salt_type = SALT_TYPE_EMBEDDED;
7942 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7943 opts_type = OPTS_TYPE_PT_GENERATE_BE
7944 | OPTS_TYPE_PT_ADD80
7945 | OPTS_TYPE_PT_ADDBITS15;
7946 kern_type = KERN_TYPE_SHA1_SLTPW;
7947 dgst_size = DGST_SIZE_4_5;
7948 parse_func = djangosha1_parse_hash;
7949 sort_by_digest = sort_by_digest_4_5;
7950 opti_type = OPTI_TYPE_ZERO_BYTE
7951 | OPTI_TYPE_PRECOMPUTE_INIT
7952 | OPTI_TYPE_PRECOMPUTE_MERKLE
7953 | OPTI_TYPE_EARLY_SKIP
7954 | OPTI_TYPE_NOT_ITERATED
7955 | OPTI_TYPE_PREPENDED_SALT
7956 | OPTI_TYPE_RAW_HASH;
7957 dgst_pos0 = 3;
7958 dgst_pos1 = 4;
7959 dgst_pos2 = 2;
7960 dgst_pos3 = 1;
7961 break;
7962
7963 case 125: hash_type = HASH_TYPE_SHA1;
7964 salt_type = SALT_TYPE_EMBEDDED;
7965 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7966 opts_type = OPTS_TYPE_PT_GENERATE_BE
7967 | OPTS_TYPE_PT_ADD80
7968 | OPTS_TYPE_PT_ADDBITS15
7969 | OPTS_TYPE_ST_HEX;
7970 kern_type = KERN_TYPE_SHA1_SLTPW;
7971 dgst_size = DGST_SIZE_4_5;
7972 parse_func = arubaos_parse_hash;
7973 sort_by_digest = sort_by_digest_4_5;
7974 opti_type = OPTI_TYPE_ZERO_BYTE
7975 | OPTI_TYPE_PRECOMPUTE_INIT
7976 | OPTI_TYPE_PRECOMPUTE_MERKLE
7977 | OPTI_TYPE_EARLY_SKIP
7978 | OPTI_TYPE_NOT_ITERATED
7979 | OPTI_TYPE_PREPENDED_SALT
7980 | OPTI_TYPE_RAW_HASH;
7981 dgst_pos0 = 3;
7982 dgst_pos1 = 4;
7983 dgst_pos2 = 2;
7984 dgst_pos3 = 1;
7985 break;
7986
7987 case 130: hash_type = HASH_TYPE_SHA1;
7988 salt_type = SALT_TYPE_INTERN;
7989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7990 opts_type = OPTS_TYPE_PT_GENERATE_BE
7991 | OPTS_TYPE_PT_UNICODE
7992 | OPTS_TYPE_ST_ADD80
7993 | OPTS_TYPE_ST_ADDBITS15;
7994 kern_type = KERN_TYPE_SHA1_PWUSLT;
7995 dgst_size = DGST_SIZE_4_5;
7996 parse_func = sha1s_parse_hash;
7997 sort_by_digest = sort_by_digest_4_5;
7998 opti_type = OPTI_TYPE_ZERO_BYTE
7999 | OPTI_TYPE_PRECOMPUTE_INIT
8000 | OPTI_TYPE_PRECOMPUTE_MERKLE
8001 | OPTI_TYPE_EARLY_SKIP
8002 | OPTI_TYPE_NOT_ITERATED
8003 | OPTI_TYPE_APPENDED_SALT
8004 | OPTI_TYPE_RAW_HASH;
8005 dgst_pos0 = 3;
8006 dgst_pos1 = 4;
8007 dgst_pos2 = 2;
8008 dgst_pos3 = 1;
8009 break;
8010
8011 case 131: hash_type = HASH_TYPE_SHA1;
8012 salt_type = SALT_TYPE_EMBEDDED;
8013 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8014 opts_type = OPTS_TYPE_PT_GENERATE_BE
8015 | OPTS_TYPE_PT_UNICODE
8016 | OPTS_TYPE_PT_UPPER
8017 | OPTS_TYPE_ST_ADD80
8018 | OPTS_TYPE_ST_ADDBITS15
8019 | OPTS_TYPE_ST_HEX;
8020 kern_type = KERN_TYPE_SHA1_PWUSLT;
8021 dgst_size = DGST_SIZE_4_5;
8022 parse_func = mssql2000_parse_hash;
8023 sort_by_digest = sort_by_digest_4_5;
8024 opti_type = OPTI_TYPE_ZERO_BYTE
8025 | OPTI_TYPE_PRECOMPUTE_INIT
8026 | OPTI_TYPE_PRECOMPUTE_MERKLE
8027 | OPTI_TYPE_EARLY_SKIP
8028 | OPTI_TYPE_NOT_ITERATED
8029 | OPTI_TYPE_APPENDED_SALT
8030 | OPTI_TYPE_RAW_HASH;
8031 dgst_pos0 = 3;
8032 dgst_pos1 = 4;
8033 dgst_pos2 = 2;
8034 dgst_pos3 = 1;
8035 break;
8036
8037 case 132: hash_type = HASH_TYPE_SHA1;
8038 salt_type = SALT_TYPE_EMBEDDED;
8039 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8040 opts_type = OPTS_TYPE_PT_GENERATE_BE
8041 | OPTS_TYPE_PT_UNICODE
8042 | OPTS_TYPE_ST_ADD80
8043 | OPTS_TYPE_ST_ADDBITS15
8044 | OPTS_TYPE_ST_HEX;
8045 kern_type = KERN_TYPE_SHA1_PWUSLT;
8046 dgst_size = DGST_SIZE_4_5;
8047 parse_func = mssql2005_parse_hash;
8048 sort_by_digest = sort_by_digest_4_5;
8049 opti_type = OPTI_TYPE_ZERO_BYTE
8050 | OPTI_TYPE_PRECOMPUTE_INIT
8051 | OPTI_TYPE_PRECOMPUTE_MERKLE
8052 | OPTI_TYPE_EARLY_SKIP
8053 | OPTI_TYPE_NOT_ITERATED
8054 | OPTI_TYPE_APPENDED_SALT
8055 | OPTI_TYPE_RAW_HASH;
8056 dgst_pos0 = 3;
8057 dgst_pos1 = 4;
8058 dgst_pos2 = 2;
8059 dgst_pos3 = 1;
8060 break;
8061
8062 case 133: hash_type = HASH_TYPE_SHA1;
8063 salt_type = SALT_TYPE_EMBEDDED;
8064 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8065 opts_type = OPTS_TYPE_PT_GENERATE_BE
8066 | OPTS_TYPE_PT_UNICODE
8067 | OPTS_TYPE_ST_ADD80
8068 | OPTS_TYPE_ST_ADDBITS15;
8069 kern_type = KERN_TYPE_SHA1_PWUSLT;
8070 dgst_size = DGST_SIZE_4_5;
8071 parse_func = peoplesoft_parse_hash;
8072 sort_by_digest = sort_by_digest_4_5;
8073 opti_type = OPTI_TYPE_ZERO_BYTE
8074 | OPTI_TYPE_PRECOMPUTE_INIT
8075 | OPTI_TYPE_PRECOMPUTE_MERKLE
8076 | OPTI_TYPE_EARLY_SKIP
8077 | OPTI_TYPE_NOT_ITERATED
8078 | OPTI_TYPE_APPENDED_SALT
8079 | OPTI_TYPE_RAW_HASH;
8080 dgst_pos0 = 3;
8081 dgst_pos1 = 4;
8082 dgst_pos2 = 2;
8083 dgst_pos3 = 1;
8084 break;
8085
8086 case 140: hash_type = HASH_TYPE_SHA1;
8087 salt_type = SALT_TYPE_INTERN;
8088 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8089 opts_type = OPTS_TYPE_PT_GENERATE_BE
8090 | OPTS_TYPE_PT_ADD80
8091 | OPTS_TYPE_PT_ADDBITS15
8092 | OPTS_TYPE_PT_UNICODE;
8093 kern_type = KERN_TYPE_SHA1_SLTPWU;
8094 dgst_size = DGST_SIZE_4_5;
8095 parse_func = sha1s_parse_hash;
8096 sort_by_digest = sort_by_digest_4_5;
8097 opti_type = OPTI_TYPE_ZERO_BYTE
8098 | OPTI_TYPE_PRECOMPUTE_INIT
8099 | OPTI_TYPE_PRECOMPUTE_MERKLE
8100 | OPTI_TYPE_EARLY_SKIP
8101 | OPTI_TYPE_NOT_ITERATED
8102 | OPTI_TYPE_PREPENDED_SALT
8103 | OPTI_TYPE_RAW_HASH;
8104 dgst_pos0 = 3;
8105 dgst_pos1 = 4;
8106 dgst_pos2 = 2;
8107 dgst_pos3 = 1;
8108 break;
8109
8110 case 141: hash_type = HASH_TYPE_SHA1;
8111 salt_type = SALT_TYPE_EMBEDDED;
8112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8113 opts_type = OPTS_TYPE_PT_GENERATE_BE
8114 | OPTS_TYPE_PT_ADD80
8115 | OPTS_TYPE_PT_ADDBITS15
8116 | OPTS_TYPE_PT_UNICODE
8117 | OPTS_TYPE_ST_BASE64;
8118 kern_type = KERN_TYPE_SHA1_SLTPWU;
8119 dgst_size = DGST_SIZE_4_5;
8120 parse_func = episerver_parse_hash;
8121 sort_by_digest = sort_by_digest_4_5;
8122 opti_type = OPTI_TYPE_ZERO_BYTE
8123 | OPTI_TYPE_PRECOMPUTE_INIT
8124 | OPTI_TYPE_PRECOMPUTE_MERKLE
8125 | OPTI_TYPE_EARLY_SKIP
8126 | OPTI_TYPE_NOT_ITERATED
8127 | OPTI_TYPE_PREPENDED_SALT
8128 | OPTI_TYPE_RAW_HASH;
8129 dgst_pos0 = 3;
8130 dgst_pos1 = 4;
8131 dgst_pos2 = 2;
8132 dgst_pos3 = 1;
8133 break;
8134
8135 case 150: hash_type = HASH_TYPE_SHA1;
8136 salt_type = SALT_TYPE_INTERN;
8137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8138 opts_type = OPTS_TYPE_PT_GENERATE_BE
8139 | OPTS_TYPE_ST_ADD80
8140 | OPTS_TYPE_ST_ADDBITS15;
8141 kern_type = KERN_TYPE_HMACSHA1_PW;
8142 dgst_size = DGST_SIZE_4_5;
8143 parse_func = hmacsha1_parse_hash;
8144 sort_by_digest = sort_by_digest_4_5;
8145 opti_type = OPTI_TYPE_ZERO_BYTE
8146 | OPTI_TYPE_NOT_ITERATED;
8147 dgst_pos0 = 3;
8148 dgst_pos1 = 4;
8149 dgst_pos2 = 2;
8150 dgst_pos3 = 1;
8151 break;
8152
8153 case 160: hash_type = HASH_TYPE_SHA1;
8154 salt_type = SALT_TYPE_INTERN;
8155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8156 opts_type = OPTS_TYPE_PT_GENERATE_BE
8157 | OPTS_TYPE_PT_ADD80
8158 | OPTS_TYPE_PT_ADDBITS15;
8159 kern_type = KERN_TYPE_HMACSHA1_SLT;
8160 dgst_size = DGST_SIZE_4_5;
8161 parse_func = hmacsha1_parse_hash;
8162 sort_by_digest = sort_by_digest_4_5;
8163 opti_type = OPTI_TYPE_ZERO_BYTE
8164 | OPTI_TYPE_NOT_ITERATED;
8165 dgst_pos0 = 3;
8166 dgst_pos1 = 4;
8167 dgst_pos2 = 2;
8168 dgst_pos3 = 1;
8169 break;
8170
8171 case 200: hash_type = HASH_TYPE_MYSQL;
8172 salt_type = SALT_TYPE_NONE;
8173 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8174 opts_type = 0;
8175 kern_type = KERN_TYPE_MYSQL;
8176 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8177 parse_func = mysql323_parse_hash;
8178 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8179 opti_type = OPTI_TYPE_ZERO_BYTE;
8180 dgst_pos0 = 0;
8181 dgst_pos1 = 1;
8182 dgst_pos2 = 2;
8183 dgst_pos3 = 3;
8184 break;
8185
8186 case 300: hash_type = HASH_TYPE_SHA1;
8187 salt_type = SALT_TYPE_NONE;
8188 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8189 opts_type = OPTS_TYPE_PT_GENERATE_BE
8190 | OPTS_TYPE_PT_ADD80
8191 | OPTS_TYPE_PT_ADDBITS15;
8192 kern_type = KERN_TYPE_MYSQL41;
8193 dgst_size = DGST_SIZE_4_5;
8194 parse_func = sha1_parse_hash;
8195 sort_by_digest = sort_by_digest_4_5;
8196 opti_type = OPTI_TYPE_ZERO_BYTE
8197 | OPTI_TYPE_PRECOMPUTE_INIT
8198 | OPTI_TYPE_PRECOMPUTE_MERKLE
8199 | OPTI_TYPE_EARLY_SKIP
8200 | OPTI_TYPE_NOT_ITERATED
8201 | OPTI_TYPE_NOT_SALTED;
8202 dgst_pos0 = 3;
8203 dgst_pos1 = 4;
8204 dgst_pos2 = 2;
8205 dgst_pos3 = 1;
8206 break;
8207
8208 case 400: hash_type = HASH_TYPE_MD5;
8209 salt_type = SALT_TYPE_EMBEDDED;
8210 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8211 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8212 kern_type = KERN_TYPE_PHPASS;
8213 dgst_size = DGST_SIZE_4_4;
8214 parse_func = phpass_parse_hash;
8215 sort_by_digest = sort_by_digest_4_4;
8216 opti_type = OPTI_TYPE_ZERO_BYTE
8217 | OPTI_TYPE_SLOW_HASH_SIMD;
8218 dgst_pos0 = 0;
8219 dgst_pos1 = 1;
8220 dgst_pos2 = 2;
8221 dgst_pos3 = 3;
8222 break;
8223
8224 case 500: hash_type = HASH_TYPE_MD5;
8225 salt_type = SALT_TYPE_EMBEDDED;
8226 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8227 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8228 kern_type = KERN_TYPE_MD5CRYPT;
8229 dgst_size = DGST_SIZE_4_4;
8230 parse_func = md5crypt_parse_hash;
8231 sort_by_digest = sort_by_digest_4_4;
8232 opti_type = OPTI_TYPE_ZERO_BYTE;
8233 dgst_pos0 = 0;
8234 dgst_pos1 = 1;
8235 dgst_pos2 = 2;
8236 dgst_pos3 = 3;
8237 break;
8238
8239 case 501: hash_type = HASH_TYPE_MD5;
8240 salt_type = SALT_TYPE_EMBEDDED;
8241 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8242 opts_type = OPTS_TYPE_PT_GENERATE_LE
8243 | OPTS_TYPE_HASH_COPY;
8244 kern_type = KERN_TYPE_MD5CRYPT;
8245 dgst_size = DGST_SIZE_4_4;
8246 parse_func = juniper_parse_hash;
8247 sort_by_digest = sort_by_digest_4_4;
8248 opti_type = OPTI_TYPE_ZERO_BYTE;
8249 dgst_pos0 = 0;
8250 dgst_pos1 = 1;
8251 dgst_pos2 = 2;
8252 dgst_pos3 = 3;
8253 break;
8254
8255 case 900: hash_type = HASH_TYPE_MD4;
8256 salt_type = SALT_TYPE_NONE;
8257 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8258 opts_type = OPTS_TYPE_PT_GENERATE_LE
8259 | OPTS_TYPE_PT_ADD80
8260 | OPTS_TYPE_PT_ADDBITS14;
8261 kern_type = KERN_TYPE_MD4;
8262 dgst_size = DGST_SIZE_4_4;
8263 parse_func = md4_parse_hash;
8264 sort_by_digest = sort_by_digest_4_4;
8265 opti_type = OPTI_TYPE_ZERO_BYTE
8266 | OPTI_TYPE_PRECOMPUTE_INIT
8267 | OPTI_TYPE_PRECOMPUTE_MERKLE
8268 | OPTI_TYPE_MEET_IN_MIDDLE
8269 | OPTI_TYPE_EARLY_SKIP
8270 | OPTI_TYPE_NOT_ITERATED
8271 | OPTI_TYPE_NOT_SALTED
8272 | OPTI_TYPE_RAW_HASH;
8273 dgst_pos0 = 0;
8274 dgst_pos1 = 3;
8275 dgst_pos2 = 2;
8276 dgst_pos3 = 1;
8277 break;
8278
8279 case 1000: hash_type = HASH_TYPE_MD4;
8280 salt_type = SALT_TYPE_NONE;
8281 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8282 opts_type = OPTS_TYPE_PT_GENERATE_LE
8283 | OPTS_TYPE_PT_ADD80
8284 | OPTS_TYPE_PT_ADDBITS14
8285 | OPTS_TYPE_PT_UNICODE;
8286 kern_type = KERN_TYPE_MD4_PWU;
8287 dgst_size = DGST_SIZE_4_4;
8288 parse_func = md4_parse_hash;
8289 sort_by_digest = sort_by_digest_4_4;
8290 opti_type = OPTI_TYPE_ZERO_BYTE
8291 | OPTI_TYPE_PRECOMPUTE_INIT
8292 | OPTI_TYPE_PRECOMPUTE_MERKLE
8293 | OPTI_TYPE_MEET_IN_MIDDLE
8294 | OPTI_TYPE_EARLY_SKIP
8295 | OPTI_TYPE_NOT_ITERATED
8296 | OPTI_TYPE_NOT_SALTED
8297 | OPTI_TYPE_RAW_HASH;
8298 dgst_pos0 = 0;
8299 dgst_pos1 = 3;
8300 dgst_pos2 = 2;
8301 dgst_pos3 = 1;
8302 break;
8303
8304 case 1100: hash_type = HASH_TYPE_MD4;
8305 salt_type = SALT_TYPE_INTERN;
8306 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8307 opts_type = OPTS_TYPE_PT_GENERATE_LE
8308 | OPTS_TYPE_PT_ADD80
8309 | OPTS_TYPE_PT_ADDBITS14
8310 | OPTS_TYPE_PT_UNICODE
8311 | OPTS_TYPE_ST_ADD80
8312 | OPTS_TYPE_ST_UNICODE
8313 | OPTS_TYPE_ST_LOWER;
8314 kern_type = KERN_TYPE_MD44_PWUSLT;
8315 dgst_size = DGST_SIZE_4_4;
8316 parse_func = dcc_parse_hash;
8317 sort_by_digest = sort_by_digest_4_4;
8318 opti_type = OPTI_TYPE_ZERO_BYTE
8319 | OPTI_TYPE_PRECOMPUTE_INIT
8320 | OPTI_TYPE_PRECOMPUTE_MERKLE
8321 | OPTI_TYPE_EARLY_SKIP
8322 | OPTI_TYPE_NOT_ITERATED;
8323 dgst_pos0 = 0;
8324 dgst_pos1 = 3;
8325 dgst_pos2 = 2;
8326 dgst_pos3 = 1;
8327 break;
8328
8329 case 1400: hash_type = HASH_TYPE_SHA256;
8330 salt_type = SALT_TYPE_NONE;
8331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8332 opts_type = OPTS_TYPE_PT_GENERATE_BE
8333 | OPTS_TYPE_PT_ADD80
8334 | OPTS_TYPE_PT_ADDBITS15;
8335 kern_type = KERN_TYPE_SHA256;
8336 dgst_size = DGST_SIZE_4_8;
8337 parse_func = sha256_parse_hash;
8338 sort_by_digest = sort_by_digest_4_8;
8339 opti_type = OPTI_TYPE_ZERO_BYTE
8340 | OPTI_TYPE_PRECOMPUTE_INIT
8341 | OPTI_TYPE_PRECOMPUTE_MERKLE
8342 | OPTI_TYPE_EARLY_SKIP
8343 | OPTI_TYPE_NOT_ITERATED
8344 | OPTI_TYPE_NOT_SALTED
8345 | OPTI_TYPE_RAW_HASH;
8346 dgst_pos0 = 3;
8347 dgst_pos1 = 7;
8348 dgst_pos2 = 2;
8349 dgst_pos3 = 6;
8350 break;
8351
8352 case 1410: hash_type = HASH_TYPE_SHA256;
8353 salt_type = SALT_TYPE_INTERN;
8354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8355 opts_type = OPTS_TYPE_PT_GENERATE_BE
8356 | OPTS_TYPE_ST_ADD80
8357 | OPTS_TYPE_ST_ADDBITS15;
8358 kern_type = KERN_TYPE_SHA256_PWSLT;
8359 dgst_size = DGST_SIZE_4_8;
8360 parse_func = sha256s_parse_hash;
8361 sort_by_digest = sort_by_digest_4_8;
8362 opti_type = OPTI_TYPE_ZERO_BYTE
8363 | OPTI_TYPE_PRECOMPUTE_INIT
8364 | OPTI_TYPE_PRECOMPUTE_MERKLE
8365 | OPTI_TYPE_EARLY_SKIP
8366 | OPTI_TYPE_NOT_ITERATED
8367 | OPTI_TYPE_APPENDED_SALT
8368 | OPTI_TYPE_RAW_HASH;
8369 dgst_pos0 = 3;
8370 dgst_pos1 = 7;
8371 dgst_pos2 = 2;
8372 dgst_pos3 = 6;
8373 break;
8374
8375 case 1420: hash_type = HASH_TYPE_SHA256;
8376 salt_type = SALT_TYPE_INTERN;
8377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8378 opts_type = OPTS_TYPE_PT_GENERATE_BE
8379 | OPTS_TYPE_PT_ADD80
8380 | OPTS_TYPE_PT_ADDBITS15;
8381 kern_type = KERN_TYPE_SHA256_SLTPW;
8382 dgst_size = DGST_SIZE_4_8;
8383 parse_func = sha256s_parse_hash;
8384 sort_by_digest = sort_by_digest_4_8;
8385 opti_type = OPTI_TYPE_ZERO_BYTE
8386 | OPTI_TYPE_PRECOMPUTE_INIT
8387 | OPTI_TYPE_PRECOMPUTE_MERKLE
8388 | OPTI_TYPE_EARLY_SKIP
8389 | OPTI_TYPE_NOT_ITERATED
8390 | OPTI_TYPE_PREPENDED_SALT
8391 | OPTI_TYPE_RAW_HASH;
8392 dgst_pos0 = 3;
8393 dgst_pos1 = 7;
8394 dgst_pos2 = 2;
8395 dgst_pos3 = 6;
8396 break;
8397
8398 case 1421: hash_type = HASH_TYPE_SHA256;
8399 salt_type = SALT_TYPE_EMBEDDED;
8400 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8401 opts_type = OPTS_TYPE_PT_GENERATE_BE
8402 | OPTS_TYPE_PT_ADD80
8403 | OPTS_TYPE_PT_ADDBITS15;
8404 kern_type = KERN_TYPE_SHA256_SLTPW;
8405 dgst_size = DGST_SIZE_4_8;
8406 parse_func = hmailserver_parse_hash;
8407 sort_by_digest = sort_by_digest_4_8;
8408 opti_type = OPTI_TYPE_ZERO_BYTE
8409 | OPTI_TYPE_PRECOMPUTE_INIT
8410 | OPTI_TYPE_PRECOMPUTE_MERKLE
8411 | OPTI_TYPE_EARLY_SKIP
8412 | OPTI_TYPE_NOT_ITERATED
8413 | OPTI_TYPE_PREPENDED_SALT
8414 | OPTI_TYPE_RAW_HASH;
8415 dgst_pos0 = 3;
8416 dgst_pos1 = 7;
8417 dgst_pos2 = 2;
8418 dgst_pos3 = 6;
8419 break;
8420
8421 case 1430: hash_type = HASH_TYPE_SHA256;
8422 salt_type = SALT_TYPE_INTERN;
8423 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8424 opts_type = OPTS_TYPE_PT_GENERATE_BE
8425 | OPTS_TYPE_PT_UNICODE
8426 | OPTS_TYPE_ST_ADD80
8427 | OPTS_TYPE_ST_ADDBITS15;
8428 kern_type = KERN_TYPE_SHA256_PWUSLT;
8429 dgst_size = DGST_SIZE_4_8;
8430 parse_func = sha256s_parse_hash;
8431 sort_by_digest = sort_by_digest_4_8;
8432 opti_type = OPTI_TYPE_ZERO_BYTE
8433 | OPTI_TYPE_PRECOMPUTE_INIT
8434 | OPTI_TYPE_PRECOMPUTE_MERKLE
8435 | OPTI_TYPE_EARLY_SKIP
8436 | OPTI_TYPE_NOT_ITERATED
8437 | OPTI_TYPE_APPENDED_SALT
8438 | OPTI_TYPE_RAW_HASH;
8439 dgst_pos0 = 3;
8440 dgst_pos1 = 7;
8441 dgst_pos2 = 2;
8442 dgst_pos3 = 6;
8443 break;
8444
8445 case 1440: hash_type = HASH_TYPE_SHA256;
8446 salt_type = SALT_TYPE_INTERN;
8447 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8448 opts_type = OPTS_TYPE_PT_GENERATE_BE
8449 | OPTS_TYPE_PT_ADD80
8450 | OPTS_TYPE_PT_ADDBITS15
8451 | OPTS_TYPE_PT_UNICODE;
8452 kern_type = KERN_TYPE_SHA256_SLTPWU;
8453 dgst_size = DGST_SIZE_4_8;
8454 parse_func = sha256s_parse_hash;
8455 sort_by_digest = sort_by_digest_4_8;
8456 opti_type = OPTI_TYPE_ZERO_BYTE
8457 | OPTI_TYPE_PRECOMPUTE_INIT
8458 | OPTI_TYPE_PRECOMPUTE_MERKLE
8459 | OPTI_TYPE_EARLY_SKIP
8460 | OPTI_TYPE_NOT_ITERATED
8461 | OPTI_TYPE_PREPENDED_SALT
8462 | OPTI_TYPE_RAW_HASH;
8463 dgst_pos0 = 3;
8464 dgst_pos1 = 7;
8465 dgst_pos2 = 2;
8466 dgst_pos3 = 6;
8467 break;
8468
8469 case 1441: hash_type = HASH_TYPE_SHA256;
8470 salt_type = SALT_TYPE_EMBEDDED;
8471 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8472 opts_type = OPTS_TYPE_PT_GENERATE_BE
8473 | OPTS_TYPE_PT_ADD80
8474 | OPTS_TYPE_PT_ADDBITS15
8475 | OPTS_TYPE_PT_UNICODE
8476 | OPTS_TYPE_ST_BASE64;
8477 kern_type = KERN_TYPE_SHA256_SLTPWU;
8478 dgst_size = DGST_SIZE_4_8;
8479 parse_func = episerver4_parse_hash;
8480 sort_by_digest = sort_by_digest_4_8;
8481 opti_type = OPTI_TYPE_ZERO_BYTE
8482 | OPTI_TYPE_PRECOMPUTE_INIT
8483 | OPTI_TYPE_PRECOMPUTE_MERKLE
8484 | OPTI_TYPE_EARLY_SKIP
8485 | OPTI_TYPE_NOT_ITERATED
8486 | OPTI_TYPE_PREPENDED_SALT
8487 | OPTI_TYPE_RAW_HASH;
8488 dgst_pos0 = 3;
8489 dgst_pos1 = 7;
8490 dgst_pos2 = 2;
8491 dgst_pos3 = 6;
8492 break;
8493
8494 case 1450: hash_type = HASH_TYPE_SHA256;
8495 salt_type = SALT_TYPE_INTERN;
8496 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8497 opts_type = OPTS_TYPE_PT_GENERATE_BE
8498 | OPTS_TYPE_ST_ADD80;
8499 kern_type = KERN_TYPE_HMACSHA256_PW;
8500 dgst_size = DGST_SIZE_4_8;
8501 parse_func = hmacsha256_parse_hash;
8502 sort_by_digest = sort_by_digest_4_8;
8503 opti_type = OPTI_TYPE_ZERO_BYTE
8504 | OPTI_TYPE_NOT_ITERATED;
8505 dgst_pos0 = 3;
8506 dgst_pos1 = 7;
8507 dgst_pos2 = 2;
8508 dgst_pos3 = 6;
8509 break;
8510
8511 case 1460: hash_type = HASH_TYPE_SHA256;
8512 salt_type = SALT_TYPE_INTERN;
8513 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8514 opts_type = OPTS_TYPE_PT_GENERATE_BE
8515 | OPTS_TYPE_PT_ADD80
8516 | OPTS_TYPE_PT_ADDBITS15;
8517 kern_type = KERN_TYPE_HMACSHA256_SLT;
8518 dgst_size = DGST_SIZE_4_8;
8519 parse_func = hmacsha256_parse_hash;
8520 sort_by_digest = sort_by_digest_4_8;
8521 opti_type = OPTI_TYPE_ZERO_BYTE
8522 | OPTI_TYPE_NOT_ITERATED;
8523 dgst_pos0 = 3;
8524 dgst_pos1 = 7;
8525 dgst_pos2 = 2;
8526 dgst_pos3 = 6;
8527 break;
8528
8529 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8530 salt_type = SALT_TYPE_EMBEDDED;
8531 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8532 opts_type = OPTS_TYPE_PT_GENERATE_LE
8533 | OPTS_TYPE_PT_BITSLICE;
8534 kern_type = KERN_TYPE_DESCRYPT;
8535 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8536 parse_func = descrypt_parse_hash;
8537 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8538 opti_type = OPTI_TYPE_ZERO_BYTE
8539 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8540 dgst_pos0 = 0;
8541 dgst_pos1 = 1;
8542 dgst_pos2 = 2;
8543 dgst_pos3 = 3;
8544 break;
8545
8546 case 1600: hash_type = HASH_TYPE_MD5;
8547 salt_type = SALT_TYPE_EMBEDDED;
8548 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8549 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8550 kern_type = KERN_TYPE_APR1CRYPT;
8551 dgst_size = DGST_SIZE_4_4;
8552 parse_func = md5apr1_parse_hash;
8553 sort_by_digest = sort_by_digest_4_4;
8554 opti_type = OPTI_TYPE_ZERO_BYTE;
8555 dgst_pos0 = 0;
8556 dgst_pos1 = 1;
8557 dgst_pos2 = 2;
8558 dgst_pos3 = 3;
8559 break;
8560
8561 case 1700: hash_type = HASH_TYPE_SHA512;
8562 salt_type = SALT_TYPE_NONE;
8563 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8564 opts_type = OPTS_TYPE_PT_GENERATE_BE
8565 | OPTS_TYPE_PT_ADD80
8566 | OPTS_TYPE_PT_ADDBITS15;
8567 kern_type = KERN_TYPE_SHA512;
8568 dgst_size = DGST_SIZE_8_8;
8569 parse_func = sha512_parse_hash;
8570 sort_by_digest = sort_by_digest_8_8;
8571 opti_type = OPTI_TYPE_ZERO_BYTE
8572 | OPTI_TYPE_PRECOMPUTE_INIT
8573 | OPTI_TYPE_PRECOMPUTE_MERKLE
8574 | OPTI_TYPE_EARLY_SKIP
8575 | OPTI_TYPE_NOT_ITERATED
8576 | OPTI_TYPE_NOT_SALTED
8577 | OPTI_TYPE_USES_BITS_64
8578 | OPTI_TYPE_RAW_HASH;
8579 dgst_pos0 = 14;
8580 dgst_pos1 = 15;
8581 dgst_pos2 = 6;
8582 dgst_pos3 = 7;
8583 break;
8584
8585 case 1710: hash_type = HASH_TYPE_SHA512;
8586 salt_type = SALT_TYPE_INTERN;
8587 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8588 opts_type = OPTS_TYPE_PT_GENERATE_BE
8589 | OPTS_TYPE_ST_ADD80
8590 | OPTS_TYPE_ST_ADDBITS15;
8591 kern_type = KERN_TYPE_SHA512_PWSLT;
8592 dgst_size = DGST_SIZE_8_8;
8593 parse_func = sha512s_parse_hash;
8594 sort_by_digest = sort_by_digest_8_8;
8595 opti_type = OPTI_TYPE_ZERO_BYTE
8596 | OPTI_TYPE_PRECOMPUTE_INIT
8597 | OPTI_TYPE_PRECOMPUTE_MERKLE
8598 | OPTI_TYPE_EARLY_SKIP
8599 | OPTI_TYPE_NOT_ITERATED
8600 | OPTI_TYPE_APPENDED_SALT
8601 | OPTI_TYPE_USES_BITS_64
8602 | OPTI_TYPE_RAW_HASH;
8603 dgst_pos0 = 14;
8604 dgst_pos1 = 15;
8605 dgst_pos2 = 6;
8606 dgst_pos3 = 7;
8607 break;
8608
8609 case 1711: hash_type = HASH_TYPE_SHA512;
8610 salt_type = SALT_TYPE_EMBEDDED;
8611 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8612 opts_type = OPTS_TYPE_PT_GENERATE_BE
8613 | OPTS_TYPE_ST_ADD80
8614 | OPTS_TYPE_ST_ADDBITS15;
8615 kern_type = KERN_TYPE_SHA512_PWSLT;
8616 dgst_size = DGST_SIZE_8_8;
8617 parse_func = sha512b64s_parse_hash;
8618 sort_by_digest = sort_by_digest_8_8;
8619 opti_type = OPTI_TYPE_ZERO_BYTE
8620 | OPTI_TYPE_PRECOMPUTE_INIT
8621 | OPTI_TYPE_PRECOMPUTE_MERKLE
8622 | OPTI_TYPE_EARLY_SKIP
8623 | OPTI_TYPE_NOT_ITERATED
8624 | OPTI_TYPE_APPENDED_SALT
8625 | OPTI_TYPE_USES_BITS_64
8626 | OPTI_TYPE_RAW_HASH;
8627 dgst_pos0 = 14;
8628 dgst_pos1 = 15;
8629 dgst_pos2 = 6;
8630 dgst_pos3 = 7;
8631 break;
8632
8633 case 1720: hash_type = HASH_TYPE_SHA512;
8634 salt_type = SALT_TYPE_INTERN;
8635 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8636 opts_type = OPTS_TYPE_PT_GENERATE_BE
8637 | OPTS_TYPE_PT_ADD80
8638 | OPTS_TYPE_PT_ADDBITS15;
8639 kern_type = KERN_TYPE_SHA512_SLTPW;
8640 dgst_size = DGST_SIZE_8_8;
8641 parse_func = sha512s_parse_hash;
8642 sort_by_digest = sort_by_digest_8_8;
8643 opti_type = OPTI_TYPE_ZERO_BYTE
8644 | OPTI_TYPE_PRECOMPUTE_INIT
8645 | OPTI_TYPE_PRECOMPUTE_MERKLE
8646 | OPTI_TYPE_EARLY_SKIP
8647 | OPTI_TYPE_NOT_ITERATED
8648 | OPTI_TYPE_PREPENDED_SALT
8649 | OPTI_TYPE_USES_BITS_64
8650 | OPTI_TYPE_RAW_HASH;
8651 dgst_pos0 = 14;
8652 dgst_pos1 = 15;
8653 dgst_pos2 = 6;
8654 dgst_pos3 = 7;
8655 break;
8656
8657 case 1722: hash_type = HASH_TYPE_SHA512;
8658 salt_type = SALT_TYPE_EMBEDDED;
8659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8660 opts_type = OPTS_TYPE_PT_GENERATE_BE
8661 | OPTS_TYPE_PT_ADD80
8662 | OPTS_TYPE_PT_ADDBITS15
8663 | OPTS_TYPE_ST_HEX;
8664 kern_type = KERN_TYPE_SHA512_SLTPW;
8665 dgst_size = DGST_SIZE_8_8;
8666 parse_func = osx512_parse_hash;
8667 sort_by_digest = sort_by_digest_8_8;
8668 opti_type = OPTI_TYPE_ZERO_BYTE
8669 | OPTI_TYPE_PRECOMPUTE_INIT
8670 | OPTI_TYPE_PRECOMPUTE_MERKLE
8671 | OPTI_TYPE_EARLY_SKIP
8672 | OPTI_TYPE_NOT_ITERATED
8673 | OPTI_TYPE_PREPENDED_SALT
8674 | OPTI_TYPE_USES_BITS_64
8675 | OPTI_TYPE_RAW_HASH;
8676 dgst_pos0 = 14;
8677 dgst_pos1 = 15;
8678 dgst_pos2 = 6;
8679 dgst_pos3 = 7;
8680 break;
8681
8682 case 1730: hash_type = HASH_TYPE_SHA512;
8683 salt_type = SALT_TYPE_INTERN;
8684 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8685 opts_type = OPTS_TYPE_PT_GENERATE_BE
8686 | OPTS_TYPE_PT_UNICODE
8687 | OPTS_TYPE_ST_ADD80
8688 | OPTS_TYPE_ST_ADDBITS15;
8689 kern_type = KERN_TYPE_SHA512_PWSLTU;
8690 dgst_size = DGST_SIZE_8_8;
8691 parse_func = sha512s_parse_hash;
8692 sort_by_digest = sort_by_digest_8_8;
8693 opti_type = OPTI_TYPE_ZERO_BYTE
8694 | OPTI_TYPE_PRECOMPUTE_INIT
8695 | OPTI_TYPE_PRECOMPUTE_MERKLE
8696 | OPTI_TYPE_EARLY_SKIP
8697 | OPTI_TYPE_NOT_ITERATED
8698 | OPTI_TYPE_APPENDED_SALT
8699 | OPTI_TYPE_USES_BITS_64
8700 | OPTI_TYPE_RAW_HASH;
8701 dgst_pos0 = 14;
8702 dgst_pos1 = 15;
8703 dgst_pos2 = 6;
8704 dgst_pos3 = 7;
8705 break;
8706
8707 case 1731: hash_type = HASH_TYPE_SHA512;
8708 salt_type = SALT_TYPE_EMBEDDED;
8709 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8710 opts_type = OPTS_TYPE_PT_GENERATE_BE
8711 | OPTS_TYPE_PT_UNICODE
8712 | OPTS_TYPE_ST_ADD80
8713 | OPTS_TYPE_ST_ADDBITS15
8714 | OPTS_TYPE_ST_HEX;
8715 kern_type = KERN_TYPE_SHA512_PWSLTU;
8716 dgst_size = DGST_SIZE_8_8;
8717 parse_func = mssql2012_parse_hash;
8718 sort_by_digest = sort_by_digest_8_8;
8719 opti_type = OPTI_TYPE_ZERO_BYTE
8720 | OPTI_TYPE_PRECOMPUTE_INIT
8721 | OPTI_TYPE_PRECOMPUTE_MERKLE
8722 | OPTI_TYPE_EARLY_SKIP
8723 | OPTI_TYPE_NOT_ITERATED
8724 | OPTI_TYPE_APPENDED_SALT
8725 | OPTI_TYPE_USES_BITS_64
8726 | OPTI_TYPE_RAW_HASH;
8727 dgst_pos0 = 14;
8728 dgst_pos1 = 15;
8729 dgst_pos2 = 6;
8730 dgst_pos3 = 7;
8731 break;
8732
8733 case 1740: hash_type = HASH_TYPE_SHA512;
8734 salt_type = SALT_TYPE_INTERN;
8735 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8736 opts_type = OPTS_TYPE_PT_GENERATE_BE
8737 | OPTS_TYPE_PT_ADD80
8738 | OPTS_TYPE_PT_ADDBITS15
8739 | OPTS_TYPE_PT_UNICODE;
8740 kern_type = KERN_TYPE_SHA512_SLTPWU;
8741 dgst_size = DGST_SIZE_8_8;
8742 parse_func = sha512s_parse_hash;
8743 sort_by_digest = sort_by_digest_8_8;
8744 opti_type = OPTI_TYPE_ZERO_BYTE
8745 | OPTI_TYPE_PRECOMPUTE_INIT
8746 | OPTI_TYPE_PRECOMPUTE_MERKLE
8747 | OPTI_TYPE_EARLY_SKIP
8748 | OPTI_TYPE_NOT_ITERATED
8749 | OPTI_TYPE_PREPENDED_SALT
8750 | OPTI_TYPE_USES_BITS_64
8751 | OPTI_TYPE_RAW_HASH;
8752 dgst_pos0 = 14;
8753 dgst_pos1 = 15;
8754 dgst_pos2 = 6;
8755 dgst_pos3 = 7;
8756 break;
8757
8758 case 1750: hash_type = HASH_TYPE_SHA512;
8759 salt_type = SALT_TYPE_INTERN;
8760 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8761 opts_type = OPTS_TYPE_PT_GENERATE_BE
8762 | OPTS_TYPE_ST_ADD80;
8763 kern_type = KERN_TYPE_HMACSHA512_PW;
8764 dgst_size = DGST_SIZE_8_8;
8765 parse_func = hmacsha512_parse_hash;
8766 sort_by_digest = sort_by_digest_8_8;
8767 opti_type = OPTI_TYPE_ZERO_BYTE
8768 | OPTI_TYPE_USES_BITS_64
8769 | OPTI_TYPE_NOT_ITERATED;
8770 dgst_pos0 = 14;
8771 dgst_pos1 = 15;
8772 dgst_pos2 = 6;
8773 dgst_pos3 = 7;
8774 break;
8775
8776 case 1760: hash_type = HASH_TYPE_SHA512;
8777 salt_type = SALT_TYPE_INTERN;
8778 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8779 opts_type = OPTS_TYPE_PT_GENERATE_BE
8780 | OPTS_TYPE_PT_ADD80
8781 | OPTS_TYPE_PT_ADDBITS15;
8782 kern_type = KERN_TYPE_HMACSHA512_SLT;
8783 dgst_size = DGST_SIZE_8_8;
8784 parse_func = hmacsha512_parse_hash;
8785 sort_by_digest = sort_by_digest_8_8;
8786 opti_type = OPTI_TYPE_ZERO_BYTE
8787 | OPTI_TYPE_USES_BITS_64
8788 | OPTI_TYPE_NOT_ITERATED;
8789 dgst_pos0 = 14;
8790 dgst_pos1 = 15;
8791 dgst_pos2 = 6;
8792 dgst_pos3 = 7;
8793 break;
8794
8795 case 1800: hash_type = HASH_TYPE_SHA512;
8796 salt_type = SALT_TYPE_EMBEDDED;
8797 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8798 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8799 kern_type = KERN_TYPE_SHA512CRYPT;
8800 dgst_size = DGST_SIZE_8_8;
8801 parse_func = sha512crypt_parse_hash;
8802 sort_by_digest = sort_by_digest_8_8;
8803 opti_type = OPTI_TYPE_ZERO_BYTE
8804 | OPTI_TYPE_USES_BITS_64;
8805 dgst_pos0 = 0;
8806 dgst_pos1 = 1;
8807 dgst_pos2 = 2;
8808 dgst_pos3 = 3;
8809 break;
8810
8811 case 2000: hash_type = HASH_TYPE_STDOUT;
8812 salt_type = SALT_TYPE_NONE;
8813 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8814 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8815 kern_type = KERN_TYPE_STDOUT;
8816 dgst_size = DGST_SIZE_4_4;
8817 parse_func = NULL;
8818 sort_by_digest = NULL;
8819 opti_type = 0;
8820 dgst_pos0 = 0;
8821 dgst_pos1 = 0;
8822 dgst_pos2 = 0;
8823 dgst_pos3 = 0;
8824 break;
8825
8826 case 2100: hash_type = HASH_TYPE_DCC2;
8827 salt_type = SALT_TYPE_EMBEDDED;
8828 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8829 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8830 | OPTS_TYPE_ST_LOWER
8831 | OPTS_TYPE_ST_UNICODE;
8832 kern_type = KERN_TYPE_DCC2;
8833 dgst_size = DGST_SIZE_4_4;
8834 parse_func = dcc2_parse_hash;
8835 sort_by_digest = sort_by_digest_4_4;
8836 opti_type = OPTI_TYPE_ZERO_BYTE
8837 | OPTI_TYPE_SLOW_HASH_SIMD;
8838 dgst_pos0 = 0;
8839 dgst_pos1 = 1;
8840 dgst_pos2 = 2;
8841 dgst_pos3 = 3;
8842 break;
8843
8844 case 2400: hash_type = HASH_TYPE_MD5;
8845 salt_type = SALT_TYPE_NONE;
8846 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8847 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8848 kern_type = KERN_TYPE_MD5PIX;
8849 dgst_size = DGST_SIZE_4_4;
8850 parse_func = md5pix_parse_hash;
8851 sort_by_digest = sort_by_digest_4_4;
8852 opti_type = OPTI_TYPE_ZERO_BYTE
8853 | OPTI_TYPE_PRECOMPUTE_INIT
8854 | OPTI_TYPE_PRECOMPUTE_MERKLE
8855 | OPTI_TYPE_EARLY_SKIP
8856 | OPTI_TYPE_NOT_ITERATED
8857 | OPTI_TYPE_NOT_SALTED;
8858 dgst_pos0 = 0;
8859 dgst_pos1 = 3;
8860 dgst_pos2 = 2;
8861 dgst_pos3 = 1;
8862 break;
8863
8864 case 2410: hash_type = HASH_TYPE_MD5;
8865 salt_type = SALT_TYPE_INTERN;
8866 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8867 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8868 kern_type = KERN_TYPE_MD5ASA;
8869 dgst_size = DGST_SIZE_4_4;
8870 parse_func = md5asa_parse_hash;
8871 sort_by_digest = sort_by_digest_4_4;
8872 opti_type = OPTI_TYPE_ZERO_BYTE
8873 | OPTI_TYPE_PRECOMPUTE_INIT
8874 | OPTI_TYPE_PRECOMPUTE_MERKLE
8875 | OPTI_TYPE_EARLY_SKIP
8876 | OPTI_TYPE_NOT_ITERATED;
8877 dgst_pos0 = 0;
8878 dgst_pos1 = 3;
8879 dgst_pos2 = 2;
8880 dgst_pos3 = 1;
8881 break;
8882
8883 case 2500: hash_type = HASH_TYPE_WPA;
8884 salt_type = SALT_TYPE_EMBEDDED;
8885 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8886 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8887 kern_type = KERN_TYPE_WPA;
8888 dgst_size = DGST_SIZE_4_4;
8889 parse_func = wpa_parse_hash;
8890 sort_by_digest = sort_by_digest_4_4;
8891 opti_type = OPTI_TYPE_ZERO_BYTE
8892 | OPTI_TYPE_SLOW_HASH_SIMD;
8893 dgst_pos0 = 0;
8894 dgst_pos1 = 1;
8895 dgst_pos2 = 2;
8896 dgst_pos3 = 3;
8897 break;
8898
8899 case 2600: hash_type = HASH_TYPE_MD5;
8900 salt_type = SALT_TYPE_VIRTUAL;
8901 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8902 opts_type = OPTS_TYPE_PT_GENERATE_LE
8903 | OPTS_TYPE_PT_ADD80
8904 | OPTS_TYPE_PT_ADDBITS14
8905 | OPTS_TYPE_ST_ADD80;
8906 kern_type = KERN_TYPE_MD55_PWSLT1;
8907 dgst_size = DGST_SIZE_4_4;
8908 parse_func = md5md5_parse_hash;
8909 sort_by_digest = sort_by_digest_4_4;
8910 opti_type = OPTI_TYPE_ZERO_BYTE
8911 | OPTI_TYPE_PRECOMPUTE_INIT
8912 | OPTI_TYPE_PRECOMPUTE_MERKLE
8913 | OPTI_TYPE_EARLY_SKIP;
8914 dgst_pos0 = 0;
8915 dgst_pos1 = 3;
8916 dgst_pos2 = 2;
8917 dgst_pos3 = 1;
8918 break;
8919
8920 case 2611: hash_type = HASH_TYPE_MD5;
8921 salt_type = SALT_TYPE_INTERN;
8922 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8923 opts_type = OPTS_TYPE_PT_GENERATE_LE
8924 | OPTS_TYPE_PT_ADD80
8925 | OPTS_TYPE_PT_ADDBITS14
8926 | OPTS_TYPE_ST_ADD80;
8927 kern_type = KERN_TYPE_MD55_PWSLT1;
8928 dgst_size = DGST_SIZE_4_4;
8929 parse_func = vb3_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 2612: 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 | OPTS_TYPE_ST_ADD80
8948 | OPTS_TYPE_ST_HEX;
8949 kern_type = KERN_TYPE_MD55_PWSLT1;
8950 dgst_size = DGST_SIZE_4_4;
8951 parse_func = phps_parse_hash;
8952 sort_by_digest = sort_by_digest_4_4;
8953 opti_type = OPTI_TYPE_ZERO_BYTE
8954 | OPTI_TYPE_PRECOMPUTE_INIT
8955 | OPTI_TYPE_PRECOMPUTE_MERKLE
8956 | OPTI_TYPE_EARLY_SKIP;
8957 dgst_pos0 = 0;
8958 dgst_pos1 = 3;
8959 dgst_pos2 = 2;
8960 dgst_pos3 = 1;
8961 break;
8962
8963 case 2711: hash_type = HASH_TYPE_MD5;
8964 salt_type = SALT_TYPE_INTERN;
8965 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8966 opts_type = OPTS_TYPE_PT_GENERATE_LE
8967 | OPTS_TYPE_PT_ADD80
8968 | OPTS_TYPE_PT_ADDBITS14
8969 | OPTS_TYPE_ST_ADD80;
8970 kern_type = KERN_TYPE_MD55_PWSLT2;
8971 dgst_size = DGST_SIZE_4_4;
8972 parse_func = vb30_parse_hash;
8973 sort_by_digest = sort_by_digest_4_4;
8974 opti_type = OPTI_TYPE_ZERO_BYTE
8975 | OPTI_TYPE_PRECOMPUTE_INIT
8976 | OPTI_TYPE_EARLY_SKIP;
8977 dgst_pos0 = 0;
8978 dgst_pos1 = 3;
8979 dgst_pos2 = 2;
8980 dgst_pos3 = 1;
8981 break;
8982
8983 case 2811: hash_type = HASH_TYPE_MD5;
8984 salt_type = SALT_TYPE_INTERN;
8985 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8986 opts_type = OPTS_TYPE_PT_GENERATE_LE
8987 | OPTS_TYPE_PT_ADD80
8988 | OPTS_TYPE_PT_ADDBITS14;
8989 kern_type = KERN_TYPE_MD55_SLTPW;
8990 dgst_size = DGST_SIZE_4_4;
8991 parse_func = ipb2_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_EARLY_SKIP;
8996 dgst_pos0 = 0;
8997 dgst_pos1 = 3;
8998 dgst_pos2 = 2;
8999 dgst_pos3 = 1;
9000 break;
9001
9002 case 3000: hash_type = HASH_TYPE_LM;
9003 salt_type = SALT_TYPE_NONE;
9004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9005 opts_type = OPTS_TYPE_PT_GENERATE_LE
9006 | OPTS_TYPE_PT_UPPER
9007 | OPTS_TYPE_PT_BITSLICE;
9008 kern_type = KERN_TYPE_LM;
9009 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9010 parse_func = lm_parse_hash;
9011 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9012 opti_type = OPTI_TYPE_ZERO_BYTE
9013 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9014 dgst_pos0 = 0;
9015 dgst_pos1 = 1;
9016 dgst_pos2 = 2;
9017 dgst_pos3 = 3;
9018 break;
9019
9020 case 3100: hash_type = HASH_TYPE_ORACLEH;
9021 salt_type = SALT_TYPE_INTERN;
9022 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9023 opts_type = OPTS_TYPE_PT_GENERATE_LE
9024 | OPTS_TYPE_PT_UPPER
9025 | OPTS_TYPE_ST_UPPER;
9026 kern_type = KERN_TYPE_ORACLEH;
9027 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9028 parse_func = oracleh_parse_hash;
9029 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9030 opti_type = OPTI_TYPE_ZERO_BYTE;
9031 dgst_pos0 = 0;
9032 dgst_pos1 = 1;
9033 dgst_pos2 = 2;
9034 dgst_pos3 = 3;
9035 break;
9036
9037 case 3200: hash_type = HASH_TYPE_BCRYPT;
9038 salt_type = SALT_TYPE_EMBEDDED;
9039 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9040 opts_type = OPTS_TYPE_PT_GENERATE_LE
9041 | OPTS_TYPE_ST_GENERATE_LE;
9042 kern_type = KERN_TYPE_BCRYPT;
9043 dgst_size = DGST_SIZE_4_6;
9044 parse_func = bcrypt_parse_hash;
9045 sort_by_digest = sort_by_digest_4_6;
9046 opti_type = OPTI_TYPE_ZERO_BYTE;
9047 dgst_pos0 = 0;
9048 dgst_pos1 = 1;
9049 dgst_pos2 = 2;
9050 dgst_pos3 = 3;
9051 break;
9052
9053 case 3710: hash_type = HASH_TYPE_MD5;
9054 salt_type = SALT_TYPE_INTERN;
9055 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9056 opts_type = OPTS_TYPE_PT_GENERATE_LE
9057 | OPTS_TYPE_PT_ADD80
9058 | OPTS_TYPE_PT_ADDBITS14;
9059 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9060 dgst_size = DGST_SIZE_4_4;
9061 parse_func = md5s_parse_hash;
9062 sort_by_digest = sort_by_digest_4_4;
9063 opti_type = OPTI_TYPE_ZERO_BYTE
9064 | OPTI_TYPE_PRECOMPUTE_INIT
9065 | OPTI_TYPE_PRECOMPUTE_MERKLE
9066 | OPTI_TYPE_EARLY_SKIP;
9067 dgst_pos0 = 0;
9068 dgst_pos1 = 3;
9069 dgst_pos2 = 2;
9070 dgst_pos3 = 1;
9071 break;
9072
9073 case 3711: hash_type = HASH_TYPE_MD5;
9074 salt_type = SALT_TYPE_EMBEDDED;
9075 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9076 opts_type = OPTS_TYPE_PT_GENERATE_LE
9077 | OPTS_TYPE_PT_ADD80
9078 | OPTS_TYPE_PT_ADDBITS14;
9079 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9080 dgst_size = DGST_SIZE_4_4;
9081 parse_func = mediawiki_b_parse_hash;
9082 sort_by_digest = sort_by_digest_4_4;
9083 opti_type = OPTI_TYPE_ZERO_BYTE
9084 | OPTI_TYPE_PRECOMPUTE_INIT
9085 | OPTI_TYPE_PRECOMPUTE_MERKLE
9086 | OPTI_TYPE_EARLY_SKIP;
9087 dgst_pos0 = 0;
9088 dgst_pos1 = 3;
9089 dgst_pos2 = 2;
9090 dgst_pos3 = 1;
9091 break;
9092
9093 case 3800: hash_type = HASH_TYPE_MD5;
9094 salt_type = SALT_TYPE_INTERN;
9095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9096 opts_type = OPTS_TYPE_PT_GENERATE_LE
9097 | OPTS_TYPE_ST_ADDBITS14;
9098 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
9099 dgst_size = DGST_SIZE_4_4;
9100 parse_func = md5s_parse_hash;
9101 sort_by_digest = sort_by_digest_4_4;
9102 opti_type = OPTI_TYPE_ZERO_BYTE
9103 | OPTI_TYPE_PRECOMPUTE_INIT
9104 | OPTI_TYPE_PRECOMPUTE_MERKLE
9105 | OPTI_TYPE_EARLY_SKIP
9106 | OPTI_TYPE_NOT_ITERATED
9107 | OPTI_TYPE_RAW_HASH;
9108 dgst_pos0 = 0;
9109 dgst_pos1 = 3;
9110 dgst_pos2 = 2;
9111 dgst_pos3 = 1;
9112 break;
9113
9114 case 4300: hash_type = HASH_TYPE_MD5;
9115 salt_type = SALT_TYPE_VIRTUAL;
9116 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9117 opts_type = OPTS_TYPE_PT_GENERATE_LE
9118 | OPTS_TYPE_PT_ADD80
9119 | OPTS_TYPE_PT_ADDBITS14
9120 | OPTS_TYPE_ST_ADD80;
9121 kern_type = KERN_TYPE_MD5U5_PWSLT1;
9122 dgst_size = DGST_SIZE_4_4;
9123 parse_func = md5md5_parse_hash;
9124 sort_by_digest = sort_by_digest_4_4;
9125 opti_type = OPTI_TYPE_ZERO_BYTE
9126 | OPTI_TYPE_PRECOMPUTE_INIT
9127 | OPTI_TYPE_PRECOMPUTE_MERKLE
9128 | OPTI_TYPE_EARLY_SKIP;
9129 dgst_pos0 = 0;
9130 dgst_pos1 = 3;
9131 dgst_pos2 = 2;
9132 dgst_pos3 = 1;
9133 break;
9134
9135
9136 case 4400: hash_type = HASH_TYPE_MD5;
9137 salt_type = SALT_TYPE_NONE;
9138 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9139 opts_type = OPTS_TYPE_PT_GENERATE_BE
9140 | OPTS_TYPE_PT_ADD80
9141 | OPTS_TYPE_PT_ADDBITS15;
9142 kern_type = KERN_TYPE_MD5_SHA1;
9143 dgst_size = DGST_SIZE_4_4;
9144 parse_func = md5_parse_hash;
9145 sort_by_digest = sort_by_digest_4_4;
9146 opti_type = OPTI_TYPE_ZERO_BYTE
9147 | OPTI_TYPE_PRECOMPUTE_INIT
9148 | OPTI_TYPE_PRECOMPUTE_MERKLE
9149 | OPTI_TYPE_EARLY_SKIP
9150 | OPTI_TYPE_NOT_ITERATED
9151 | OPTI_TYPE_NOT_SALTED
9152 | OPTI_TYPE_RAW_HASH;
9153 dgst_pos0 = 0;
9154 dgst_pos1 = 3;
9155 dgst_pos2 = 2;
9156 dgst_pos3 = 1;
9157 break;
9158
9159 case 4500: hash_type = HASH_TYPE_SHA1;
9160 salt_type = SALT_TYPE_NONE;
9161 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9162 opts_type = OPTS_TYPE_PT_GENERATE_BE
9163 | OPTS_TYPE_PT_ADD80
9164 | OPTS_TYPE_PT_ADDBITS15;
9165 kern_type = KERN_TYPE_SHA11;
9166 dgst_size = DGST_SIZE_4_5;
9167 parse_func = sha1_parse_hash;
9168 sort_by_digest = sort_by_digest_4_5;
9169 opti_type = OPTI_TYPE_ZERO_BYTE
9170 | OPTI_TYPE_PRECOMPUTE_INIT
9171 | OPTI_TYPE_PRECOMPUTE_MERKLE
9172 | OPTI_TYPE_EARLY_SKIP
9173 | OPTI_TYPE_NOT_SALTED;
9174 dgst_pos0 = 3;
9175 dgst_pos1 = 4;
9176 dgst_pos2 = 2;
9177 dgst_pos3 = 1;
9178 break;
9179
9180 case 4700: hash_type = HASH_TYPE_SHA1;
9181 salt_type = SALT_TYPE_NONE;
9182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9183 opts_type = OPTS_TYPE_PT_GENERATE_LE
9184 | OPTS_TYPE_PT_ADD80
9185 | OPTS_TYPE_PT_ADDBITS14;
9186 kern_type = KERN_TYPE_SHA1_MD5;
9187 dgst_size = DGST_SIZE_4_5;
9188 parse_func = sha1_parse_hash;
9189 sort_by_digest = sort_by_digest_4_5;
9190 opti_type = OPTI_TYPE_ZERO_BYTE
9191 | OPTI_TYPE_PRECOMPUTE_INIT
9192 | OPTI_TYPE_PRECOMPUTE_MERKLE
9193 | OPTI_TYPE_EARLY_SKIP
9194 | OPTI_TYPE_NOT_ITERATED
9195 | OPTI_TYPE_NOT_SALTED
9196 | OPTI_TYPE_RAW_HASH;
9197 dgst_pos0 = 3;
9198 dgst_pos1 = 4;
9199 dgst_pos2 = 2;
9200 dgst_pos3 = 1;
9201 break;
9202
9203 case 4800: hash_type = HASH_TYPE_MD5;
9204 salt_type = SALT_TYPE_EMBEDDED;
9205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9206 opts_type = OPTS_TYPE_PT_GENERATE_LE
9207 | OPTS_TYPE_PT_ADDBITS14;
9208 kern_type = KERN_TYPE_MD5_CHAP;
9209 dgst_size = DGST_SIZE_4_4;
9210 parse_func = chap_parse_hash;
9211 sort_by_digest = sort_by_digest_4_4;
9212 opti_type = OPTI_TYPE_ZERO_BYTE
9213 | OPTI_TYPE_PRECOMPUTE_INIT
9214 | OPTI_TYPE_PRECOMPUTE_MERKLE
9215 | OPTI_TYPE_MEET_IN_MIDDLE
9216 | OPTI_TYPE_EARLY_SKIP
9217 | OPTI_TYPE_NOT_ITERATED
9218 | OPTI_TYPE_RAW_HASH;
9219 dgst_pos0 = 0;
9220 dgst_pos1 = 3;
9221 dgst_pos2 = 2;
9222 dgst_pos3 = 1;
9223 break;
9224
9225 case 4900: hash_type = HASH_TYPE_SHA1;
9226 salt_type = SALT_TYPE_INTERN;
9227 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9228 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9229 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9230 dgst_size = DGST_SIZE_4_5;
9231 parse_func = sha1s_parse_hash;
9232 sort_by_digest = sort_by_digest_4_5;
9233 opti_type = OPTI_TYPE_ZERO_BYTE
9234 | OPTI_TYPE_PRECOMPUTE_INIT
9235 | OPTI_TYPE_PRECOMPUTE_MERKLE
9236 | OPTI_TYPE_EARLY_SKIP;
9237 dgst_pos0 = 3;
9238 dgst_pos1 = 4;
9239 dgst_pos2 = 2;
9240 dgst_pos3 = 1;
9241 break;
9242
9243 case 5000: hash_type = HASH_TYPE_KECCAK;
9244 salt_type = SALT_TYPE_EMBEDDED;
9245 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9246 opts_type = OPTS_TYPE_PT_GENERATE_LE
9247 | OPTS_TYPE_PT_ADD01;
9248 kern_type = KERN_TYPE_KECCAK;
9249 dgst_size = DGST_SIZE_8_25;
9250 parse_func = keccak_parse_hash;
9251 sort_by_digest = sort_by_digest_8_25;
9252 opti_type = OPTI_TYPE_ZERO_BYTE
9253 | OPTI_TYPE_USES_BITS_64
9254 | OPTI_TYPE_RAW_HASH;
9255 dgst_pos0 = 2;
9256 dgst_pos1 = 3;
9257 dgst_pos2 = 4;
9258 dgst_pos3 = 5;
9259 break;
9260
9261 case 5100: hash_type = HASH_TYPE_MD5H;
9262 salt_type = SALT_TYPE_NONE;
9263 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9264 opts_type = OPTS_TYPE_PT_GENERATE_LE
9265 | OPTS_TYPE_PT_ADD80
9266 | OPTS_TYPE_PT_ADDBITS14;
9267 kern_type = KERN_TYPE_MD5H;
9268 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9269 parse_func = md5half_parse_hash;
9270 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9271 opti_type = OPTI_TYPE_ZERO_BYTE
9272 | OPTI_TYPE_RAW_HASH;
9273 dgst_pos0 = 0;
9274 dgst_pos1 = 1;
9275 dgst_pos2 = 2;
9276 dgst_pos3 = 3;
9277 break;
9278
9279 case 5200: hash_type = HASH_TYPE_SHA256;
9280 salt_type = SALT_TYPE_EMBEDDED;
9281 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9282 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9283 kern_type = KERN_TYPE_PSAFE3;
9284 dgst_size = DGST_SIZE_4_8;
9285 parse_func = psafe3_parse_hash;
9286 sort_by_digest = sort_by_digest_4_8;
9287 opti_type = OPTI_TYPE_ZERO_BYTE;
9288 dgst_pos0 = 0;
9289 dgst_pos1 = 1;
9290 dgst_pos2 = 2;
9291 dgst_pos3 = 3;
9292 break;
9293
9294 case 5300: hash_type = HASH_TYPE_MD5;
9295 salt_type = SALT_TYPE_EMBEDDED;
9296 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9297 opts_type = OPTS_TYPE_PT_GENERATE_LE
9298 | OPTS_TYPE_ST_ADD80;
9299 kern_type = KERN_TYPE_IKEPSK_MD5;
9300 dgst_size = DGST_SIZE_4_4;
9301 parse_func = ikepsk_md5_parse_hash;
9302 sort_by_digest = sort_by_digest_4_4;
9303 opti_type = OPTI_TYPE_ZERO_BYTE;
9304 dgst_pos0 = 0;
9305 dgst_pos1 = 3;
9306 dgst_pos2 = 2;
9307 dgst_pos3 = 1;
9308 break;
9309
9310 case 5400: hash_type = HASH_TYPE_SHA1;
9311 salt_type = SALT_TYPE_EMBEDDED;
9312 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9313 opts_type = OPTS_TYPE_PT_GENERATE_BE
9314 | OPTS_TYPE_ST_ADD80;
9315 kern_type = KERN_TYPE_IKEPSK_SHA1;
9316 dgst_size = DGST_SIZE_4_5;
9317 parse_func = ikepsk_sha1_parse_hash;
9318 sort_by_digest = sort_by_digest_4_5;
9319 opti_type = OPTI_TYPE_ZERO_BYTE;
9320 dgst_pos0 = 3;
9321 dgst_pos1 = 4;
9322 dgst_pos2 = 2;
9323 dgst_pos3 = 1;
9324 break;
9325
9326 case 5500: hash_type = HASH_TYPE_NETNTLM;
9327 salt_type = SALT_TYPE_EMBEDDED;
9328 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9329 opts_type = OPTS_TYPE_PT_GENERATE_LE
9330 | OPTS_TYPE_PT_ADD80
9331 | OPTS_TYPE_PT_ADDBITS14
9332 | OPTS_TYPE_PT_UNICODE
9333 | OPTS_TYPE_ST_HEX;
9334 kern_type = KERN_TYPE_NETNTLMv1;
9335 dgst_size = DGST_SIZE_4_4;
9336 parse_func = netntlmv1_parse_hash;
9337 sort_by_digest = sort_by_digest_4_4;
9338 opti_type = OPTI_TYPE_ZERO_BYTE
9339 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9340 dgst_pos0 = 0;
9341 dgst_pos1 = 1;
9342 dgst_pos2 = 2;
9343 dgst_pos3 = 3;
9344 break;
9345
9346 case 5600: hash_type = HASH_TYPE_MD5;
9347 salt_type = SALT_TYPE_EMBEDDED;
9348 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9349 opts_type = OPTS_TYPE_PT_GENERATE_LE
9350 | OPTS_TYPE_PT_ADD80
9351 | OPTS_TYPE_PT_ADDBITS14
9352 | OPTS_TYPE_PT_UNICODE;
9353 kern_type = KERN_TYPE_NETNTLMv2;
9354 dgst_size = DGST_SIZE_4_4;
9355 parse_func = netntlmv2_parse_hash;
9356 sort_by_digest = sort_by_digest_4_4;
9357 opti_type = OPTI_TYPE_ZERO_BYTE;
9358 dgst_pos0 = 0;
9359 dgst_pos1 = 3;
9360 dgst_pos2 = 2;
9361 dgst_pos3 = 1;
9362 break;
9363
9364 case 5700: hash_type = HASH_TYPE_SHA256;
9365 salt_type = SALT_TYPE_NONE;
9366 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9367 opts_type = OPTS_TYPE_PT_GENERATE_BE
9368 | OPTS_TYPE_PT_ADD80
9369 | OPTS_TYPE_PT_ADDBITS15;
9370 kern_type = KERN_TYPE_SHA256;
9371 dgst_size = DGST_SIZE_4_8;
9372 parse_func = cisco4_parse_hash;
9373 sort_by_digest = sort_by_digest_4_8;
9374 opti_type = OPTI_TYPE_ZERO_BYTE
9375 | OPTI_TYPE_PRECOMPUTE_INIT
9376 | OPTI_TYPE_PRECOMPUTE_MERKLE
9377 | OPTI_TYPE_EARLY_SKIP
9378 | OPTI_TYPE_NOT_ITERATED
9379 | OPTI_TYPE_NOT_SALTED
9380 | OPTI_TYPE_RAW_HASH;
9381 dgst_pos0 = 3;
9382 dgst_pos1 = 7;
9383 dgst_pos2 = 2;
9384 dgst_pos3 = 6;
9385 break;
9386
9387 case 5800: hash_type = HASH_TYPE_SHA1;
9388 salt_type = SALT_TYPE_INTERN;
9389 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9390 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9391 | OPTS_TYPE_ST_ADD80;
9392 kern_type = KERN_TYPE_ANDROIDPIN;
9393 dgst_size = DGST_SIZE_4_5;
9394 parse_func = androidpin_parse_hash;
9395 sort_by_digest = sort_by_digest_4_5;
9396 opti_type = OPTI_TYPE_ZERO_BYTE;
9397 dgst_pos0 = 0;
9398 dgst_pos1 = 1;
9399 dgst_pos2 = 2;
9400 dgst_pos3 = 3;
9401 break;
9402
9403 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9404 salt_type = SALT_TYPE_NONE;
9405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9406 opts_type = OPTS_TYPE_PT_GENERATE_LE
9407 | OPTS_TYPE_PT_ADD80;
9408 kern_type = KERN_TYPE_RIPEMD160;
9409 dgst_size = DGST_SIZE_4_5;
9410 parse_func = ripemd160_parse_hash;
9411 sort_by_digest = sort_by_digest_4_5;
9412 opti_type = OPTI_TYPE_ZERO_BYTE;
9413 dgst_pos0 = 0;
9414 dgst_pos1 = 1;
9415 dgst_pos2 = 2;
9416 dgst_pos3 = 3;
9417 break;
9418
9419 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9420 salt_type = SALT_TYPE_NONE;
9421 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9422 opts_type = OPTS_TYPE_PT_GENERATE_BE
9423 | OPTS_TYPE_PT_ADD80;
9424 kern_type = KERN_TYPE_WHIRLPOOL;
9425 dgst_size = DGST_SIZE_4_16;
9426 parse_func = whirlpool_parse_hash;
9427 sort_by_digest = sort_by_digest_4_16;
9428 opti_type = OPTI_TYPE_ZERO_BYTE;
9429 dgst_pos0 = 0;
9430 dgst_pos1 = 1;
9431 dgst_pos2 = 2;
9432 dgst_pos3 = 3;
9433 break;
9434
9435 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9436 salt_type = SALT_TYPE_EMBEDDED;
9437 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9438 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9439 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9440 dgst_size = DGST_SIZE_4_5;
9441 parse_func = truecrypt_parse_hash_2k;
9442 sort_by_digest = sort_by_digest_4_5;
9443 opti_type = OPTI_TYPE_ZERO_BYTE;
9444 dgst_pos0 = 0;
9445 dgst_pos1 = 1;
9446 dgst_pos2 = 2;
9447 dgst_pos3 = 3;
9448 break;
9449
9450 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9451 salt_type = SALT_TYPE_EMBEDDED;
9452 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9453 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9454 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9455 dgst_size = DGST_SIZE_4_5;
9456 parse_func = truecrypt_parse_hash_2k;
9457 sort_by_digest = sort_by_digest_4_5;
9458 opti_type = OPTI_TYPE_ZERO_BYTE;
9459 dgst_pos0 = 0;
9460 dgst_pos1 = 1;
9461 dgst_pos2 = 2;
9462 dgst_pos3 = 3;
9463 break;
9464
9465 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9466 salt_type = SALT_TYPE_EMBEDDED;
9467 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9468 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9469 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9470 dgst_size = DGST_SIZE_4_5;
9471 parse_func = truecrypt_parse_hash_2k;
9472 sort_by_digest = sort_by_digest_4_5;
9473 opti_type = OPTI_TYPE_ZERO_BYTE;
9474 dgst_pos0 = 0;
9475 dgst_pos1 = 1;
9476 dgst_pos2 = 2;
9477 dgst_pos3 = 3;
9478 break;
9479
9480 case 6221: hash_type = HASH_TYPE_SHA512;
9481 salt_type = SALT_TYPE_EMBEDDED;
9482 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9483 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9484 kern_type = KERN_TYPE_TCSHA512_XTS512;
9485 dgst_size = DGST_SIZE_8_8;
9486 parse_func = truecrypt_parse_hash_1k;
9487 sort_by_digest = sort_by_digest_8_8;
9488 opti_type = OPTI_TYPE_ZERO_BYTE
9489 | OPTI_TYPE_USES_BITS_64;
9490 dgst_pos0 = 0;
9491 dgst_pos1 = 1;
9492 dgst_pos2 = 2;
9493 dgst_pos3 = 3;
9494 break;
9495
9496 case 6222: hash_type = HASH_TYPE_SHA512;
9497 salt_type = SALT_TYPE_EMBEDDED;
9498 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9499 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9500 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9501 dgst_size = DGST_SIZE_8_8;
9502 parse_func = truecrypt_parse_hash_1k;
9503 sort_by_digest = sort_by_digest_8_8;
9504 opti_type = OPTI_TYPE_ZERO_BYTE
9505 | OPTI_TYPE_USES_BITS_64;
9506 dgst_pos0 = 0;
9507 dgst_pos1 = 1;
9508 dgst_pos2 = 2;
9509 dgst_pos3 = 3;
9510 break;
9511
9512 case 6223: hash_type = HASH_TYPE_SHA512;
9513 salt_type = SALT_TYPE_EMBEDDED;
9514 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9515 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9516 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9517 dgst_size = DGST_SIZE_8_8;
9518 parse_func = truecrypt_parse_hash_1k;
9519 sort_by_digest = sort_by_digest_8_8;
9520 opti_type = OPTI_TYPE_ZERO_BYTE
9521 | OPTI_TYPE_USES_BITS_64;
9522 dgst_pos0 = 0;
9523 dgst_pos1 = 1;
9524 dgst_pos2 = 2;
9525 dgst_pos3 = 3;
9526 break;
9527
9528 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9529 salt_type = SALT_TYPE_EMBEDDED;
9530 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9531 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9532 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9533 dgst_size = DGST_SIZE_4_8;
9534 parse_func = truecrypt_parse_hash_1k;
9535 sort_by_digest = sort_by_digest_4_8;
9536 opti_type = OPTI_TYPE_ZERO_BYTE;
9537 dgst_pos0 = 0;
9538 dgst_pos1 = 1;
9539 dgst_pos2 = 2;
9540 dgst_pos3 = 3;
9541 break;
9542
9543 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9544 salt_type = SALT_TYPE_EMBEDDED;
9545 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9546 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9547 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9548 dgst_size = DGST_SIZE_4_8;
9549 parse_func = truecrypt_parse_hash_1k;
9550 sort_by_digest = sort_by_digest_4_8;
9551 opti_type = OPTI_TYPE_ZERO_BYTE;
9552 dgst_pos0 = 0;
9553 dgst_pos1 = 1;
9554 dgst_pos2 = 2;
9555 dgst_pos3 = 3;
9556 break;
9557
9558 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9559 salt_type = SALT_TYPE_EMBEDDED;
9560 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9561 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9562 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9563 dgst_size = DGST_SIZE_4_8;
9564 parse_func = truecrypt_parse_hash_1k;
9565 sort_by_digest = sort_by_digest_4_8;
9566 opti_type = OPTI_TYPE_ZERO_BYTE;
9567 dgst_pos0 = 0;
9568 dgst_pos1 = 1;
9569 dgst_pos2 = 2;
9570 dgst_pos3 = 3;
9571 break;
9572
9573 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9574 salt_type = SALT_TYPE_EMBEDDED;
9575 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9576 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9577 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9578 dgst_size = DGST_SIZE_4_5;
9579 parse_func = truecrypt_parse_hash_1k;
9580 sort_by_digest = sort_by_digest_4_5;
9581 opti_type = OPTI_TYPE_ZERO_BYTE;
9582 dgst_pos0 = 0;
9583 dgst_pos1 = 1;
9584 dgst_pos2 = 2;
9585 dgst_pos3 = 3;
9586 break;
9587
9588 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9589 salt_type = SALT_TYPE_EMBEDDED;
9590 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9591 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9592 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9593 dgst_size = DGST_SIZE_4_5;
9594 parse_func = truecrypt_parse_hash_1k;
9595 sort_by_digest = sort_by_digest_4_5;
9596 opti_type = OPTI_TYPE_ZERO_BYTE;
9597 dgst_pos0 = 0;
9598 dgst_pos1 = 1;
9599 dgst_pos2 = 2;
9600 dgst_pos3 = 3;
9601 break;
9602
9603 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9604 salt_type = SALT_TYPE_EMBEDDED;
9605 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9606 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9607 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9608 dgst_size = DGST_SIZE_4_5;
9609 parse_func = truecrypt_parse_hash_1k;
9610 sort_by_digest = sort_by_digest_4_5;
9611 opti_type = OPTI_TYPE_ZERO_BYTE;
9612 dgst_pos0 = 0;
9613 dgst_pos1 = 1;
9614 dgst_pos2 = 2;
9615 dgst_pos3 = 3;
9616 break;
9617
9618 case 6300: hash_type = HASH_TYPE_MD5;
9619 salt_type = SALT_TYPE_EMBEDDED;
9620 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9621 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9622 kern_type = KERN_TYPE_MD5AIX;
9623 dgst_size = DGST_SIZE_4_4;
9624 parse_func = md5aix_parse_hash;
9625 sort_by_digest = sort_by_digest_4_4;
9626 opti_type = OPTI_TYPE_ZERO_BYTE;
9627 dgst_pos0 = 0;
9628 dgst_pos1 = 1;
9629 dgst_pos2 = 2;
9630 dgst_pos3 = 3;
9631 break;
9632
9633 case 6400: hash_type = HASH_TYPE_SHA256;
9634 salt_type = SALT_TYPE_EMBEDDED;
9635 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9636 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9637 kern_type = KERN_TYPE_SHA256AIX;
9638 dgst_size = DGST_SIZE_4_8;
9639 parse_func = sha256aix_parse_hash;
9640 sort_by_digest = sort_by_digest_4_8;
9641 opti_type = OPTI_TYPE_ZERO_BYTE;
9642 dgst_pos0 = 0;
9643 dgst_pos1 = 1;
9644 dgst_pos2 = 2;
9645 dgst_pos3 = 3;
9646 break;
9647
9648 case 6500: hash_type = HASH_TYPE_SHA512;
9649 salt_type = SALT_TYPE_EMBEDDED;
9650 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9651 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9652 kern_type = KERN_TYPE_SHA512AIX;
9653 dgst_size = DGST_SIZE_8_8;
9654 parse_func = sha512aix_parse_hash;
9655 sort_by_digest = sort_by_digest_8_8;
9656 opti_type = OPTI_TYPE_ZERO_BYTE
9657 | OPTI_TYPE_USES_BITS_64;
9658 dgst_pos0 = 0;
9659 dgst_pos1 = 1;
9660 dgst_pos2 = 2;
9661 dgst_pos3 = 3;
9662 break;
9663
9664 case 6600: hash_type = HASH_TYPE_AES;
9665 salt_type = SALT_TYPE_EMBEDDED;
9666 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9667 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9668 kern_type = KERN_TYPE_AGILEKEY;
9669 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9670 parse_func = agilekey_parse_hash;
9671 sort_by_digest = sort_by_digest_4_5;
9672 opti_type = OPTI_TYPE_ZERO_BYTE;
9673 dgst_pos0 = 0;
9674 dgst_pos1 = 1;
9675 dgst_pos2 = 2;
9676 dgst_pos3 = 3;
9677 break;
9678
9679 case 6700: hash_type = HASH_TYPE_SHA1;
9680 salt_type = SALT_TYPE_EMBEDDED;
9681 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9682 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9683 kern_type = KERN_TYPE_SHA1AIX;
9684 dgst_size = DGST_SIZE_4_5;
9685 parse_func = sha1aix_parse_hash;
9686 sort_by_digest = sort_by_digest_4_5;
9687 opti_type = OPTI_TYPE_ZERO_BYTE;
9688 dgst_pos0 = 0;
9689 dgst_pos1 = 1;
9690 dgst_pos2 = 2;
9691 dgst_pos3 = 3;
9692 break;
9693
9694 case 6800: hash_type = HASH_TYPE_AES;
9695 salt_type = SALT_TYPE_EMBEDDED;
9696 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9697 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9698 kern_type = KERN_TYPE_LASTPASS;
9699 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9700 parse_func = lastpass_parse_hash;
9701 sort_by_digest = sort_by_digest_4_8;
9702 opti_type = OPTI_TYPE_ZERO_BYTE;
9703 dgst_pos0 = 0;
9704 dgst_pos1 = 1;
9705 dgst_pos2 = 2;
9706 dgst_pos3 = 3;
9707 break;
9708
9709 case 6900: hash_type = HASH_TYPE_GOST;
9710 salt_type = SALT_TYPE_NONE;
9711 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9712 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9713 kern_type = KERN_TYPE_GOST;
9714 dgst_size = DGST_SIZE_4_8;
9715 parse_func = gost_parse_hash;
9716 sort_by_digest = sort_by_digest_4_8;
9717 opti_type = OPTI_TYPE_ZERO_BYTE;
9718 dgst_pos0 = 0;
9719 dgst_pos1 = 1;
9720 dgst_pos2 = 2;
9721 dgst_pos3 = 3;
9722 break;
9723
9724 case 7100: hash_type = HASH_TYPE_SHA512;
9725 salt_type = SALT_TYPE_EMBEDDED;
9726 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9727 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9728 kern_type = KERN_TYPE_PBKDF2_SHA512;
9729 dgst_size = DGST_SIZE_8_16;
9730 parse_func = sha512osx_parse_hash;
9731 sort_by_digest = sort_by_digest_8_16;
9732 opti_type = OPTI_TYPE_ZERO_BYTE
9733 | OPTI_TYPE_USES_BITS_64
9734 | OPTI_TYPE_SLOW_HASH_SIMD;
9735 dgst_pos0 = 0;
9736 dgst_pos1 = 1;
9737 dgst_pos2 = 2;
9738 dgst_pos3 = 3;
9739 break;
9740
9741 case 7200: hash_type = HASH_TYPE_SHA512;
9742 salt_type = SALT_TYPE_EMBEDDED;
9743 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9744 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9745 kern_type = KERN_TYPE_PBKDF2_SHA512;
9746 dgst_size = DGST_SIZE_8_16;
9747 parse_func = sha512grub_parse_hash;
9748 sort_by_digest = sort_by_digest_8_16;
9749 opti_type = OPTI_TYPE_ZERO_BYTE
9750 | OPTI_TYPE_USES_BITS_64
9751 | OPTI_TYPE_SLOW_HASH_SIMD;
9752 dgst_pos0 = 0;
9753 dgst_pos1 = 1;
9754 dgst_pos2 = 2;
9755 dgst_pos3 = 3;
9756 break;
9757
9758 case 7300: hash_type = HASH_TYPE_SHA1;
9759 salt_type = SALT_TYPE_EMBEDDED;
9760 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9761 opts_type = OPTS_TYPE_PT_GENERATE_BE
9762 | OPTS_TYPE_ST_ADD80
9763 | OPTS_TYPE_ST_ADDBITS15;
9764 kern_type = KERN_TYPE_RAKP;
9765 dgst_size = DGST_SIZE_4_5;
9766 parse_func = rakp_parse_hash;
9767 sort_by_digest = sort_by_digest_4_5;
9768 opti_type = OPTI_TYPE_ZERO_BYTE
9769 | OPTI_TYPE_NOT_ITERATED;
9770 dgst_pos0 = 3;
9771 dgst_pos1 = 4;
9772 dgst_pos2 = 2;
9773 dgst_pos3 = 1;
9774 break;
9775
9776 case 7400: hash_type = HASH_TYPE_SHA256;
9777 salt_type = SALT_TYPE_EMBEDDED;
9778 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9779 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9780 kern_type = KERN_TYPE_SHA256CRYPT;
9781 dgst_size = DGST_SIZE_4_8;
9782 parse_func = sha256crypt_parse_hash;
9783 sort_by_digest = sort_by_digest_4_8;
9784 opti_type = OPTI_TYPE_ZERO_BYTE;
9785 dgst_pos0 = 0;
9786 dgst_pos1 = 1;
9787 dgst_pos2 = 2;
9788 dgst_pos3 = 3;
9789 break;
9790
9791 case 7500: hash_type = HASH_TYPE_KRB5PA;
9792 salt_type = SALT_TYPE_EMBEDDED;
9793 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9794 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9795 kern_type = KERN_TYPE_KRB5PA;
9796 dgst_size = DGST_SIZE_4_4;
9797 parse_func = krb5pa_parse_hash;
9798 sort_by_digest = sort_by_digest_4_4;
9799 opti_type = OPTI_TYPE_ZERO_BYTE
9800 | OPTI_TYPE_NOT_ITERATED;
9801 dgst_pos0 = 0;
9802 dgst_pos1 = 1;
9803 dgst_pos2 = 2;
9804 dgst_pos3 = 3;
9805 break;
9806
9807 case 7600: hash_type = HASH_TYPE_SHA1;
9808 salt_type = SALT_TYPE_INTERN;
9809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9810 opts_type = OPTS_TYPE_PT_GENERATE_BE
9811 | OPTS_TYPE_PT_ADD80
9812 | OPTS_TYPE_PT_ADDBITS15;
9813 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9814 dgst_size = DGST_SIZE_4_5;
9815 parse_func = redmine_parse_hash;
9816 sort_by_digest = sort_by_digest_4_5;
9817 opti_type = OPTI_TYPE_ZERO_BYTE
9818 | OPTI_TYPE_PRECOMPUTE_INIT
9819 | OPTI_TYPE_EARLY_SKIP
9820 | OPTI_TYPE_NOT_ITERATED
9821 | OPTI_TYPE_PREPENDED_SALT;
9822 dgst_pos0 = 3;
9823 dgst_pos1 = 4;
9824 dgst_pos2 = 2;
9825 dgst_pos3 = 1;
9826 break;
9827
9828 case 7700: hash_type = HASH_TYPE_SAPB;
9829 salt_type = SALT_TYPE_EMBEDDED;
9830 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9831 opts_type = OPTS_TYPE_PT_GENERATE_LE
9832 | OPTS_TYPE_PT_UPPER
9833 | OPTS_TYPE_ST_UPPER;
9834 kern_type = KERN_TYPE_SAPB;
9835 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9836 parse_func = sapb_parse_hash;
9837 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9838 opti_type = OPTI_TYPE_ZERO_BYTE
9839 | OPTI_TYPE_PRECOMPUTE_INIT
9840 | OPTI_TYPE_NOT_ITERATED;
9841 dgst_pos0 = 0;
9842 dgst_pos1 = 1;
9843 dgst_pos2 = 2;
9844 dgst_pos3 = 3;
9845 break;
9846
9847 case 7800: hash_type = HASH_TYPE_SAPG;
9848 salt_type = SALT_TYPE_EMBEDDED;
9849 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9850 opts_type = OPTS_TYPE_PT_GENERATE_BE
9851 | OPTS_TYPE_ST_ADD80
9852 | OPTS_TYPE_ST_UPPER;
9853 kern_type = KERN_TYPE_SAPG;
9854 dgst_size = DGST_SIZE_4_5;
9855 parse_func = sapg_parse_hash;
9856 sort_by_digest = sort_by_digest_4_5;
9857 opti_type = OPTI_TYPE_ZERO_BYTE
9858 | OPTI_TYPE_PRECOMPUTE_INIT
9859 | OPTI_TYPE_NOT_ITERATED;
9860 dgst_pos0 = 3;
9861 dgst_pos1 = 4;
9862 dgst_pos2 = 2;
9863 dgst_pos3 = 1;
9864 break;
9865
9866 case 7900: hash_type = HASH_TYPE_SHA512;
9867 salt_type = SALT_TYPE_EMBEDDED;
9868 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9869 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9870 kern_type = KERN_TYPE_DRUPAL7;
9871 dgst_size = DGST_SIZE_8_8;
9872 parse_func = drupal7_parse_hash;
9873 sort_by_digest = sort_by_digest_8_8;
9874 opti_type = OPTI_TYPE_ZERO_BYTE
9875 | OPTI_TYPE_USES_BITS_64;
9876 dgst_pos0 = 0;
9877 dgst_pos1 = 1;
9878 dgst_pos2 = 2;
9879 dgst_pos3 = 3;
9880 break;
9881
9882 case 8000: hash_type = HASH_TYPE_SHA256;
9883 salt_type = SALT_TYPE_EMBEDDED;
9884 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9885 opts_type = OPTS_TYPE_PT_GENERATE_BE
9886 | OPTS_TYPE_PT_UNICODE
9887 | OPTS_TYPE_ST_ADD80
9888 | OPTS_TYPE_ST_HEX;
9889 kern_type = KERN_TYPE_SYBASEASE;
9890 dgst_size = DGST_SIZE_4_8;
9891 parse_func = sybasease_parse_hash;
9892 sort_by_digest = sort_by_digest_4_8;
9893 opti_type = OPTI_TYPE_ZERO_BYTE
9894 | OPTI_TYPE_PRECOMPUTE_INIT
9895 | OPTI_TYPE_EARLY_SKIP
9896 | OPTI_TYPE_NOT_ITERATED
9897 | OPTI_TYPE_RAW_HASH;
9898 dgst_pos0 = 3;
9899 dgst_pos1 = 7;
9900 dgst_pos2 = 2;
9901 dgst_pos3 = 6;
9902 break;
9903
9904 case 8100: hash_type = HASH_TYPE_SHA1;
9905 salt_type = SALT_TYPE_EMBEDDED;
9906 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9907 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9908 kern_type = KERN_TYPE_NETSCALER;
9909 dgst_size = DGST_SIZE_4_5;
9910 parse_func = netscaler_parse_hash;
9911 sort_by_digest = sort_by_digest_4_5;
9912 opti_type = OPTI_TYPE_ZERO_BYTE
9913 | OPTI_TYPE_PRECOMPUTE_INIT
9914 | OPTI_TYPE_PRECOMPUTE_MERKLE
9915 | OPTI_TYPE_EARLY_SKIP
9916 | OPTI_TYPE_NOT_ITERATED
9917 | OPTI_TYPE_PREPENDED_SALT
9918 | OPTI_TYPE_RAW_HASH;
9919 dgst_pos0 = 3;
9920 dgst_pos1 = 4;
9921 dgst_pos2 = 2;
9922 dgst_pos3 = 1;
9923 break;
9924
9925 case 8200: hash_type = HASH_TYPE_SHA256;
9926 salt_type = SALT_TYPE_EMBEDDED;
9927 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9928 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9929 kern_type = KERN_TYPE_CLOUDKEY;
9930 dgst_size = DGST_SIZE_4_8;
9931 parse_func = cloudkey_parse_hash;
9932 sort_by_digest = sort_by_digest_4_8;
9933 opti_type = OPTI_TYPE_ZERO_BYTE;
9934 dgst_pos0 = 0;
9935 dgst_pos1 = 1;
9936 dgst_pos2 = 2;
9937 dgst_pos3 = 3;
9938 break;
9939
9940 case 8300: hash_type = HASH_TYPE_SHA1;
9941 salt_type = SALT_TYPE_EMBEDDED;
9942 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9943 opts_type = OPTS_TYPE_PT_GENERATE_BE
9944 | OPTS_TYPE_ST_HEX
9945 | OPTS_TYPE_ST_ADD80;
9946 kern_type = KERN_TYPE_NSEC3;
9947 dgst_size = DGST_SIZE_4_5;
9948 parse_func = nsec3_parse_hash;
9949 sort_by_digest = sort_by_digest_4_5;
9950 opti_type = OPTI_TYPE_ZERO_BYTE;
9951 dgst_pos0 = 3;
9952 dgst_pos1 = 4;
9953 dgst_pos2 = 2;
9954 dgst_pos3 = 1;
9955 break;
9956
9957 case 8400: hash_type = HASH_TYPE_SHA1;
9958 salt_type = SALT_TYPE_INTERN;
9959 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9960 opts_type = OPTS_TYPE_PT_GENERATE_BE
9961 | OPTS_TYPE_PT_ADD80
9962 | OPTS_TYPE_PT_ADDBITS15;
9963 kern_type = KERN_TYPE_WBB3;
9964 dgst_size = DGST_SIZE_4_5;
9965 parse_func = wbb3_parse_hash;
9966 sort_by_digest = sort_by_digest_4_5;
9967 opti_type = OPTI_TYPE_ZERO_BYTE
9968 | OPTI_TYPE_PRECOMPUTE_INIT
9969 | OPTI_TYPE_NOT_ITERATED;
9970 dgst_pos0 = 3;
9971 dgst_pos1 = 4;
9972 dgst_pos2 = 2;
9973 dgst_pos3 = 1;
9974 break;
9975
9976 case 8500: hash_type = HASH_TYPE_DESRACF;
9977 salt_type = SALT_TYPE_EMBEDDED;
9978 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9979 opts_type = OPTS_TYPE_PT_GENERATE_LE
9980 | OPTS_TYPE_ST_UPPER;
9981 kern_type = KERN_TYPE_RACF;
9982 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9983 parse_func = racf_parse_hash;
9984 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9985 opti_type = OPTI_TYPE_ZERO_BYTE
9986 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9987 dgst_pos0 = 0;
9988 dgst_pos1 = 1;
9989 dgst_pos2 = 2;
9990 dgst_pos3 = 3;
9991 break;
9992
9993 case 8600: hash_type = HASH_TYPE_LOTUS5;
9994 salt_type = SALT_TYPE_NONE;
9995 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9996 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9997 kern_type = KERN_TYPE_LOTUS5;
9998 dgst_size = DGST_SIZE_4_4;
9999 parse_func = lotus5_parse_hash;
10000 sort_by_digest = sort_by_digest_4_4;
10001 opti_type = OPTI_TYPE_EARLY_SKIP
10002 | OPTI_TYPE_NOT_ITERATED
10003 | OPTI_TYPE_NOT_SALTED
10004 | OPTI_TYPE_RAW_HASH;
10005 dgst_pos0 = 0;
10006 dgst_pos1 = 1;
10007 dgst_pos2 = 2;
10008 dgst_pos3 = 3;
10009 break;
10010
10011 case 8700: hash_type = HASH_TYPE_LOTUS6;
10012 salt_type = SALT_TYPE_EMBEDDED;
10013 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10014 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10015 kern_type = KERN_TYPE_LOTUS6;
10016 dgst_size = DGST_SIZE_4_4;
10017 parse_func = lotus6_parse_hash;
10018 sort_by_digest = sort_by_digest_4_4;
10019 opti_type = OPTI_TYPE_EARLY_SKIP
10020 | OPTI_TYPE_NOT_ITERATED
10021 | OPTI_TYPE_RAW_HASH;
10022 dgst_pos0 = 0;
10023 dgst_pos1 = 1;
10024 dgst_pos2 = 2;
10025 dgst_pos3 = 3;
10026 break;
10027
10028 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
10029 salt_type = SALT_TYPE_EMBEDDED;
10030 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10031 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10032 kern_type = KERN_TYPE_ANDROIDFDE;
10033 dgst_size = DGST_SIZE_4_4;
10034 parse_func = androidfde_parse_hash;
10035 sort_by_digest = sort_by_digest_4_4;
10036 opti_type = OPTI_TYPE_ZERO_BYTE;
10037 dgst_pos0 = 0;
10038 dgst_pos1 = 1;
10039 dgst_pos2 = 2;
10040 dgst_pos3 = 3;
10041 break;
10042
10043 case 8900: hash_type = HASH_TYPE_SCRYPT;
10044 salt_type = SALT_TYPE_EMBEDDED;
10045 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10046 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10047 kern_type = KERN_TYPE_SCRYPT;
10048 dgst_size = DGST_SIZE_4_8;
10049 parse_func = scrypt_parse_hash;
10050 sort_by_digest = sort_by_digest_4_8;
10051 opti_type = OPTI_TYPE_ZERO_BYTE;
10052 dgst_pos0 = 0;
10053 dgst_pos1 = 1;
10054 dgst_pos2 = 2;
10055 dgst_pos3 = 3;
10056 break;
10057
10058 case 9000: hash_type = HASH_TYPE_SHA1;
10059 salt_type = SALT_TYPE_EMBEDDED;
10060 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10061 opts_type = OPTS_TYPE_PT_GENERATE_LE
10062 | OPTS_TYPE_ST_GENERATE_LE;
10063 kern_type = KERN_TYPE_PSAFE2;
10064 dgst_size = DGST_SIZE_4_5;
10065 parse_func = psafe2_parse_hash;
10066 sort_by_digest = sort_by_digest_4_5;
10067 opti_type = OPTI_TYPE_ZERO_BYTE;
10068 dgst_pos0 = 0;
10069 dgst_pos1 = 1;
10070 dgst_pos2 = 2;
10071 dgst_pos3 = 3;
10072 break;
10073
10074 case 9100: hash_type = HASH_TYPE_LOTUS8;
10075 salt_type = SALT_TYPE_EMBEDDED;
10076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10077 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10078 kern_type = KERN_TYPE_LOTUS8;
10079 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10080 parse_func = lotus8_parse_hash;
10081 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10082 opti_type = OPTI_TYPE_ZERO_BYTE;
10083 dgst_pos0 = 0;
10084 dgst_pos1 = 1;
10085 dgst_pos2 = 2;
10086 dgst_pos3 = 3;
10087 break;
10088
10089 case 9200: hash_type = HASH_TYPE_SHA256;
10090 salt_type = SALT_TYPE_EMBEDDED;
10091 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10092 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10093 kern_type = KERN_TYPE_PBKDF2_SHA256;
10094 dgst_size = DGST_SIZE_4_32;
10095 parse_func = cisco8_parse_hash;
10096 sort_by_digest = sort_by_digest_4_32;
10097 opti_type = OPTI_TYPE_ZERO_BYTE
10098 | OPTI_TYPE_SLOW_HASH_SIMD;
10099 dgst_pos0 = 0;
10100 dgst_pos1 = 1;
10101 dgst_pos2 = 2;
10102 dgst_pos3 = 3;
10103 break;
10104
10105 case 9300: hash_type = HASH_TYPE_SCRYPT;
10106 salt_type = SALT_TYPE_EMBEDDED;
10107 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10108 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10109 kern_type = KERN_TYPE_SCRYPT;
10110 dgst_size = DGST_SIZE_4_8;
10111 parse_func = cisco9_parse_hash;
10112 sort_by_digest = sort_by_digest_4_8;
10113 opti_type = OPTI_TYPE_ZERO_BYTE;
10114 dgst_pos0 = 0;
10115 dgst_pos1 = 1;
10116 dgst_pos2 = 2;
10117 dgst_pos3 = 3;
10118 break;
10119
10120 case 9400: hash_type = HASH_TYPE_OFFICE2007;
10121 salt_type = SALT_TYPE_EMBEDDED;
10122 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10123 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10124 kern_type = KERN_TYPE_OFFICE2007;
10125 dgst_size = DGST_SIZE_4_4;
10126 parse_func = office2007_parse_hash;
10127 sort_by_digest = sort_by_digest_4_4;
10128 opti_type = OPTI_TYPE_ZERO_BYTE;
10129 dgst_pos0 = 0;
10130 dgst_pos1 = 1;
10131 dgst_pos2 = 2;
10132 dgst_pos3 = 3;
10133 break;
10134
10135 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10136 salt_type = SALT_TYPE_EMBEDDED;
10137 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10138 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10139 kern_type = KERN_TYPE_OFFICE2010;
10140 dgst_size = DGST_SIZE_4_4;
10141 parse_func = office2010_parse_hash;
10142 sort_by_digest = sort_by_digest_4_4;
10143 opti_type = OPTI_TYPE_ZERO_BYTE;
10144 dgst_pos0 = 0;
10145 dgst_pos1 = 1;
10146 dgst_pos2 = 2;
10147 dgst_pos3 = 3;
10148 break;
10149
10150 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10151 salt_type = SALT_TYPE_EMBEDDED;
10152 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10153 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10154 kern_type = KERN_TYPE_OFFICE2013;
10155 dgst_size = DGST_SIZE_4_4;
10156 parse_func = office2013_parse_hash;
10157 sort_by_digest = sort_by_digest_4_4;
10158 opti_type = OPTI_TYPE_ZERO_BYTE;
10159 dgst_pos0 = 0;
10160 dgst_pos1 = 1;
10161 dgst_pos2 = 2;
10162 dgst_pos3 = 3;
10163 break;
10164
10165 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10166 salt_type = SALT_TYPE_EMBEDDED;
10167 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10168 opts_type = OPTS_TYPE_PT_GENERATE_LE
10169 | OPTS_TYPE_PT_ADD80
10170 | OPTS_TYPE_PT_UNICODE;
10171 kern_type = KERN_TYPE_OLDOFFICE01;
10172 dgst_size = DGST_SIZE_4_4;
10173 parse_func = oldoffice01_parse_hash;
10174 sort_by_digest = sort_by_digest_4_4;
10175 opti_type = OPTI_TYPE_ZERO_BYTE
10176 | OPTI_TYPE_PRECOMPUTE_INIT
10177 | OPTI_TYPE_NOT_ITERATED;
10178 dgst_pos0 = 0;
10179 dgst_pos1 = 1;
10180 dgst_pos2 = 2;
10181 dgst_pos3 = 3;
10182 break;
10183
10184 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10185 salt_type = SALT_TYPE_EMBEDDED;
10186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10187 opts_type = OPTS_TYPE_PT_GENERATE_LE
10188 | OPTS_TYPE_PT_ADD80;
10189 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10190 dgst_size = DGST_SIZE_4_4;
10191 parse_func = oldoffice01cm1_parse_hash;
10192 sort_by_digest = sort_by_digest_4_4;
10193 opti_type = OPTI_TYPE_ZERO_BYTE
10194 | OPTI_TYPE_PRECOMPUTE_INIT
10195 | OPTI_TYPE_NOT_ITERATED;
10196 dgst_pos0 = 0;
10197 dgst_pos1 = 1;
10198 dgst_pos2 = 2;
10199 dgst_pos3 = 3;
10200 break;
10201
10202 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10203 salt_type = SALT_TYPE_EMBEDDED;
10204 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10205 opts_type = OPTS_TYPE_PT_GENERATE_LE
10206 | OPTS_TYPE_PT_ADD80
10207 | OPTS_TYPE_PT_UNICODE
10208 | OPTS_TYPE_PT_NEVERCRACK;
10209 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10210 dgst_size = DGST_SIZE_4_4;
10211 parse_func = oldoffice01cm2_parse_hash;
10212 sort_by_digest = sort_by_digest_4_4;
10213 opti_type = OPTI_TYPE_ZERO_BYTE
10214 | OPTI_TYPE_PRECOMPUTE_INIT
10215 | OPTI_TYPE_NOT_ITERATED;
10216 dgst_pos0 = 0;
10217 dgst_pos1 = 1;
10218 dgst_pos2 = 2;
10219 dgst_pos3 = 3;
10220 break;
10221
10222 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10223 salt_type = SALT_TYPE_EMBEDDED;
10224 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10225 opts_type = OPTS_TYPE_PT_GENERATE_BE
10226 | OPTS_TYPE_PT_ADD80
10227 | OPTS_TYPE_PT_UNICODE;
10228 kern_type = KERN_TYPE_OLDOFFICE34;
10229 dgst_size = DGST_SIZE_4_4;
10230 parse_func = oldoffice34_parse_hash;
10231 sort_by_digest = sort_by_digest_4_4;
10232 opti_type = OPTI_TYPE_ZERO_BYTE
10233 | OPTI_TYPE_PRECOMPUTE_INIT
10234 | OPTI_TYPE_NOT_ITERATED;
10235 dgst_pos0 = 0;
10236 dgst_pos1 = 1;
10237 dgst_pos2 = 2;
10238 dgst_pos3 = 3;
10239 break;
10240
10241 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10242 salt_type = SALT_TYPE_EMBEDDED;
10243 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10244 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10245 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10246 dgst_size = DGST_SIZE_4_4;
10247 parse_func = oldoffice34cm1_parse_hash;
10248 sort_by_digest = sort_by_digest_4_4;
10249 opti_type = OPTI_TYPE_ZERO_BYTE
10250 | OPTI_TYPE_PRECOMPUTE_INIT
10251 | OPTI_TYPE_NOT_ITERATED;
10252 dgst_pos0 = 0;
10253 dgst_pos1 = 1;
10254 dgst_pos2 = 2;
10255 dgst_pos3 = 3;
10256 break;
10257
10258 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10259 salt_type = SALT_TYPE_EMBEDDED;
10260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10261 opts_type = OPTS_TYPE_PT_GENERATE_BE
10262 | OPTS_TYPE_PT_ADD80
10263 | OPTS_TYPE_PT_UNICODE
10264 | OPTS_TYPE_PT_NEVERCRACK;
10265 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10266 dgst_size = DGST_SIZE_4_4;
10267 parse_func = oldoffice34cm2_parse_hash;
10268 sort_by_digest = sort_by_digest_4_4;
10269 opti_type = OPTI_TYPE_ZERO_BYTE
10270 | OPTI_TYPE_PRECOMPUTE_INIT
10271 | OPTI_TYPE_NOT_ITERATED;
10272 dgst_pos0 = 0;
10273 dgst_pos1 = 1;
10274 dgst_pos2 = 2;
10275 dgst_pos3 = 3;
10276 break;
10277
10278 case 9900: hash_type = HASH_TYPE_MD5;
10279 salt_type = SALT_TYPE_NONE;
10280 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10281 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10282 kern_type = KERN_TYPE_RADMIN2;
10283 dgst_size = DGST_SIZE_4_4;
10284 parse_func = radmin2_parse_hash;
10285 sort_by_digest = sort_by_digest_4_4;
10286 opti_type = OPTI_TYPE_ZERO_BYTE
10287 | OPTI_TYPE_PRECOMPUTE_INIT
10288 | OPTI_TYPE_EARLY_SKIP
10289 | OPTI_TYPE_NOT_ITERATED
10290 | OPTI_TYPE_NOT_SALTED;
10291 dgst_pos0 = 0;
10292 dgst_pos1 = 3;
10293 dgst_pos2 = 2;
10294 dgst_pos3 = 1;
10295 break;
10296
10297 case 10000: hash_type = HASH_TYPE_SHA256;
10298 salt_type = SALT_TYPE_EMBEDDED;
10299 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10300 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10301 kern_type = KERN_TYPE_PBKDF2_SHA256;
10302 dgst_size = DGST_SIZE_4_32;
10303 parse_func = djangopbkdf2_parse_hash;
10304 sort_by_digest = sort_by_digest_4_32;
10305 opti_type = OPTI_TYPE_ZERO_BYTE
10306 | OPTI_TYPE_SLOW_HASH_SIMD;
10307 dgst_pos0 = 0;
10308 dgst_pos1 = 1;
10309 dgst_pos2 = 2;
10310 dgst_pos3 = 3;
10311 break;
10312
10313 case 10100: hash_type = HASH_TYPE_SIPHASH;
10314 salt_type = SALT_TYPE_EMBEDDED;
10315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10316 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10317 kern_type = KERN_TYPE_SIPHASH;
10318 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10319 parse_func = siphash_parse_hash;
10320 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10321 opti_type = OPTI_TYPE_ZERO_BYTE
10322 | OPTI_TYPE_NOT_ITERATED
10323 | OPTI_TYPE_RAW_HASH;
10324 dgst_pos0 = 0;
10325 dgst_pos1 = 1;
10326 dgst_pos2 = 2;
10327 dgst_pos3 = 3;
10328 break;
10329
10330 case 10200: hash_type = HASH_TYPE_MD5;
10331 salt_type = SALT_TYPE_EMBEDDED;
10332 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10333 opts_type = OPTS_TYPE_PT_GENERATE_LE
10334 | OPTS_TYPE_ST_ADD80
10335 | OPTS_TYPE_ST_ADDBITS14;
10336 kern_type = KERN_TYPE_HMACMD5_PW;
10337 dgst_size = DGST_SIZE_4_4;
10338 parse_func = crammd5_parse_hash;
10339 sort_by_digest = sort_by_digest_4_4;
10340 opti_type = OPTI_TYPE_ZERO_BYTE
10341 | OPTI_TYPE_NOT_ITERATED;
10342 dgst_pos0 = 0;
10343 dgst_pos1 = 3;
10344 dgst_pos2 = 2;
10345 dgst_pos3 = 1;
10346 break;
10347
10348 case 10300: hash_type = HASH_TYPE_SHA1;
10349 salt_type = SALT_TYPE_EMBEDDED;
10350 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10351 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10352 kern_type = KERN_TYPE_SAPH_SHA1;
10353 dgst_size = DGST_SIZE_4_5;
10354 parse_func = saph_sha1_parse_hash;
10355 sort_by_digest = sort_by_digest_4_5;
10356 opti_type = OPTI_TYPE_ZERO_BYTE;
10357 dgst_pos0 = 0;
10358 dgst_pos1 = 1;
10359 dgst_pos2 = 2;
10360 dgst_pos3 = 3;
10361 break;
10362
10363 case 10400: hash_type = HASH_TYPE_PDFU16;
10364 salt_type = SALT_TYPE_EMBEDDED;
10365 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10366 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10367 kern_type = KERN_TYPE_PDF11;
10368 dgst_size = DGST_SIZE_4_4;
10369 parse_func = pdf11_parse_hash;
10370 sort_by_digest = sort_by_digest_4_4;
10371 opti_type = OPTI_TYPE_ZERO_BYTE
10372 | OPTI_TYPE_NOT_ITERATED;
10373 dgst_pos0 = 0;
10374 dgst_pos1 = 1;
10375 dgst_pos2 = 2;
10376 dgst_pos3 = 3;
10377 break;
10378
10379 case 10410: hash_type = HASH_TYPE_PDFU16;
10380 salt_type = SALT_TYPE_EMBEDDED;
10381 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10382 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10383 kern_type = KERN_TYPE_PDF11CM1;
10384 dgst_size = DGST_SIZE_4_4;
10385 parse_func = pdf11cm1_parse_hash;
10386 sort_by_digest = sort_by_digest_4_4;
10387 opti_type = OPTI_TYPE_ZERO_BYTE
10388 | OPTI_TYPE_NOT_ITERATED;
10389 dgst_pos0 = 0;
10390 dgst_pos1 = 1;
10391 dgst_pos2 = 2;
10392 dgst_pos3 = 3;
10393 break;
10394
10395 case 10420: hash_type = HASH_TYPE_PDFU16;
10396 salt_type = SALT_TYPE_EMBEDDED;
10397 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10398 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10399 kern_type = KERN_TYPE_PDF11CM2;
10400 dgst_size = DGST_SIZE_4_4;
10401 parse_func = pdf11cm2_parse_hash;
10402 sort_by_digest = sort_by_digest_4_4;
10403 opti_type = OPTI_TYPE_ZERO_BYTE
10404 | OPTI_TYPE_NOT_ITERATED;
10405 dgst_pos0 = 0;
10406 dgst_pos1 = 1;
10407 dgst_pos2 = 2;
10408 dgst_pos3 = 3;
10409 break;
10410
10411 case 10500: hash_type = HASH_TYPE_PDFU16;
10412 salt_type = SALT_TYPE_EMBEDDED;
10413 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10414 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10415 kern_type = KERN_TYPE_PDF14;
10416 dgst_size = DGST_SIZE_4_4;
10417 parse_func = pdf14_parse_hash;
10418 sort_by_digest = sort_by_digest_4_4;
10419 opti_type = OPTI_TYPE_ZERO_BYTE
10420 | OPTI_TYPE_NOT_ITERATED;
10421 dgst_pos0 = 0;
10422 dgst_pos1 = 1;
10423 dgst_pos2 = 2;
10424 dgst_pos3 = 3;
10425 break;
10426
10427 case 10600: hash_type = HASH_TYPE_SHA256;
10428 salt_type = SALT_TYPE_EMBEDDED;
10429 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10430 opts_type = OPTS_TYPE_PT_GENERATE_BE
10431 | OPTS_TYPE_ST_ADD80
10432 | OPTS_TYPE_ST_ADDBITS15
10433 | OPTS_TYPE_HASH_COPY;
10434 kern_type = KERN_TYPE_SHA256_PWSLT;
10435 dgst_size = DGST_SIZE_4_8;
10436 parse_func = pdf17l3_parse_hash;
10437 sort_by_digest = sort_by_digest_4_8;
10438 opti_type = OPTI_TYPE_ZERO_BYTE
10439 | OPTI_TYPE_PRECOMPUTE_INIT
10440 | OPTI_TYPE_PRECOMPUTE_MERKLE
10441 | OPTI_TYPE_EARLY_SKIP
10442 | OPTI_TYPE_NOT_ITERATED
10443 | OPTI_TYPE_APPENDED_SALT
10444 | OPTI_TYPE_RAW_HASH;
10445 dgst_pos0 = 3;
10446 dgst_pos1 = 7;
10447 dgst_pos2 = 2;
10448 dgst_pos3 = 6;
10449 break;
10450
10451 case 10700: hash_type = HASH_TYPE_PDFU32;
10452 salt_type = SALT_TYPE_EMBEDDED;
10453 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10454 opts_type = OPTS_TYPE_PT_GENERATE_LE
10455 | OPTS_TYPE_HASH_COPY;
10456 kern_type = KERN_TYPE_PDF17L8;
10457 dgst_size = DGST_SIZE_4_8;
10458 parse_func = pdf17l8_parse_hash;
10459 sort_by_digest = sort_by_digest_4_8;
10460 opti_type = OPTI_TYPE_ZERO_BYTE
10461 | OPTI_TYPE_NOT_ITERATED;
10462 dgst_pos0 = 0;
10463 dgst_pos1 = 1;
10464 dgst_pos2 = 2;
10465 dgst_pos3 = 3;
10466 break;
10467
10468 case 10800: hash_type = HASH_TYPE_SHA384;
10469 salt_type = SALT_TYPE_NONE;
10470 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10471 opts_type = OPTS_TYPE_PT_GENERATE_BE
10472 | OPTS_TYPE_PT_ADD80
10473 | OPTS_TYPE_PT_ADDBITS15;
10474 kern_type = KERN_TYPE_SHA384;
10475 dgst_size = DGST_SIZE_8_8;
10476 parse_func = sha384_parse_hash;
10477 sort_by_digest = sort_by_digest_8_8;
10478 opti_type = OPTI_TYPE_ZERO_BYTE
10479 | OPTI_TYPE_PRECOMPUTE_INIT
10480 | OPTI_TYPE_PRECOMPUTE_MERKLE
10481 | OPTI_TYPE_EARLY_SKIP
10482 | OPTI_TYPE_NOT_ITERATED
10483 | OPTI_TYPE_NOT_SALTED
10484 | OPTI_TYPE_USES_BITS_64
10485 | OPTI_TYPE_RAW_HASH;
10486 dgst_pos0 = 6;
10487 dgst_pos1 = 7;
10488 dgst_pos2 = 4;
10489 dgst_pos3 = 5;
10490 break;
10491
10492 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10493 salt_type = SALT_TYPE_EMBEDDED;
10494 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10495 opts_type = OPTS_TYPE_PT_GENERATE_LE
10496 | OPTS_TYPE_ST_BASE64
10497 | OPTS_TYPE_HASH_COPY;
10498 kern_type = KERN_TYPE_PBKDF2_SHA256;
10499 dgst_size = DGST_SIZE_4_32;
10500 parse_func = pbkdf2_sha256_parse_hash;
10501 sort_by_digest = sort_by_digest_4_32;
10502 opti_type = OPTI_TYPE_ZERO_BYTE
10503 | OPTI_TYPE_SLOW_HASH_SIMD;
10504 dgst_pos0 = 0;
10505 dgst_pos1 = 1;
10506 dgst_pos2 = 2;
10507 dgst_pos3 = 3;
10508 break;
10509
10510 case 11000: hash_type = HASH_TYPE_MD5;
10511 salt_type = SALT_TYPE_INTERN;
10512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10513 opts_type = OPTS_TYPE_PT_GENERATE_LE
10514 | OPTS_TYPE_PT_ADD80;
10515 kern_type = KERN_TYPE_PRESTASHOP;
10516 dgst_size = DGST_SIZE_4_4;
10517 parse_func = prestashop_parse_hash;
10518 sort_by_digest = sort_by_digest_4_4;
10519 opti_type = OPTI_TYPE_ZERO_BYTE
10520 | OPTI_TYPE_PRECOMPUTE_INIT
10521 | OPTI_TYPE_NOT_ITERATED
10522 | OPTI_TYPE_PREPENDED_SALT;
10523 dgst_pos0 = 0;
10524 dgst_pos1 = 3;
10525 dgst_pos2 = 2;
10526 dgst_pos3 = 1;
10527 break;
10528
10529 case 11100: hash_type = HASH_TYPE_MD5;
10530 salt_type = SALT_TYPE_EMBEDDED;
10531 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10532 opts_type = OPTS_TYPE_PT_GENERATE_LE
10533 | OPTS_TYPE_ST_ADD80;
10534 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10535 dgst_size = DGST_SIZE_4_4;
10536 parse_func = postgresql_auth_parse_hash;
10537 sort_by_digest = sort_by_digest_4_4;
10538 opti_type = OPTI_TYPE_ZERO_BYTE
10539 | OPTI_TYPE_PRECOMPUTE_INIT
10540 | OPTI_TYPE_PRECOMPUTE_MERKLE
10541 | OPTI_TYPE_EARLY_SKIP;
10542 dgst_pos0 = 0;
10543 dgst_pos1 = 3;
10544 dgst_pos2 = 2;
10545 dgst_pos3 = 1;
10546 break;
10547
10548 case 11200: hash_type = HASH_TYPE_SHA1;
10549 salt_type = SALT_TYPE_EMBEDDED;
10550 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10551 opts_type = OPTS_TYPE_PT_GENERATE_BE
10552 | OPTS_TYPE_PT_ADD80
10553 | OPTS_TYPE_ST_HEX;
10554 kern_type = KERN_TYPE_MYSQL_AUTH;
10555 dgst_size = DGST_SIZE_4_5;
10556 parse_func = mysql_auth_parse_hash;
10557 sort_by_digest = sort_by_digest_4_5;
10558 opti_type = OPTI_TYPE_ZERO_BYTE
10559 | OPTI_TYPE_EARLY_SKIP;
10560 dgst_pos0 = 3;
10561 dgst_pos1 = 4;
10562 dgst_pos2 = 2;
10563 dgst_pos3 = 1;
10564 break;
10565
10566 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10567 salt_type = SALT_TYPE_EMBEDDED;
10568 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10569 opts_type = OPTS_TYPE_PT_GENERATE_LE
10570 | OPTS_TYPE_ST_HEX
10571 | OPTS_TYPE_ST_ADD80;
10572 kern_type = KERN_TYPE_BITCOIN_WALLET;
10573 dgst_size = DGST_SIZE_4_4;
10574 parse_func = bitcoin_wallet_parse_hash;
10575 sort_by_digest = sort_by_digest_4_4;
10576 opti_type = OPTI_TYPE_ZERO_BYTE;
10577 dgst_pos0 = 0;
10578 dgst_pos1 = 1;
10579 dgst_pos2 = 2;
10580 dgst_pos3 = 3;
10581 break;
10582
10583 case 11400: hash_type = HASH_TYPE_MD5;
10584 salt_type = SALT_TYPE_EMBEDDED;
10585 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10586 opts_type = OPTS_TYPE_PT_GENERATE_LE
10587 | OPTS_TYPE_PT_ADD80
10588 | OPTS_TYPE_HASH_COPY;
10589 kern_type = KERN_TYPE_SIP_AUTH;
10590 dgst_size = DGST_SIZE_4_4;
10591 parse_func = sip_auth_parse_hash;
10592 sort_by_digest = sort_by_digest_4_4;
10593 opti_type = OPTI_TYPE_ZERO_BYTE;
10594 dgst_pos0 = 0;
10595 dgst_pos1 = 3;
10596 dgst_pos2 = 2;
10597 dgst_pos3 = 1;
10598 break;
10599
10600 case 11500: hash_type = HASH_TYPE_CRC32;
10601 salt_type = SALT_TYPE_INTERN;
10602 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10603 opts_type = OPTS_TYPE_PT_GENERATE_LE
10604 | OPTS_TYPE_ST_GENERATE_LE
10605 | OPTS_TYPE_ST_HEX;
10606 kern_type = KERN_TYPE_CRC32;
10607 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10608 parse_func = crc32_parse_hash;
10609 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10610 opti_type = OPTI_TYPE_ZERO_BYTE;
10611 dgst_pos0 = 0;
10612 dgst_pos1 = 1;
10613 dgst_pos2 = 2;
10614 dgst_pos3 = 3;
10615 break;
10616
10617 case 11600: hash_type = HASH_TYPE_AES;
10618 salt_type = SALT_TYPE_EMBEDDED;
10619 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10620 opts_type = OPTS_TYPE_PT_GENERATE_LE
10621 | OPTS_TYPE_PT_NEVERCRACK;
10622 kern_type = KERN_TYPE_SEVEN_ZIP;
10623 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10624 parse_func = seven_zip_parse_hash;
10625 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10626 opti_type = OPTI_TYPE_ZERO_BYTE;
10627 dgst_pos0 = 0;
10628 dgst_pos1 = 1;
10629 dgst_pos2 = 2;
10630 dgst_pos3 = 3;
10631 break;
10632
10633 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10634 salt_type = SALT_TYPE_NONE;
10635 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10636 opts_type = OPTS_TYPE_PT_GENERATE_LE
10637 | OPTS_TYPE_PT_ADD01;
10638 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10639 dgst_size = DGST_SIZE_4_8;
10640 parse_func = gost2012sbog_256_parse_hash;
10641 sort_by_digest = sort_by_digest_4_8;
10642 opti_type = OPTI_TYPE_ZERO_BYTE;
10643 dgst_pos0 = 0;
10644 dgst_pos1 = 1;
10645 dgst_pos2 = 2;
10646 dgst_pos3 = 3;
10647 break;
10648
10649 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10650 salt_type = SALT_TYPE_NONE;
10651 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10652 opts_type = OPTS_TYPE_PT_GENERATE_LE
10653 | OPTS_TYPE_PT_ADD01;
10654 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10655 dgst_size = DGST_SIZE_4_16;
10656 parse_func = gost2012sbog_512_parse_hash;
10657 sort_by_digest = sort_by_digest_4_16;
10658 opti_type = OPTI_TYPE_ZERO_BYTE;
10659 dgst_pos0 = 0;
10660 dgst_pos1 = 1;
10661 dgst_pos2 = 2;
10662 dgst_pos3 = 3;
10663 break;
10664
10665 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10666 salt_type = SALT_TYPE_EMBEDDED;
10667 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10668 opts_type = OPTS_TYPE_PT_GENERATE_LE
10669 | OPTS_TYPE_ST_BASE64
10670 | OPTS_TYPE_HASH_COPY;
10671 kern_type = KERN_TYPE_PBKDF2_MD5;
10672 dgst_size = DGST_SIZE_4_32;
10673 parse_func = pbkdf2_md5_parse_hash;
10674 sort_by_digest = sort_by_digest_4_32;
10675 opti_type = OPTI_TYPE_ZERO_BYTE
10676 | OPTI_TYPE_SLOW_HASH_SIMD;
10677 dgst_pos0 = 0;
10678 dgst_pos1 = 1;
10679 dgst_pos2 = 2;
10680 dgst_pos3 = 3;
10681 break;
10682
10683 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10684 salt_type = SALT_TYPE_EMBEDDED;
10685 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10686 opts_type = OPTS_TYPE_PT_GENERATE_LE
10687 | OPTS_TYPE_ST_BASE64
10688 | OPTS_TYPE_HASH_COPY;
10689 kern_type = KERN_TYPE_PBKDF2_SHA1;
10690 dgst_size = DGST_SIZE_4_32;
10691 parse_func = pbkdf2_sha1_parse_hash;
10692 sort_by_digest = sort_by_digest_4_32;
10693 opti_type = OPTI_TYPE_ZERO_BYTE
10694 | OPTI_TYPE_SLOW_HASH_SIMD;
10695 dgst_pos0 = 0;
10696 dgst_pos1 = 1;
10697 dgst_pos2 = 2;
10698 dgst_pos3 = 3;
10699 break;
10700
10701 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10702 salt_type = SALT_TYPE_EMBEDDED;
10703 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10704 opts_type = OPTS_TYPE_PT_GENERATE_LE
10705 | OPTS_TYPE_ST_BASE64
10706 | OPTS_TYPE_HASH_COPY;
10707 kern_type = KERN_TYPE_PBKDF2_SHA512;
10708 dgst_size = DGST_SIZE_8_16;
10709 parse_func = pbkdf2_sha512_parse_hash;
10710 sort_by_digest = sort_by_digest_8_16;
10711 opti_type = OPTI_TYPE_ZERO_BYTE
10712 | OPTI_TYPE_USES_BITS_64
10713 | OPTI_TYPE_SLOW_HASH_SIMD;
10714 dgst_pos0 = 0;
10715 dgst_pos1 = 1;
10716 dgst_pos2 = 2;
10717 dgst_pos3 = 3;
10718 break;
10719
10720 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10721 salt_type = SALT_TYPE_EMBEDDED;
10722 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10723 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10724 kern_type = KERN_TYPE_ECRYPTFS;
10725 dgst_size = DGST_SIZE_8_8;
10726 parse_func = ecryptfs_parse_hash;
10727 sort_by_digest = sort_by_digest_8_8;
10728 opti_type = OPTI_TYPE_ZERO_BYTE
10729 | OPTI_TYPE_USES_BITS_64;
10730 dgst_pos0 = 0;
10731 dgst_pos1 = 1;
10732 dgst_pos2 = 2;
10733 dgst_pos3 = 3;
10734 break;
10735
10736 case 12300: hash_type = HASH_TYPE_ORACLET;
10737 salt_type = SALT_TYPE_EMBEDDED;
10738 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10739 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10740 kern_type = KERN_TYPE_ORACLET;
10741 dgst_size = DGST_SIZE_8_16;
10742 parse_func = oraclet_parse_hash;
10743 sort_by_digest = sort_by_digest_8_16;
10744 opti_type = OPTI_TYPE_ZERO_BYTE
10745 | OPTI_TYPE_USES_BITS_64;
10746 dgst_pos0 = 0;
10747 dgst_pos1 = 1;
10748 dgst_pos2 = 2;
10749 dgst_pos3 = 3;
10750 break;
10751
10752 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10753 salt_type = SALT_TYPE_EMBEDDED;
10754 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10755 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10756 kern_type = KERN_TYPE_BSDICRYPT;
10757 dgst_size = DGST_SIZE_4_4;
10758 parse_func = bsdicrypt_parse_hash;
10759 sort_by_digest = sort_by_digest_4_4;
10760 opti_type = OPTI_TYPE_ZERO_BYTE
10761 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10762 dgst_pos0 = 0;
10763 dgst_pos1 = 1;
10764 dgst_pos2 = 2;
10765 dgst_pos3 = 3;
10766 break;
10767
10768 case 12500: hash_type = HASH_TYPE_RAR3HP;
10769 salt_type = SALT_TYPE_EMBEDDED;
10770 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10771 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10772 kern_type = KERN_TYPE_RAR3;
10773 dgst_size = DGST_SIZE_4_4;
10774 parse_func = rar3hp_parse_hash;
10775 sort_by_digest = sort_by_digest_4_4;
10776 opti_type = OPTI_TYPE_ZERO_BYTE;
10777 dgst_pos0 = 0;
10778 dgst_pos1 = 1;
10779 dgst_pos2 = 2;
10780 dgst_pos3 = 3;
10781 break;
10782
10783 case 12600: hash_type = HASH_TYPE_SHA256;
10784 salt_type = SALT_TYPE_INTERN;
10785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10786 opts_type = OPTS_TYPE_PT_GENERATE_BE
10787 | OPTS_TYPE_PT_ADD80;
10788 kern_type = KERN_TYPE_CF10;
10789 dgst_size = DGST_SIZE_4_8;
10790 parse_func = cf10_parse_hash;
10791 sort_by_digest = sort_by_digest_4_8;
10792 opti_type = OPTI_TYPE_ZERO_BYTE
10793 | OPTI_TYPE_PRECOMPUTE_INIT
10794 | OPTI_TYPE_EARLY_SKIP
10795 | OPTI_TYPE_NOT_ITERATED;
10796 dgst_pos0 = 3;
10797 dgst_pos1 = 7;
10798 dgst_pos2 = 2;
10799 dgst_pos3 = 6;
10800 break;
10801
10802 case 12700: hash_type = HASH_TYPE_AES;
10803 salt_type = SALT_TYPE_EMBEDDED;
10804 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10805 opts_type = OPTS_TYPE_PT_GENERATE_LE
10806 | OPTS_TYPE_HASH_COPY;
10807 kern_type = KERN_TYPE_MYWALLET;
10808 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10809 parse_func = mywallet_parse_hash;
10810 sort_by_digest = sort_by_digest_4_5;
10811 opti_type = OPTI_TYPE_ZERO_BYTE;
10812 dgst_pos0 = 0;
10813 dgst_pos1 = 1;
10814 dgst_pos2 = 2;
10815 dgst_pos3 = 3;
10816 break;
10817
10818 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10819 salt_type = SALT_TYPE_EMBEDDED;
10820 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10821 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10822 kern_type = KERN_TYPE_MS_DRSR;
10823 dgst_size = DGST_SIZE_4_8;
10824 parse_func = ms_drsr_parse_hash;
10825 sort_by_digest = sort_by_digest_4_8;
10826 opti_type = OPTI_TYPE_ZERO_BYTE;
10827 dgst_pos0 = 0;
10828 dgst_pos1 = 1;
10829 dgst_pos2 = 2;
10830 dgst_pos3 = 3;
10831 break;
10832
10833 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10834 salt_type = SALT_TYPE_EMBEDDED;
10835 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10836 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10837 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10838 dgst_size = DGST_SIZE_4_8;
10839 parse_func = androidfde_samsung_parse_hash;
10840 sort_by_digest = sort_by_digest_4_8;
10841 opti_type = OPTI_TYPE_ZERO_BYTE;
10842 dgst_pos0 = 0;
10843 dgst_pos1 = 1;
10844 dgst_pos2 = 2;
10845 dgst_pos3 = 3;
10846 break;
10847
10848 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10849 salt_type = SALT_TYPE_EMBEDDED;
10850 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10851 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10852 kern_type = KERN_TYPE_RAR5;
10853 dgst_size = DGST_SIZE_4_4;
10854 parse_func = rar5_parse_hash;
10855 sort_by_digest = sort_by_digest_4_4;
10856 opti_type = OPTI_TYPE_ZERO_BYTE;
10857 dgst_pos0 = 0;
10858 dgst_pos1 = 1;
10859 dgst_pos2 = 2;
10860 dgst_pos3 = 3;
10861 break;
10862
10863 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10864 salt_type = SALT_TYPE_EMBEDDED;
10865 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10866 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10867 kern_type = KERN_TYPE_KRB5TGS;
10868 dgst_size = DGST_SIZE_4_4;
10869 parse_func = krb5tgs_parse_hash;
10870 sort_by_digest = sort_by_digest_4_4;
10871 opti_type = OPTI_TYPE_ZERO_BYTE
10872 | OPTI_TYPE_NOT_ITERATED;
10873 dgst_pos0 = 0;
10874 dgst_pos1 = 1;
10875 dgst_pos2 = 2;
10876 dgst_pos3 = 3;
10877 break;
10878
10879 case 13200: hash_type = HASH_TYPE_AES;
10880 salt_type = SALT_TYPE_EMBEDDED;
10881 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10882 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10883 kern_type = KERN_TYPE_AXCRYPT;
10884 dgst_size = DGST_SIZE_4_4;
10885 parse_func = axcrypt_parse_hash;
10886 sort_by_digest = sort_by_digest_4_4;
10887 opti_type = OPTI_TYPE_ZERO_BYTE;
10888 dgst_pos0 = 0;
10889 dgst_pos1 = 1;
10890 dgst_pos2 = 2;
10891 dgst_pos3 = 3;
10892 break;
10893
10894 case 13300: hash_type = HASH_TYPE_SHA1;
10895 salt_type = SALT_TYPE_NONE;
10896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10897 opts_type = OPTS_TYPE_PT_GENERATE_BE
10898 | OPTS_TYPE_PT_ADD80
10899 | OPTS_TYPE_PT_ADDBITS15;
10900 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10901 dgst_size = DGST_SIZE_4_5;
10902 parse_func = sha1axcrypt_parse_hash;
10903 sort_by_digest = sort_by_digest_4_5;
10904 opti_type = OPTI_TYPE_ZERO_BYTE
10905 | OPTI_TYPE_PRECOMPUTE_INIT
10906 | OPTI_TYPE_EARLY_SKIP
10907 | OPTI_TYPE_NOT_ITERATED
10908 | OPTI_TYPE_NOT_SALTED;
10909 dgst_pos0 = 0;
10910 dgst_pos1 = 4;
10911 dgst_pos2 = 3;
10912 dgst_pos3 = 2;
10913 break;
10914
10915 case 13400: hash_type = HASH_TYPE_AES;
10916 salt_type = SALT_TYPE_EMBEDDED;
10917 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10918 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10919 kern_type = KERN_TYPE_KEEPASS;
10920 dgst_size = DGST_SIZE_4_4;
10921 parse_func = keepass_parse_hash;
10922 sort_by_digest = sort_by_digest_4_4;
10923 opti_type = OPTI_TYPE_ZERO_BYTE;
10924 dgst_pos0 = 0;
10925 dgst_pos1 = 1;
10926 dgst_pos2 = 2;
10927 dgst_pos3 = 3;
10928 break;
10929
10930 case 13500: hash_type = HASH_TYPE_SHA1;
10931 salt_type = SALT_TYPE_EMBEDDED;
10932 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10933 opts_type = OPTS_TYPE_PT_GENERATE_BE
10934 | OPTS_TYPE_PT_UNICODE
10935 | OPTS_TYPE_PT_ADD80;
10936 kern_type = KERN_TYPE_PSTOKEN;
10937 dgst_size = DGST_SIZE_4_5;
10938 parse_func = pstoken_parse_hash;
10939 sort_by_digest = sort_by_digest_4_5;
10940 opti_type = OPTI_TYPE_ZERO_BYTE
10941 | OPTI_TYPE_PRECOMPUTE_INIT
10942 | OPTI_TYPE_EARLY_SKIP
10943 | OPTI_TYPE_NOT_ITERATED
10944 | OPTI_TYPE_PREPENDED_SALT
10945 | OPTI_TYPE_RAW_HASH;
10946 dgst_pos0 = 3;
10947 dgst_pos1 = 4;
10948 dgst_pos2 = 2;
10949 dgst_pos3 = 1;
10950 break;
10951
10952 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10953 salt_type = SALT_TYPE_EMBEDDED;
10954 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10955 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10956 kern_type = KERN_TYPE_ZIP2;
10957 dgst_size = DGST_SIZE_4_4;
10958 parse_func = zip2_parse_hash;
10959 sort_by_digest = sort_by_digest_4_4;
10960 opti_type = OPTI_TYPE_ZERO_BYTE;
10961 dgst_pos0 = 0;
10962 dgst_pos1 = 1;
10963 dgst_pos2 = 2;
10964 dgst_pos3 = 3;
10965 break;
10966
10967 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10968 salt_type = SALT_TYPE_EMBEDDED;
10969 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10970 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10971 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10972 dgst_size = DGST_SIZE_4_5;
10973 parse_func = veracrypt_parse_hash_655331;
10974 sort_by_digest = sort_by_digest_4_5;
10975 opti_type = OPTI_TYPE_ZERO_BYTE;
10976 dgst_pos0 = 0;
10977 dgst_pos1 = 1;
10978 dgst_pos2 = 2;
10979 dgst_pos3 = 3;
10980 break;
10981
10982 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10983 salt_type = SALT_TYPE_EMBEDDED;
10984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10985 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10986 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10987 dgst_size = DGST_SIZE_4_5;
10988 parse_func = veracrypt_parse_hash_655331;
10989 sort_by_digest = sort_by_digest_4_5;
10990 opti_type = OPTI_TYPE_ZERO_BYTE;
10991 dgst_pos0 = 0;
10992 dgst_pos1 = 1;
10993 dgst_pos2 = 2;
10994 dgst_pos3 = 3;
10995 break;
10996
10997 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10998 salt_type = SALT_TYPE_EMBEDDED;
10999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11000 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11001 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11002 dgst_size = DGST_SIZE_4_5;
11003 parse_func = veracrypt_parse_hash_655331;
11004 sort_by_digest = sort_by_digest_4_5;
11005 opti_type = OPTI_TYPE_ZERO_BYTE;
11006 dgst_pos0 = 0;
11007 dgst_pos1 = 1;
11008 dgst_pos2 = 2;
11009 dgst_pos3 = 3;
11010 break;
11011
11012 case 13721: hash_type = HASH_TYPE_SHA512;
11013 salt_type = SALT_TYPE_EMBEDDED;
11014 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11015 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11016 kern_type = KERN_TYPE_TCSHA512_XTS512;
11017 dgst_size = DGST_SIZE_8_8;
11018 parse_func = veracrypt_parse_hash_500000;
11019 sort_by_digest = sort_by_digest_8_8;
11020 opti_type = OPTI_TYPE_ZERO_BYTE
11021 | OPTI_TYPE_USES_BITS_64;
11022 dgst_pos0 = 0;
11023 dgst_pos1 = 1;
11024 dgst_pos2 = 2;
11025 dgst_pos3 = 3;
11026 break;
11027
11028 case 13722: hash_type = HASH_TYPE_SHA512;
11029 salt_type = SALT_TYPE_EMBEDDED;
11030 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11031 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11032 kern_type = KERN_TYPE_TCSHA512_XTS1024;
11033 dgst_size = DGST_SIZE_8_8;
11034 parse_func = veracrypt_parse_hash_500000;
11035 sort_by_digest = sort_by_digest_8_8;
11036 opti_type = OPTI_TYPE_ZERO_BYTE
11037 | OPTI_TYPE_USES_BITS_64;
11038 dgst_pos0 = 0;
11039 dgst_pos1 = 1;
11040 dgst_pos2 = 2;
11041 dgst_pos3 = 3;
11042 break;
11043
11044 case 13723: hash_type = HASH_TYPE_SHA512;
11045 salt_type = SALT_TYPE_EMBEDDED;
11046 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11047 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11048 kern_type = KERN_TYPE_TCSHA512_XTS1536;
11049 dgst_size = DGST_SIZE_8_8;
11050 parse_func = veracrypt_parse_hash_500000;
11051 sort_by_digest = sort_by_digest_8_8;
11052 opti_type = OPTI_TYPE_ZERO_BYTE
11053 | OPTI_TYPE_USES_BITS_64;
11054 dgst_pos0 = 0;
11055 dgst_pos1 = 1;
11056 dgst_pos2 = 2;
11057 dgst_pos3 = 3;
11058 break;
11059
11060 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
11061 salt_type = SALT_TYPE_EMBEDDED;
11062 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11063 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11064 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
11065 dgst_size = DGST_SIZE_4_8;
11066 parse_func = veracrypt_parse_hash_500000;
11067 sort_by_digest = sort_by_digest_4_8;
11068 opti_type = OPTI_TYPE_ZERO_BYTE;
11069 dgst_pos0 = 0;
11070 dgst_pos1 = 1;
11071 dgst_pos2 = 2;
11072 dgst_pos3 = 3;
11073 break;
11074
11075 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
11076 salt_type = SALT_TYPE_EMBEDDED;
11077 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11078 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11079 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
11080 dgst_size = DGST_SIZE_4_8;
11081 parse_func = veracrypt_parse_hash_500000;
11082 sort_by_digest = sort_by_digest_4_8;
11083 opti_type = OPTI_TYPE_ZERO_BYTE;
11084 dgst_pos0 = 0;
11085 dgst_pos1 = 1;
11086 dgst_pos2 = 2;
11087 dgst_pos3 = 3;
11088 break;
11089
11090 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
11091 salt_type = SALT_TYPE_EMBEDDED;
11092 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11093 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11094 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
11095 dgst_size = DGST_SIZE_4_8;
11096 parse_func = veracrypt_parse_hash_500000;
11097 sort_by_digest = sort_by_digest_4_8;
11098 opti_type = OPTI_TYPE_ZERO_BYTE;
11099 dgst_pos0 = 0;
11100 dgst_pos1 = 1;
11101 dgst_pos2 = 2;
11102 dgst_pos3 = 3;
11103 break;
11104
11105 case 13741: hash_type = HASH_TYPE_RIPEMD160;
11106 salt_type = SALT_TYPE_EMBEDDED;
11107 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11108 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11109 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
11110 dgst_size = DGST_SIZE_4_5;
11111 parse_func = veracrypt_parse_hash_327661;
11112 sort_by_digest = sort_by_digest_4_5;
11113 opti_type = OPTI_TYPE_ZERO_BYTE;
11114 dgst_pos0 = 0;
11115 dgst_pos1 = 1;
11116 dgst_pos2 = 2;
11117 dgst_pos3 = 3;
11118 break;
11119
11120 case 13742: hash_type = HASH_TYPE_RIPEMD160;
11121 salt_type = SALT_TYPE_EMBEDDED;
11122 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11123 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11124 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11125 dgst_size = DGST_SIZE_4_5;
11126 parse_func = veracrypt_parse_hash_327661;
11127 sort_by_digest = sort_by_digest_4_5;
11128 opti_type = OPTI_TYPE_ZERO_BYTE;
11129 dgst_pos0 = 0;
11130 dgst_pos1 = 1;
11131 dgst_pos2 = 2;
11132 dgst_pos3 = 3;
11133 break;
11134
11135 case 13743: hash_type = HASH_TYPE_RIPEMD160;
11136 salt_type = SALT_TYPE_EMBEDDED;
11137 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11138 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11139 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11140 dgst_size = DGST_SIZE_4_5;
11141 parse_func = veracrypt_parse_hash_327661;
11142 sort_by_digest = sort_by_digest_4_5;
11143 opti_type = OPTI_TYPE_ZERO_BYTE;
11144 dgst_pos0 = 0;
11145 dgst_pos1 = 1;
11146 dgst_pos2 = 2;
11147 dgst_pos3 = 3;
11148 break;
11149
11150 case 13751: hash_type = HASH_TYPE_SHA256;
11151 salt_type = SALT_TYPE_EMBEDDED;
11152 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11153 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11154 kern_type = KERN_TYPE_VCSHA256_XTS512;
11155 dgst_size = DGST_SIZE_4_8;
11156 parse_func = veracrypt_parse_hash_500000;
11157 sort_by_digest = sort_by_digest_4_8;
11158 opti_type = OPTI_TYPE_ZERO_BYTE;
11159 dgst_pos0 = 0;
11160 dgst_pos1 = 1;
11161 dgst_pos2 = 2;
11162 dgst_pos3 = 3;
11163 break;
11164
11165 case 13752: hash_type = HASH_TYPE_SHA256;
11166 salt_type = SALT_TYPE_EMBEDDED;
11167 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11168 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11169 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11170 dgst_size = DGST_SIZE_4_8;
11171 parse_func = veracrypt_parse_hash_500000;
11172 sort_by_digest = sort_by_digest_4_8;
11173 opti_type = OPTI_TYPE_ZERO_BYTE;
11174 dgst_pos0 = 0;
11175 dgst_pos1 = 1;
11176 dgst_pos2 = 2;
11177 dgst_pos3 = 3;
11178 break;
11179
11180 case 13753: hash_type = HASH_TYPE_SHA256;
11181 salt_type = SALT_TYPE_EMBEDDED;
11182 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11183 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11184 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11185 dgst_size = DGST_SIZE_4_8;
11186 parse_func = veracrypt_parse_hash_500000;
11187 sort_by_digest = sort_by_digest_4_8;
11188 opti_type = OPTI_TYPE_ZERO_BYTE;
11189 dgst_pos0 = 0;
11190 dgst_pos1 = 1;
11191 dgst_pos2 = 2;
11192 dgst_pos3 = 3;
11193 break;
11194
11195 case 13761: hash_type = HASH_TYPE_SHA256;
11196 salt_type = SALT_TYPE_EMBEDDED;
11197 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11198 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11199 kern_type = KERN_TYPE_VCSHA256_XTS512;
11200 dgst_size = DGST_SIZE_4_8;
11201 parse_func = veracrypt_parse_hash_200000;
11202 sort_by_digest = sort_by_digest_4_8;
11203 opti_type = OPTI_TYPE_ZERO_BYTE;
11204 dgst_pos0 = 0;
11205 dgst_pos1 = 1;
11206 dgst_pos2 = 2;
11207 dgst_pos3 = 3;
11208 break;
11209
11210 case 13762: hash_type = HASH_TYPE_SHA256;
11211 salt_type = SALT_TYPE_EMBEDDED;
11212 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11213 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11214 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11215 dgst_size = DGST_SIZE_4_8;
11216 parse_func = veracrypt_parse_hash_200000;
11217 sort_by_digest = sort_by_digest_4_8;
11218 opti_type = OPTI_TYPE_ZERO_BYTE;
11219 dgst_pos0 = 0;
11220 dgst_pos1 = 1;
11221 dgst_pos2 = 2;
11222 dgst_pos3 = 3;
11223 break;
11224
11225 case 13763: hash_type = HASH_TYPE_SHA256;
11226 salt_type = SALT_TYPE_EMBEDDED;
11227 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11228 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11229 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11230 dgst_size = DGST_SIZE_4_8;
11231 parse_func = veracrypt_parse_hash_200000;
11232 sort_by_digest = sort_by_digest_4_8;
11233 opti_type = OPTI_TYPE_ZERO_BYTE;
11234 dgst_pos0 = 0;
11235 dgst_pos1 = 1;
11236 dgst_pos2 = 2;
11237 dgst_pos3 = 3;
11238 break;
11239
11240 case 13800: hash_type = HASH_TYPE_SHA256;
11241 salt_type = SALT_TYPE_EMBEDDED;
11242 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11243 opts_type = OPTS_TYPE_PT_GENERATE_BE
11244 | OPTS_TYPE_PT_UNICODE;
11245 kern_type = KERN_TYPE_WIN8PHONE;
11246 dgst_size = DGST_SIZE_4_8;
11247 parse_func = win8phone_parse_hash;
11248 sort_by_digest = sort_by_digest_4_8;
11249 opti_type = OPTI_TYPE_ZERO_BYTE
11250 | OPTI_TYPE_PRECOMPUTE_INIT
11251 | OPTI_TYPE_EARLY_SKIP
11252 | OPTI_TYPE_NOT_ITERATED
11253 | OPTI_TYPE_RAW_HASH;
11254 dgst_pos0 = 3;
11255 dgst_pos1 = 7;
11256 dgst_pos2 = 2;
11257 dgst_pos3 = 6;
11258 break;
11259
11260 default: usage_mini_print (PROGNAME); return (-1);
11261 }
11262
11263 /**
11264 * parser
11265 */
11266
11267 data.parse_func = parse_func;
11268
11269 /**
11270 * misc stuff
11271 */
11272
11273 if (hex_salt)
11274 {
11275 if (salt_type == SALT_TYPE_INTERN)
11276 {
11277 opts_type |= OPTS_TYPE_ST_HEX;
11278 }
11279 else
11280 {
11281 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11282
11283 return (-1);
11284 }
11285 }
11286
11287 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11288 | (salt_type == SALT_TYPE_EXTERN)
11289 | (salt_type == SALT_TYPE_EMBEDDED)
11290 | (salt_type == SALT_TYPE_VIRTUAL));
11291
11292 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11293
11294 data.hash_type = hash_type;
11295 data.attack_mode = attack_mode;
11296 data.attack_kern = attack_kern;
11297 data.attack_exec = attack_exec;
11298 data.kern_type = kern_type;
11299 data.opts_type = opts_type;
11300 data.dgst_size = dgst_size;
11301 data.salt_type = salt_type;
11302 data.isSalted = isSalted;
11303 data.sort_by_digest = sort_by_digest;
11304 data.dgst_pos0 = dgst_pos0;
11305 data.dgst_pos1 = dgst_pos1;
11306 data.dgst_pos2 = dgst_pos2;
11307 data.dgst_pos3 = dgst_pos3;
11308
11309 esalt_size = 0;
11310
11311 switch (hash_mode)
11312 {
11313 case 2500: esalt_size = sizeof (wpa_t); break;
11314 case 5300: esalt_size = sizeof (ikepsk_t); break;
11315 case 5400: esalt_size = sizeof (ikepsk_t); break;
11316 case 5500: esalt_size = sizeof (netntlm_t); break;
11317 case 5600: esalt_size = sizeof (netntlm_t); break;
11318 case 6211: esalt_size = sizeof (tc_t); break;
11319 case 6212: esalt_size = sizeof (tc_t); break;
11320 case 6213: esalt_size = sizeof (tc_t); break;
11321 case 6221: esalt_size = sizeof (tc_t); break;
11322 case 6222: esalt_size = sizeof (tc_t); break;
11323 case 6223: esalt_size = sizeof (tc_t); break;
11324 case 6231: esalt_size = sizeof (tc_t); break;
11325 case 6232: esalt_size = sizeof (tc_t); break;
11326 case 6233: esalt_size = sizeof (tc_t); break;
11327 case 6241: esalt_size = sizeof (tc_t); break;
11328 case 6242: esalt_size = sizeof (tc_t); break;
11329 case 6243: esalt_size = sizeof (tc_t); break;
11330 case 6600: esalt_size = sizeof (agilekey_t); break;
11331 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11332 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11333 case 7300: esalt_size = sizeof (rakp_t); break;
11334 case 7500: esalt_size = sizeof (krb5pa_t); break;
11335 case 8200: esalt_size = sizeof (cloudkey_t); break;
11336 case 8800: esalt_size = sizeof (androidfde_t); break;
11337 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11338 case 9400: esalt_size = sizeof (office2007_t); break;
11339 case 9500: esalt_size = sizeof (office2010_t); break;
11340 case 9600: esalt_size = sizeof (office2013_t); break;
11341 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11342 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11343 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11344 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11345 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11346 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11347 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11348 case 10200: esalt_size = sizeof (cram_md5_t); break;
11349 case 10400: esalt_size = sizeof (pdf_t); break;
11350 case 10410: esalt_size = sizeof (pdf_t); break;
11351 case 10420: esalt_size = sizeof (pdf_t); break;
11352 case 10500: esalt_size = sizeof (pdf_t); break;
11353 case 10600: esalt_size = sizeof (pdf_t); break;
11354 case 10700: esalt_size = sizeof (pdf_t); break;
11355 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11356 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11357 case 11400: esalt_size = sizeof (sip_t); break;
11358 case 11600: esalt_size = sizeof (seven_zip_t); break;
11359 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11360 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11361 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11362 case 13000: esalt_size = sizeof (rar5_t); break;
11363 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11364 case 13400: esalt_size = sizeof (keepass_t); break;
11365 case 13500: esalt_size = sizeof (pstoken_t); break;
11366 case 13600: esalt_size = sizeof (zip2_t); break;
11367 case 13711: esalt_size = sizeof (tc_t); break;
11368 case 13712: esalt_size = sizeof (tc_t); break;
11369 case 13713: esalt_size = sizeof (tc_t); break;
11370 case 13721: esalt_size = sizeof (tc_t); break;
11371 case 13722: esalt_size = sizeof (tc_t); break;
11372 case 13723: esalt_size = sizeof (tc_t); break;
11373 case 13731: esalt_size = sizeof (tc_t); break;
11374 case 13732: esalt_size = sizeof (tc_t); break;
11375 case 13733: esalt_size = sizeof (tc_t); break;
11376 case 13741: esalt_size = sizeof (tc_t); break;
11377 case 13742: esalt_size = sizeof (tc_t); break;
11378 case 13743: esalt_size = sizeof (tc_t); break;
11379 case 13751: esalt_size = sizeof (tc_t); break;
11380 case 13752: esalt_size = sizeof (tc_t); break;
11381 case 13753: esalt_size = sizeof (tc_t); break;
11382 case 13761: esalt_size = sizeof (tc_t); break;
11383 case 13762: esalt_size = sizeof (tc_t); break;
11384 case 13763: esalt_size = sizeof (tc_t); break;
11385 case 13800: esalt_size = sizeof (win8phone_t); break;
11386 }
11387
11388 data.esalt_size = esalt_size;
11389
11390 /**
11391 * choose dictionary parser
11392 */
11393
11394 if (hash_type == HASH_TYPE_LM)
11395 {
11396 get_next_word_func = get_next_word_lm;
11397 }
11398 else if (opts_type & OPTS_TYPE_PT_UPPER)
11399 {
11400 get_next_word_func = get_next_word_uc;
11401 }
11402 else
11403 {
11404 get_next_word_func = get_next_word_std;
11405 }
11406
11407 /**
11408 * dictstat
11409 */
11410
11411 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11412
11413 #ifdef _POSIX
11414 size_t dictstat_nmemb = 0;
11415 #endif
11416
11417 #ifdef _WIN
11418 uint dictstat_nmemb = 0;
11419 #endif
11420
11421 char dictstat[256] = { 0 };
11422
11423 FILE *dictstat_fp = NULL;
11424
11425 if (keyspace == 0)
11426 {
11427 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11428
11429 dictstat_fp = fopen (dictstat, "rb");
11430
11431 if (dictstat_fp)
11432 {
11433 #ifdef _POSIX
11434 struct stat tmpstat;
11435
11436 fstat (fileno (dictstat_fp), &tmpstat);
11437 #endif
11438
11439 #ifdef _WIN
11440 struct stat64 tmpstat;
11441
11442 _fstat64 (fileno (dictstat_fp), &tmpstat);
11443 #endif
11444
11445 if (tmpstat.st_mtime < COMPTIME)
11446 {
11447 /* with v0.15 the format changed so we have to ensure user is using a good version
11448 since there is no version-header in the dictstat file */
11449
11450 fclose (dictstat_fp);
11451
11452 unlink (dictstat);
11453 }
11454 else
11455 {
11456 while (!feof (dictstat_fp))
11457 {
11458 dictstat_t d;
11459
11460 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11461
11462 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11463
11464 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11465 {
11466 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11467
11468 return -1;
11469 }
11470 }
11471
11472 fclose (dictstat_fp);
11473 }
11474 }
11475 }
11476
11477 /**
11478 * potfile
11479 */
11480
11481 char potfile[256] = { 0 };
11482
11483 if (potfile_path == NULL)
11484 {
11485 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11486 }
11487 else
11488 {
11489 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11490 }
11491
11492 data.pot_fp = NULL;
11493
11494 FILE *out_fp = NULL;
11495 FILE *pot_fp = NULL;
11496
11497 if (show == 1 || left == 1)
11498 {
11499 pot_fp = fopen (potfile, "rb");
11500
11501 if (pot_fp == NULL)
11502 {
11503 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11504
11505 return (-1);
11506 }
11507
11508 if (outfile != NULL)
11509 {
11510 if ((out_fp = fopen (outfile, "ab")) == NULL)
11511 {
11512 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11513
11514 fclose (pot_fp);
11515
11516 return (-1);
11517 }
11518 }
11519 else
11520 {
11521 out_fp = stdout;
11522 }
11523 }
11524 else
11525 {
11526 if (potfile_disable == 0)
11527 {
11528 pot_fp = fopen (potfile, "ab");
11529
11530 if (pot_fp == NULL)
11531 {
11532 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11533
11534 return (-1);
11535 }
11536
11537 data.pot_fp = pot_fp;
11538 }
11539 }
11540
11541 pot_t *pot = NULL;
11542
11543 uint pot_cnt = 0;
11544 uint pot_avail = 0;
11545
11546 if (show == 1 || left == 1)
11547 {
11548 SUPPRESS_OUTPUT = 1;
11549
11550 pot_avail = count_lines (pot_fp);
11551
11552 rewind (pot_fp);
11553
11554 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11555
11556 uint pot_hashes_avail = 0;
11557
11558 uint line_num = 0;
11559
11560 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11561
11562 while (!feof (pot_fp))
11563 {
11564 line_num++;
11565
11566 int line_len = fgetl (pot_fp, line_buf);
11567
11568 if (line_len == 0) continue;
11569
11570 char *plain_buf = line_buf + line_len;
11571
11572 pot_t *pot_ptr = &pot[pot_cnt];
11573
11574 hash_t *hashes_buf = &pot_ptr->hash;
11575
11576 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11577 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11578
11579 if (pot_cnt == pot_hashes_avail)
11580 {
11581 uint pos = 0;
11582
11583 for (pos = 0; pos < INCR_POT; pos++)
11584 {
11585 if ((pot_cnt + pos) >= pot_avail) break;
11586
11587 pot_t *tmp_pot = &pot[pot_cnt + pos];
11588
11589 hash_t *tmp_hash = &tmp_pot->hash;
11590
11591 tmp_hash->digest = mymalloc (dgst_size);
11592
11593 if (isSalted)
11594 {
11595 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11596 }
11597
11598 if (esalt_size)
11599 {
11600 tmp_hash->esalt = mymalloc (esalt_size);
11601 }
11602
11603 pot_hashes_avail++;
11604 }
11605 }
11606
11607 int plain_len = 0;
11608
11609 int parser_status;
11610
11611 int iter = MAX_CUT_TRIES;
11612
11613 do
11614 {
11615 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11616 {
11617 if (line_buf[i] == ':')
11618 {
11619 line_len--;
11620
11621 break;
11622 }
11623 }
11624
11625 if (data.hash_mode != 2500)
11626 {
11627 parser_status = parse_func (line_buf, line_len, hashes_buf);
11628 }
11629 else
11630 {
11631 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11632
11633 if (line_len > max_salt_size)
11634 {
11635 parser_status = PARSER_GLOBAL_LENGTH;
11636 }
11637 else
11638 {
11639 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11640
11641 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11642
11643 hashes_buf->salt->salt_len = line_len;
11644
11645 parser_status = PARSER_OK;
11646 }
11647 }
11648
11649 // if NOT parsed without error, we add the ":" to the plain
11650
11651 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11652 {
11653 plain_len++;
11654 plain_buf--;
11655 }
11656
11657 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11658
11659 if (parser_status < PARSER_GLOBAL_ZERO)
11660 {
11661 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11662
11663 continue;
11664 }
11665
11666 if (plain_len >= 255) continue;
11667
11668 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11669
11670 pot_ptr->plain_len = plain_len;
11671
11672 pot_cnt++;
11673 }
11674
11675 myfree (line_buf);
11676
11677 fclose (pot_fp);
11678
11679 SUPPRESS_OUTPUT = 0;
11680
11681 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11682 }
11683
11684 /**
11685 * word len
11686 */
11687
11688 uint pw_min = PW_MIN;
11689 uint pw_max = PW_MAX;
11690
11691 switch (hash_mode)
11692 {
11693 case 125: if (pw_max > 32) pw_max = 32;
11694 break;
11695 case 400: if (pw_max > 40) pw_max = 40;
11696 break;
11697 case 500: if (pw_max > 16) pw_max = 16;
11698 break;
11699 case 1500: if (pw_max > 8) pw_max = 8;
11700 break;
11701 case 1600: if (pw_max > 16) pw_max = 16;
11702 break;
11703 case 1800: if (pw_max > 16) pw_max = 16;
11704 break;
11705 case 2100: if (pw_max > 16) pw_max = 16;
11706 break;
11707 case 2500: if (pw_min < 8) pw_min = 8;
11708 break;
11709 case 3000: if (pw_max > 7) pw_max = 7;
11710 break;
11711 case 5200: if (pw_max > 24) pw_max = 24;
11712 break;
11713 case 5800: if (pw_max > 16) pw_max = 16;
11714 break;
11715 case 6300: if (pw_max > 16) pw_max = 16;
11716 break;
11717 case 7400: if (pw_max > 16) pw_max = 16;
11718 break;
11719 case 7700: if (pw_max > 8) pw_max = 8;
11720 break;
11721 case 7900: if (pw_max > 48) pw_max = 48;
11722 break;
11723 case 8500: if (pw_max > 8) pw_max = 8;
11724 break;
11725 case 8600: if (pw_max > 16) pw_max = 16;
11726 break;
11727 case 9710: pw_min = 5;
11728 pw_max = 5;
11729 break;
11730 case 9810: pw_min = 5;
11731 pw_max = 5;
11732 break;
11733 case 10410: pw_min = 5;
11734 pw_max = 5;
11735 break;
11736 case 10300: if (pw_max < 3) pw_min = 3;
11737 if (pw_max > 40) pw_max = 40;
11738 break;
11739 case 10500: if (pw_max < 3) pw_min = 3;
11740 if (pw_max > 40) pw_max = 40;
11741 break;
11742 case 10700: if (pw_max > 16) pw_max = 16;
11743 break;
11744 case 11300: if (pw_max > 40) pw_max = 40;
11745 break;
11746 case 11600: if (pw_max > 32) pw_max = 32;
11747 break;
11748 case 12500: if (pw_max > 20) pw_max = 20;
11749 break;
11750 case 12800: if (pw_max > 24) pw_max = 24;
11751 break;
11752 }
11753
11754 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11755 {
11756 switch (attack_kern)
11757 {
11758 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11759 break;
11760 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11761 break;
11762 }
11763 }
11764
11765 /**
11766 * charsets : keep them together for more easy maintainnce
11767 */
11768
11769 cs_t mp_sys[6] = { { { 0 }, 0 } };
11770 cs_t mp_usr[4] = { { { 0 }, 0 } };
11771
11772 mp_setup_sys (mp_sys);
11773
11774 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11775 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11776 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11777 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11778
11779 /**
11780 * load hashes, part I: find input mode, count hashes
11781 */
11782
11783 uint hashlist_mode = 0;
11784 uint hashlist_format = HLFMT_HASHCAT;
11785
11786 uint hashes_avail = 0;
11787
11788 if ((benchmark == 0) && (stdout_flag == 0))
11789 {
11790 struct stat f;
11791
11792 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11793
11794 if ((hash_mode == 2500) ||
11795 (hash_mode == 5200) ||
11796 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11797 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11798 (hash_mode == 9000))
11799 {
11800 hashlist_mode = HL_MODE_ARG;
11801
11802 char *hashfile = myargv[optind];
11803
11804 data.hashfile = hashfile;
11805
11806 logfile_top_var_string ("target", hashfile);
11807 }
11808
11809 if (hashlist_mode == HL_MODE_ARG)
11810 {
11811 if (hash_mode == 2500)
11812 {
11813 struct stat st;
11814
11815 if (stat (data.hashfile, &st) == -1)
11816 {
11817 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11818
11819 return (-1);
11820 }
11821
11822 hashes_avail = st.st_size / sizeof (hccap_t);
11823 }
11824 else
11825 {
11826 hashes_avail = 1;
11827 }
11828 }
11829 else if (hashlist_mode == HL_MODE_FILE)
11830 {
11831 char *hashfile = myargv[optind];
11832
11833 data.hashfile = hashfile;
11834
11835 logfile_top_var_string ("target", hashfile);
11836
11837 FILE *fp = NULL;
11838
11839 if ((fp = fopen (hashfile, "rb")) == NULL)
11840 {
11841 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11842
11843 return (-1);
11844 }
11845
11846 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11847
11848 hashes_avail = count_lines (fp);
11849
11850 rewind (fp);
11851
11852 if (hashes_avail == 0)
11853 {
11854 log_error ("ERROR: hashfile is empty or corrupt");
11855
11856 fclose (fp);
11857
11858 return (-1);
11859 }
11860
11861 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11862
11863 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11864 {
11865 log_error ("ERROR: remove not supported in native hashfile-format mode");
11866
11867 fclose (fp);
11868
11869 return (-1);
11870 }
11871
11872 fclose (fp);
11873 }
11874 }
11875 else
11876 {
11877 hashlist_mode = HL_MODE_ARG;
11878
11879 hashes_avail = 1;
11880 }
11881
11882 if (hash_mode == 3000) hashes_avail *= 2;
11883
11884 data.hashlist_mode = hashlist_mode;
11885 data.hashlist_format = hashlist_format;
11886
11887 logfile_top_uint (hashlist_mode);
11888 logfile_top_uint (hashlist_format);
11889
11890 /**
11891 * load hashes, part II: allocate required memory, set pointers
11892 */
11893
11894 hash_t *hashes_buf = NULL;
11895 void *digests_buf = NULL;
11896 salt_t *salts_buf = NULL;
11897 void *esalts_buf = NULL;
11898
11899 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11900
11901 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11902
11903 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11904 {
11905 u32 hash_pos;
11906
11907 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11908 {
11909 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11910
11911 hashes_buf[hash_pos].hash_info = hash_info;
11912
11913 if (username && (remove || show || left))
11914 {
11915 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11916 }
11917
11918 if (benchmark)
11919 {
11920 hash_info->orighash = (char *) mymalloc (256);
11921 }
11922 }
11923 }
11924
11925 if (isSalted)
11926 {
11927 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11928
11929 if (esalt_size)
11930 {
11931 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11932 }
11933 }
11934 else
11935 {
11936 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11937 }
11938
11939 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11940 {
11941 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11942
11943 if (isSalted)
11944 {
11945 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11946
11947 if (esalt_size)
11948 {
11949 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11950 }
11951 }
11952 else
11953 {
11954 hashes_buf[hash_pos].salt = &salts_buf[0];
11955 }
11956 }
11957
11958 /**
11959 * load hashes, part III: parse hashes or generate them if benchmark
11960 */
11961
11962 uint hashes_cnt = 0;
11963
11964 if (benchmark == 0)
11965 {
11966 if (keyspace == 1)
11967 {
11968 // useless to read hash file for keyspace, cheat a little bit w/ optind
11969 }
11970 else if (stdout_flag == 1)
11971 {
11972 // useless to read hash file for stdout, cheat a little bit w/ optind
11973 }
11974 else if (hashes_avail == 0)
11975 {
11976 }
11977 else if (hashlist_mode == HL_MODE_ARG)
11978 {
11979 char *input_buf = myargv[optind];
11980
11981 uint input_len = strlen (input_buf);
11982
11983 logfile_top_var_string ("target", input_buf);
11984
11985 char *hash_buf = NULL;
11986 int hash_len = 0;
11987
11988 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11989
11990 bool hash_fmt_error = 0;
11991
11992 if (hash_len < 1) hash_fmt_error = 1;
11993 if (hash_buf == NULL) hash_fmt_error = 1;
11994
11995 if (hash_fmt_error)
11996 {
11997 log_info ("WARNING: Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11998 }
11999 else
12000 {
12001 if (opts_type & OPTS_TYPE_HASH_COPY)
12002 {
12003 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12004
12005 hash_info_tmp->orighash = mystrdup (hash_buf);
12006 }
12007
12008 if (isSalted)
12009 {
12010 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
12011 }
12012
12013 int parser_status = PARSER_OK;
12014
12015 if (hash_mode == 2500)
12016 {
12017 if (hash_len == 0)
12018 {
12019 log_error ("ERROR: hccap file not specified");
12020
12021 return (-1);
12022 }
12023
12024 hashlist_mode = HL_MODE_FILE;
12025
12026 data.hashlist_mode = hashlist_mode;
12027
12028 FILE *fp = fopen (hash_buf, "rb");
12029
12030 if (fp == NULL)
12031 {
12032 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
12033
12034 return (-1);
12035 }
12036
12037 if (hashes_avail < 1)
12038 {
12039 log_error ("ERROR: hccap file is empty or corrupt");
12040
12041 fclose (fp);
12042
12043 return (-1);
12044 }
12045
12046 uint hccap_size = sizeof (hccap_t);
12047
12048 char *in = (char *) mymalloc (hccap_size);
12049
12050 while (!feof (fp))
12051 {
12052 int n = fread (in, hccap_size, 1, fp);
12053
12054 if (n != 1)
12055 {
12056 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
12057
12058 break;
12059 }
12060
12061 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
12062
12063 if (parser_status != PARSER_OK)
12064 {
12065 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
12066
12067 continue;
12068 }
12069
12070 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
12071
12072 if ((show == 1) || (left == 1))
12073 {
12074 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
12075
12076 char *salt_ptr = (char *) tmp_salt->salt_buf;
12077
12078 int cur_pos = tmp_salt->salt_len;
12079 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12080
12081 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
12082
12083 // do the appending task
12084
12085 snprintf (salt_ptr + cur_pos,
12086 rem_len,
12087 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
12088 wpa->orig_mac1[0],
12089 wpa->orig_mac1[1],
12090 wpa->orig_mac1[2],
12091 wpa->orig_mac1[3],
12092 wpa->orig_mac1[4],
12093 wpa->orig_mac1[5],
12094 wpa->orig_mac2[0],
12095 wpa->orig_mac2[1],
12096 wpa->orig_mac2[2],
12097 wpa->orig_mac2[3],
12098 wpa->orig_mac2[4],
12099 wpa->orig_mac2[5]);
12100
12101 // memset () the remaining part of the salt
12102
12103 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12104 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12105
12106 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12107
12108 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12109 }
12110
12111 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);
12112 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);
12113
12114 hashes_cnt++;
12115 }
12116
12117 fclose (fp);
12118
12119 myfree (in);
12120 }
12121 else if (hash_mode == 3000)
12122 {
12123 if (hash_len == 32)
12124 {
12125 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12126
12127 hash_t *lm_hash_left = NULL;
12128
12129 if (parser_status == PARSER_OK)
12130 {
12131 lm_hash_left = &hashes_buf[hashes_cnt];
12132
12133 hashes_cnt++;
12134 }
12135 else
12136 {
12137 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12138 }
12139
12140 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12141
12142 hash_t *lm_hash_right = NULL;
12143
12144 if (parser_status == PARSER_OK)
12145 {
12146 lm_hash_right = &hashes_buf[hashes_cnt];
12147
12148 hashes_cnt++;
12149 }
12150 else
12151 {
12152 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12153 }
12154
12155 // show / left
12156
12157 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12158 {
12159 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);
12160 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);
12161 }
12162 }
12163 else
12164 {
12165 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12166
12167 if (parser_status == PARSER_OK)
12168 {
12169 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12170 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12171 }
12172
12173 if (parser_status == PARSER_OK)
12174 {
12175 hashes_cnt++;
12176 }
12177 else
12178 {
12179 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12180 }
12181 }
12182 }
12183 else
12184 {
12185 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12186
12187 if (parser_status == PARSER_OK)
12188 {
12189 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12190 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12191 }
12192
12193 if (parser_status == PARSER_OK)
12194 {
12195 hashes_cnt++;
12196 }
12197 else
12198 {
12199 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12200 }
12201 }
12202 }
12203 }
12204 else if (hashlist_mode == HL_MODE_FILE)
12205 {
12206 char *hashfile = data.hashfile;
12207
12208 FILE *fp;
12209
12210 if ((fp = fopen (hashfile, "rb")) == NULL)
12211 {
12212 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12213
12214 return (-1);
12215 }
12216
12217 uint line_num = 0;
12218
12219 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12220
12221 while (!feof (fp))
12222 {
12223 line_num++;
12224
12225 int line_len = fgetl (fp, line_buf);
12226
12227 if (line_len == 0) continue;
12228
12229 char *hash_buf = NULL;
12230 int hash_len = 0;
12231
12232 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12233
12234 bool hash_fmt_error = 0;
12235
12236 if (hash_len < 1) hash_fmt_error = 1;
12237 if (hash_buf == NULL) hash_fmt_error = 1;
12238
12239 if (hash_fmt_error)
12240 {
12241 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12242
12243 continue;
12244 }
12245
12246 if (username)
12247 {
12248 char *user_buf = NULL;
12249 int user_len = 0;
12250
12251 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12252
12253 if (remove || show)
12254 {
12255 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12256
12257 *user = (user_t *) mymalloc (sizeof (user_t));
12258
12259 user_t *user_ptr = *user;
12260
12261 if (user_buf != NULL)
12262 {
12263 user_ptr->user_name = mystrdup (user_buf);
12264 }
12265 else
12266 {
12267 user_ptr->user_name = mystrdup ("");
12268 }
12269
12270 user_ptr->user_len = user_len;
12271 }
12272 }
12273
12274 if (opts_type & OPTS_TYPE_HASH_COPY)
12275 {
12276 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12277
12278 hash_info_tmp->orighash = mystrdup (hash_buf);
12279 }
12280
12281 if (isSalted)
12282 {
12283 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12284 }
12285
12286 if (hash_mode == 3000)
12287 {
12288 if (hash_len == 32)
12289 {
12290 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12291
12292 if (parser_status < PARSER_GLOBAL_ZERO)
12293 {
12294 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12295
12296 continue;
12297 }
12298
12299 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12300
12301 hashes_cnt++;
12302
12303 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12304
12305 if (parser_status < PARSER_GLOBAL_ZERO)
12306 {
12307 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12308
12309 continue;
12310 }
12311
12312 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12313
12314 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);
12315
12316 hashes_cnt++;
12317
12318 // show / left
12319
12320 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);
12321 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);
12322 }
12323 else
12324 {
12325 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12326
12327 if (parser_status < PARSER_GLOBAL_ZERO)
12328 {
12329 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12330
12331 continue;
12332 }
12333
12334 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);
12335
12336 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12337 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12338
12339 hashes_cnt++;
12340 }
12341 }
12342 else
12343 {
12344 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12345
12346 if (parser_status < PARSER_GLOBAL_ZERO)
12347 {
12348 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12349
12350 continue;
12351 }
12352
12353 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);
12354
12355 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12356 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12357
12358 hashes_cnt++;
12359 }
12360 }
12361
12362 myfree (line_buf);
12363
12364 fclose (fp);
12365
12366 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12367
12368 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12369 }
12370 }
12371 else
12372 {
12373 if (isSalted)
12374 {
12375 hashes_buf[0].salt->salt_len = 8;
12376
12377 // special salt handling
12378
12379 switch (hash_mode)
12380 {
12381 case 1500: hashes_buf[0].salt->salt_len = 2;
12382 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12383 break;
12384 case 1731: hashes_buf[0].salt->salt_len = 4;
12385 break;
12386 case 2410: hashes_buf[0].salt->salt_len = 4;
12387 break;
12388 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12389 break;
12390 case 3100: hashes_buf[0].salt->salt_len = 1;
12391 break;
12392 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12393 break;
12394 case 5800: hashes_buf[0].salt->salt_len = 16;
12395 break;
12396 case 6800: hashes_buf[0].salt->salt_len = 32;
12397 break;
12398 case 8400: hashes_buf[0].salt->salt_len = 40;
12399 break;
12400 case 8800: hashes_buf[0].salt->salt_len = 16;
12401 break;
12402 case 8900: hashes_buf[0].salt->salt_len = 16;
12403 hashes_buf[0].salt->scrypt_N = 1024;
12404 hashes_buf[0].salt->scrypt_r = 1;
12405 hashes_buf[0].salt->scrypt_p = 1;
12406 break;
12407 case 9100: hashes_buf[0].salt->salt_len = 16;
12408 break;
12409 case 9300: hashes_buf[0].salt->salt_len = 14;
12410 hashes_buf[0].salt->scrypt_N = 16384;
12411 hashes_buf[0].salt->scrypt_r = 1;
12412 hashes_buf[0].salt->scrypt_p = 1;
12413 break;
12414 case 9400: hashes_buf[0].salt->salt_len = 16;
12415 break;
12416 case 9500: hashes_buf[0].salt->salt_len = 16;
12417 break;
12418 case 9600: hashes_buf[0].salt->salt_len = 16;
12419 break;
12420 case 9700: hashes_buf[0].salt->salt_len = 16;
12421 break;
12422 case 9710: hashes_buf[0].salt->salt_len = 16;
12423 break;
12424 case 9720: hashes_buf[0].salt->salt_len = 16;
12425 break;
12426 case 9800: hashes_buf[0].salt->salt_len = 16;
12427 break;
12428 case 9810: hashes_buf[0].salt->salt_len = 16;
12429 break;
12430 case 9820: hashes_buf[0].salt->salt_len = 16;
12431 break;
12432 case 10300: hashes_buf[0].salt->salt_len = 12;
12433 break;
12434 case 11500: hashes_buf[0].salt->salt_len = 4;
12435 break;
12436 case 11600: hashes_buf[0].salt->salt_len = 4;
12437 break;
12438 case 12400: hashes_buf[0].salt->salt_len = 4;
12439 break;
12440 case 12500: hashes_buf[0].salt->salt_len = 8;
12441 break;
12442 case 12600: hashes_buf[0].salt->salt_len = 64;
12443 break;
12444 }
12445
12446 // special esalt handling
12447
12448 switch (hash_mode)
12449 {
12450 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12451 break;
12452 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12453 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12454 break;
12455 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12456 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12457 break;
12458 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12459 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12460 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12461 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12462 break;
12463 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12464 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12465 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12466 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12467 break;
12468 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12469 break;
12470 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12471 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12472 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12473 break;
12474 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12475 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12476 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12477 break;
12478 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12479 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12480 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12481 break;
12482 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12483 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12484 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12485 break;
12486 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12487 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12488 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12489 break;
12490 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12491 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12492 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12493 break;
12494 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12495 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12496 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12497 break;
12498 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12499 break;
12500 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12501 break;
12502 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12503 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12504 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12505 break;
12506 }
12507 }
12508
12509 // set hashfile
12510
12511 switch (hash_mode)
12512 {
12513 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12514 break;
12515 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12516 break;
12517 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12518 break;
12519 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12520 break;
12521 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12522 break;
12523 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12524 break;
12525 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12526 break;
12527 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12528 break;
12529 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12530 break;
12531 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12532 break;
12533 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12534 break;
12535 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12536 break;
12537 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12538 break;
12539 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12540 break;
12541 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12542 break;
12543 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12544 break;
12545 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12546 break;
12547 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12548 break;
12549 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12550 break;
12551 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12552 break;
12553 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12554 break;
12555 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12556 break;
12557 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12558 break;
12559 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12560 break;
12561 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12562 break;
12563 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12564 break;
12565 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12566 break;
12567 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12568 break;
12569 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12570 break;
12571 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12572 break;
12573 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12574 break;
12575 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12576 break;
12577 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12578 break;
12579 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12580 break;
12581 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12582 break;
12583 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12584 break;
12585 }
12586
12587 // set default iterations
12588
12589 switch (hash_mode)
12590 {
12591 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12592 break;
12593 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12594 break;
12595 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12596 break;
12597 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12598 break;
12599 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12600 break;
12601 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12602 break;
12603 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12604 break;
12605 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12606 break;
12607 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12608 break;
12609 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12610 break;
12611 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12612 break;
12613 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12614 break;
12615 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12616 break;
12617 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12618 break;
12619 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12620 break;
12621 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12622 break;
12623 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12624 break;
12625 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12626 break;
12627 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12628 break;
12629 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12630 break;
12631 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12632 break;
12633 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12634 break;
12635 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12636 break;
12637 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12638 break;
12639 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12640 break;
12641 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12642 break;
12643 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12644 break;
12645 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12646 break;
12647 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12648 break;
12649 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12650 break;
12651 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12652 break;
12653 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12654 break;
12655 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12656 break;
12657 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12658 break;
12659 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12660 break;
12661 case 8900: hashes_buf[0].salt->salt_iter = 1;
12662 break;
12663 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12664 break;
12665 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12666 break;
12667 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12668 break;
12669 case 9300: hashes_buf[0].salt->salt_iter = 1;
12670 break;
12671 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12672 break;
12673 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12674 break;
12675 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12676 break;
12677 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12678 break;
12679 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12680 break;
12681 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12682 break;
12683 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12684 break;
12685 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12686 break;
12687 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12688 break;
12689 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12690 break;
12691 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12692 break;
12693 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12694 break;
12695 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12696 break;
12697 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12698 break;
12699 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12700 break;
12701 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12702 break;
12703 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12704 break;
12705 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12706 break;
12707 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12708 break;
12709 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12710 break;
12711 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12712 break;
12713 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12714 break;
12715 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12716 break;
12717 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12718 break;
12719 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12720 break;
12721 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12722 break;
12723 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12724 break;
12725 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12726 break;
12727 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12728 break;
12729 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12730 break;
12731 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12732 break;
12733 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12734 break;
12735 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12736 break;
12737 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12738 break;
12739 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12740 break;
12741 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12742 break;
12743 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12744 break;
12745 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12746 break;
12747 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12748 break;
12749 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12750 break;
12751 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12752 break;
12753 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12754 break;
12755 }
12756
12757 hashes_cnt = 1;
12758 }
12759
12760 if (show == 1 || left == 1)
12761 {
12762 for (uint i = 0; i < pot_cnt; i++)
12763 {
12764 pot_t *pot_ptr = &pot[i];
12765
12766 hash_t *hashes_buf = &pot_ptr->hash;
12767
12768 local_free (hashes_buf->digest);
12769
12770 if (isSalted)
12771 {
12772 local_free (hashes_buf->salt);
12773 }
12774 }
12775
12776 local_free (pot);
12777
12778 if (data.quiet == 0) log_info_nn ("");
12779
12780 return (0);
12781 }
12782
12783 if ((keyspace == 0) && (stdout_flag == 0))
12784 {
12785 if (hashes_cnt == 0)
12786 {
12787 log_error ("ERROR: No hashes loaded");
12788
12789 return (-1);
12790 }
12791 }
12792
12793 /**
12794 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12795 */
12796
12797 if (data.outfile != NULL)
12798 {
12799 if (data.hashfile != NULL)
12800 {
12801 #ifdef _POSIX
12802 struct stat tmpstat_outfile;
12803 struct stat tmpstat_hashfile;
12804 #endif
12805
12806 #ifdef _WIN
12807 struct stat64 tmpstat_outfile;
12808 struct stat64 tmpstat_hashfile;
12809 #endif
12810
12811 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12812
12813 if (tmp_outfile_fp)
12814 {
12815 #ifdef _POSIX
12816 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12817 #endif
12818
12819 #ifdef _WIN
12820 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12821 #endif
12822
12823 fclose (tmp_outfile_fp);
12824 }
12825
12826 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12827
12828 if (tmp_hashfile_fp)
12829 {
12830 #ifdef _POSIX
12831 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12832 #endif
12833
12834 #ifdef _WIN
12835 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12836 #endif
12837
12838 fclose (tmp_hashfile_fp);
12839 }
12840
12841 if (tmp_outfile_fp && tmp_outfile_fp)
12842 {
12843 tmpstat_outfile.st_mode = 0;
12844 tmpstat_outfile.st_nlink = 0;
12845 tmpstat_outfile.st_uid = 0;
12846 tmpstat_outfile.st_gid = 0;
12847 tmpstat_outfile.st_rdev = 0;
12848 tmpstat_outfile.st_atime = 0;
12849
12850 tmpstat_hashfile.st_mode = 0;
12851 tmpstat_hashfile.st_nlink = 0;
12852 tmpstat_hashfile.st_uid = 0;
12853 tmpstat_hashfile.st_gid = 0;
12854 tmpstat_hashfile.st_rdev = 0;
12855 tmpstat_hashfile.st_atime = 0;
12856
12857 #ifdef _POSIX
12858 tmpstat_outfile.st_blksize = 0;
12859 tmpstat_outfile.st_blocks = 0;
12860
12861 tmpstat_hashfile.st_blksize = 0;
12862 tmpstat_hashfile.st_blocks = 0;
12863 #endif
12864
12865 #ifdef _POSIX
12866 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12867 {
12868 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12869
12870 return (-1);
12871 }
12872 #endif
12873
12874 #ifdef _WIN
12875 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12876 {
12877 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12878
12879 return (-1);
12880 }
12881 #endif
12882 }
12883 }
12884 }
12885
12886 /**
12887 * Remove duplicates
12888 */
12889
12890 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12891
12892 if (isSalted)
12893 {
12894 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12895 }
12896 else
12897 {
12898 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12899 }
12900
12901 uint hashes_cnt_orig = hashes_cnt;
12902
12903 hashes_cnt = 1;
12904
12905 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12906 {
12907 if (isSalted)
12908 {
12909 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12910 {
12911 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12912 }
12913 }
12914 else
12915 {
12916 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12917 }
12918
12919 if (hashes_pos > hashes_cnt)
12920 {
12921 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12922 }
12923
12924 hashes_cnt++;
12925 }
12926
12927 /**
12928 * Potfile removes
12929 */
12930
12931 uint potfile_remove_cracks = 0;
12932
12933 if (potfile_disable == 0)
12934 {
12935 hash_t hash_buf;
12936
12937 hash_buf.digest = mymalloc (dgst_size);
12938 hash_buf.salt = NULL;
12939 hash_buf.esalt = NULL;
12940 hash_buf.hash_info = NULL;
12941 hash_buf.cracked = 0;
12942
12943 if (isSalted)
12944 {
12945 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12946 }
12947
12948 if (esalt_size)
12949 {
12950 hash_buf.esalt = mymalloc (esalt_size);
12951 }
12952
12953 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12954
12955 // no solution for these special hash types (for instane because they use hashfile in output etc)
12956 if ((hash_mode != 5200) &&
12957 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12958 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12959 (hash_mode != 9000))
12960 {
12961 FILE *fp = fopen (potfile, "rb");
12962
12963 if (fp != NULL)
12964 {
12965 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12966
12967 // to be safe work with a copy (because of line_len loop, i etc)
12968 // moved up here because it's easier to handle continue case
12969 // it's just 64kb
12970
12971 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12972
12973 while (!feof (fp))
12974 {
12975 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12976
12977 if (ptr == NULL) break;
12978
12979 int line_len = strlen (line_buf);
12980
12981 if (line_len == 0) continue;
12982
12983 int iter = MAX_CUT_TRIES;
12984
12985 for (int i = line_len - 1; i && iter; i--, line_len--)
12986 {
12987 if (line_buf[i] != ':') continue;
12988
12989 if (isSalted)
12990 {
12991 memset (hash_buf.salt, 0, sizeof (salt_t));
12992 }
12993
12994 hash_t *found = NULL;
12995
12996 if (hash_mode == 6800)
12997 {
12998 if (i < 64) // 64 = 16 * uint in salt_buf[]
12999 {
13000 // manipulate salt_buf
13001 memcpy (hash_buf.salt->salt_buf, line_buf, i);
13002
13003 hash_buf.salt->salt_len = i;
13004
13005 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
13006 }
13007 }
13008 else if (hash_mode == 2500)
13009 {
13010 if (i < 64) // 64 = 16 * uint in salt_buf[]
13011 {
13012 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
13013 // manipulate salt_buf
13014
13015 memcpy (line_buf_cpy, line_buf, i);
13016
13017 char *mac2_pos = strrchr (line_buf_cpy, ':');
13018
13019 if (mac2_pos == NULL) continue;
13020
13021 mac2_pos[0] = 0;
13022 mac2_pos++;
13023
13024 if (strlen (mac2_pos) != 12) continue;
13025
13026 char *mac1_pos = strrchr (line_buf_cpy, ':');
13027
13028 if (mac1_pos == NULL) continue;
13029
13030 mac1_pos[0] = 0;
13031 mac1_pos++;
13032
13033 if (strlen (mac1_pos) != 12) continue;
13034
13035 uint essid_length = mac1_pos - line_buf_cpy - 1;
13036
13037 // here we need the ESSID
13038 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
13039
13040 hash_buf.salt->salt_len = essid_length;
13041
13042 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
13043
13044 if (found)
13045 {
13046 wpa_t *wpa = (wpa_t *) found->esalt;
13047
13048 // compare hex string(s) vs binary MAC address(es)
13049
13050 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13051 {
13052 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
13053 {
13054 found = NULL;
13055
13056 break;
13057 }
13058 }
13059
13060 // early skip ;)
13061 if (!found) continue;
13062
13063 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13064 {
13065 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
13066 {
13067 found = NULL;
13068
13069 break;
13070 }
13071 }
13072 }
13073 }
13074 }
13075 else
13076 {
13077 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
13078
13079 if (parser_status == PARSER_OK)
13080 {
13081 if (isSalted)
13082 {
13083 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13084 }
13085 else
13086 {
13087 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13088 }
13089 }
13090 }
13091
13092 if (found == NULL) continue;
13093
13094 if (!found->cracked) potfile_remove_cracks++;
13095
13096 found->cracked = 1;
13097
13098 if (found) break;
13099
13100 iter--;
13101 }
13102 }
13103
13104 myfree (line_buf_cpy);
13105
13106 myfree (line_buf);
13107
13108 fclose (fp);
13109 }
13110 }
13111
13112 if (esalt_size)
13113 {
13114 local_free (hash_buf.esalt);
13115 }
13116
13117 if (isSalted)
13118 {
13119 local_free (hash_buf.salt);
13120 }
13121
13122 local_free (hash_buf.digest);
13123 }
13124
13125 /**
13126 * Now generate all the buffers required for later
13127 */
13128
13129 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13130
13131 salt_t *salts_buf_new = NULL;
13132 void *esalts_buf_new = NULL;
13133
13134 if (isSalted)
13135 {
13136 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13137
13138 if (esalt_size)
13139 {
13140 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13141 }
13142 }
13143 else
13144 {
13145 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13146 }
13147
13148 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13149
13150 uint digests_cnt = hashes_cnt;
13151 uint digests_done = 0;
13152
13153 size_t size_digests = digests_cnt * dgst_size;
13154 size_t size_shown = digests_cnt * sizeof (uint);
13155
13156 uint *digests_shown = (uint *) mymalloc (size_shown);
13157 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13158
13159 uint salts_cnt = 0;
13160 uint salts_done = 0;
13161
13162 hashinfo_t **hash_info = NULL;
13163
13164 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13165 {
13166 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13167
13168 if (username && (remove || show))
13169 {
13170 uint user_pos;
13171
13172 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13173 {
13174 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13175
13176 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13177 }
13178 }
13179 }
13180
13181 uint *salts_shown = (uint *) mymalloc (size_shown);
13182
13183 salt_t *salt_buf;
13184
13185 {
13186 // copied from inner loop
13187
13188 salt_buf = &salts_buf_new[salts_cnt];
13189
13190 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13191
13192 if (esalt_size)
13193 {
13194 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13195 }
13196
13197 salt_buf->digests_cnt = 0;
13198 salt_buf->digests_done = 0;
13199 salt_buf->digests_offset = 0;
13200
13201 salts_cnt++;
13202 }
13203
13204 if (hashes_buf[0].cracked == 1)
13205 {
13206 digests_shown[0] = 1;
13207
13208 digests_done++;
13209
13210 salt_buf->digests_done++;
13211 }
13212
13213 salt_buf->digests_cnt++;
13214
13215 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13216
13217 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13218 {
13219 hash_info[0] = hashes_buf[0].hash_info;
13220 }
13221
13222 // copy from inner loop
13223
13224 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13225 {
13226 if (isSalted)
13227 {
13228 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13229 {
13230 salt_buf = &salts_buf_new[salts_cnt];
13231
13232 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13233
13234 if (esalt_size)
13235 {
13236 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13237 }
13238
13239 salt_buf->digests_cnt = 0;
13240 salt_buf->digests_done = 0;
13241 salt_buf->digests_offset = hashes_pos;
13242
13243 salts_cnt++;
13244 }
13245 }
13246
13247 if (hashes_buf[hashes_pos].cracked == 1)
13248 {
13249 digests_shown[hashes_pos] = 1;
13250
13251 digests_done++;
13252
13253 salt_buf->digests_done++;
13254 }
13255
13256 salt_buf->digests_cnt++;
13257
13258 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13259
13260 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13261 {
13262 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13263 }
13264 }
13265
13266 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13267 {
13268 salt_t *salt_buf = &salts_buf_new[salt_pos];
13269
13270 if (salt_buf->digests_done == salt_buf->digests_cnt)
13271 {
13272 salts_shown[salt_pos] = 1;
13273
13274 salts_done++;
13275 }
13276
13277 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13278 }
13279
13280 local_free (digests_buf);
13281 local_free (salts_buf);
13282 local_free (esalts_buf);
13283
13284 digests_buf = digests_buf_new;
13285 salts_buf = salts_buf_new;
13286 esalts_buf = esalts_buf_new;
13287
13288 local_free (hashes_buf);
13289
13290 /**
13291 * special modification not set from parser
13292 */
13293
13294 switch (hash_mode)
13295 {
13296 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13297 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13298 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13299 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13300 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13301 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13302 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13303 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13304 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13305 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13306 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13307 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13308 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13309 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13310 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13311 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13312 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13313 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13314 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13315 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13316 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13317 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13318 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13319 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13320 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13321 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13322 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13323 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13324 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13325 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13326 }
13327
13328 if (truecrypt_keyfiles)
13329 {
13330 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13331
13332 char *keyfiles = strdup (truecrypt_keyfiles);
13333
13334 char *keyfile = strtok (keyfiles, ",");
13335
13336 do
13337 {
13338 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13339
13340 } while ((keyfile = strtok (NULL, ",")) != NULL);
13341
13342 free (keyfiles);
13343 }
13344
13345 if (veracrypt_keyfiles)
13346 {
13347 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13348
13349 char *keyfiles = strdup (veracrypt_keyfiles);
13350
13351 char *keyfile = strtok (keyfiles, ",");
13352
13353 do
13354 {
13355 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13356
13357 } while ((keyfile = strtok (NULL, ",")) != NULL);
13358
13359 free (keyfiles);
13360 }
13361
13362 data.digests_cnt = digests_cnt;
13363 data.digests_done = digests_done;
13364 data.digests_buf = digests_buf;
13365 data.digests_shown = digests_shown;
13366 data.digests_shown_tmp = digests_shown_tmp;
13367
13368 data.salts_cnt = salts_cnt;
13369 data.salts_done = salts_done;
13370 data.salts_buf = salts_buf;
13371 data.salts_shown = salts_shown;
13372
13373 data.esalts_buf = esalts_buf;
13374 data.hash_info = hash_info;
13375
13376 /**
13377 * Automatic Optimizers
13378 */
13379
13380 if (salts_cnt == 1)
13381 opti_type |= OPTI_TYPE_SINGLE_SALT;
13382
13383 if (digests_cnt == 1)
13384 opti_type |= OPTI_TYPE_SINGLE_HASH;
13385
13386 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13387 opti_type |= OPTI_TYPE_NOT_ITERATED;
13388
13389 if (attack_mode == ATTACK_MODE_BF)
13390 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13391
13392 data.opti_type = opti_type;
13393
13394 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13395 {
13396 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13397 {
13398 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13399 {
13400 if (opts_type & OPTS_TYPE_ST_ADD80)
13401 {
13402 opts_type &= ~OPTS_TYPE_ST_ADD80;
13403 opts_type |= OPTS_TYPE_PT_ADD80;
13404 }
13405
13406 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13407 {
13408 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13409 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13410 }
13411
13412 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13413 {
13414 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13415 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13416 }
13417 }
13418 }
13419 }
13420
13421 /**
13422 * Some algorithm, like descrypt, can benefit from JIT compilation
13423 */
13424
13425 int force_jit_compilation = -1;
13426
13427 if (hash_mode == 8900)
13428 {
13429 force_jit_compilation = 8900;
13430 }
13431 else if (hash_mode == 9300)
13432 {
13433 force_jit_compilation = 8900;
13434 }
13435 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13436 {
13437 force_jit_compilation = 1500;
13438 }
13439
13440 /**
13441 * generate bitmap tables
13442 */
13443
13444 const uint bitmap_shift1 = 5;
13445 const uint bitmap_shift2 = 13;
13446
13447 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13448
13449 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13450 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13451 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13452 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13453 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13454 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13455 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13456 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13457
13458 uint bitmap_bits;
13459 uint bitmap_nums;
13460 uint bitmap_mask;
13461 uint bitmap_size;
13462
13463 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13464 {
13465 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13466
13467 bitmap_nums = 1 << bitmap_bits;
13468
13469 bitmap_mask = bitmap_nums - 1;
13470
13471 bitmap_size = bitmap_nums * sizeof (uint);
13472
13473 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13474
13475 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;
13476 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;
13477
13478 break;
13479 }
13480
13481 bitmap_nums = 1 << bitmap_bits;
13482
13483 bitmap_mask = bitmap_nums - 1;
13484
13485 bitmap_size = bitmap_nums * sizeof (uint);
13486
13487 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);
13488 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);
13489
13490 /**
13491 * prepare quick rule
13492 */
13493
13494 data.rule_buf_l = rule_buf_l;
13495 data.rule_buf_r = rule_buf_r;
13496
13497 int rule_len_l = (int) strlen (rule_buf_l);
13498 int rule_len_r = (int) strlen (rule_buf_r);
13499
13500 data.rule_len_l = rule_len_l;
13501 data.rule_len_r = rule_len_r;
13502
13503 /**
13504 * load rules
13505 */
13506
13507 uint *all_kernel_rules_cnt = NULL;
13508
13509 kernel_rule_t **all_kernel_rules_buf = NULL;
13510
13511 if (rp_files_cnt)
13512 {
13513 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13514
13515 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13516 }
13517
13518 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13519
13520 int rule_len = 0;
13521
13522 for (uint i = 0; i < rp_files_cnt; i++)
13523 {
13524 uint kernel_rules_avail = 0;
13525
13526 uint kernel_rules_cnt = 0;
13527
13528 kernel_rule_t *kernel_rules_buf = NULL;
13529
13530 char *rp_file = rp_files[i];
13531
13532 char in[BLOCK_SIZE] = { 0 };
13533 char out[BLOCK_SIZE] = { 0 };
13534
13535 FILE *fp = NULL;
13536
13537 uint rule_line = 0;
13538
13539 if ((fp = fopen (rp_file, "rb")) == NULL)
13540 {
13541 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13542
13543 return (-1);
13544 }
13545
13546 while (!feof (fp))
13547 {
13548 memset (rule_buf, 0, HCBUFSIZ);
13549
13550 rule_len = fgetl (fp, rule_buf);
13551
13552 rule_line++;
13553
13554 if (rule_len == 0) continue;
13555
13556 if (rule_buf[0] == '#') continue;
13557
13558 if (kernel_rules_avail == kernel_rules_cnt)
13559 {
13560 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13561
13562 kernel_rules_avail += INCR_RULES;
13563 }
13564
13565 memset (in, 0, BLOCK_SIZE);
13566 memset (out, 0, BLOCK_SIZE);
13567
13568 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13569
13570 if (result == -1)
13571 {
13572 log_info ("WARNING: Skipping invalid or unsupported rule in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13573
13574 continue;
13575 }
13576
13577 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13578 {
13579 log_info ("WARNING: Cannot convert rule for use on OpenCL device in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13580
13581 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13582
13583 continue;
13584 }
13585
13586 /* its so slow
13587 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13588 {
13589 log_info ("Duplicate rule for use on OpenCL device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13590
13591 continue;
13592 }
13593 */
13594
13595 kernel_rules_cnt++;
13596 }
13597
13598 fclose (fp);
13599
13600 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13601
13602 all_kernel_rules_buf[i] = kernel_rules_buf;
13603 }
13604
13605 /**
13606 * merge rules or automatic rule generator
13607 */
13608
13609 uint kernel_rules_cnt = 0;
13610
13611 kernel_rule_t *kernel_rules_buf = NULL;
13612
13613 if (attack_mode == ATTACK_MODE_STRAIGHT)
13614 {
13615 if (rp_files_cnt)
13616 {
13617 kernel_rules_cnt = 1;
13618
13619 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13620
13621 repeats[0] = kernel_rules_cnt;
13622
13623 for (uint i = 0; i < rp_files_cnt; i++)
13624 {
13625 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13626
13627 repeats[i + 1] = kernel_rules_cnt;
13628 }
13629
13630 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13631
13632 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13633
13634 for (uint i = 0; i < kernel_rules_cnt; i++)
13635 {
13636 uint out_pos = 0;
13637
13638 kernel_rule_t *out = &kernel_rules_buf[i];
13639
13640 for (uint j = 0; j < rp_files_cnt; j++)
13641 {
13642 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13643 uint in_pos;
13644
13645 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13646
13647 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13648 {
13649 if (out_pos == RULES_MAX - 1)
13650 {
13651 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13652
13653 break;
13654 }
13655
13656 out->cmds[out_pos] = in->cmds[in_pos];
13657 }
13658 }
13659 }
13660
13661 local_free (repeats);
13662 }
13663 else if (rp_gen)
13664 {
13665 uint kernel_rules_avail = 0;
13666
13667 while (kernel_rules_cnt < rp_gen)
13668 {
13669 if (kernel_rules_avail == kernel_rules_cnt)
13670 {
13671 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13672
13673 kernel_rules_avail += INCR_RULES;
13674 }
13675
13676 memset (rule_buf, 0, HCBUFSIZ);
13677
13678 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13679
13680 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13681
13682 kernel_rules_cnt++;
13683 }
13684 }
13685 }
13686
13687 myfree (rule_buf);
13688
13689 /**
13690 * generate NOP rules
13691 */
13692
13693 if ((rp_files_cnt == 0) && (rp_gen == 0))
13694 {
13695 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13696
13697 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13698
13699 kernel_rules_cnt++;
13700 }
13701
13702 data.kernel_rules_cnt = kernel_rules_cnt;
13703 data.kernel_rules_buf = kernel_rules_buf;
13704
13705 if (kernel_rules_cnt == 0)
13706 {
13707 log_error ("ERROR: No valid rules left");
13708
13709 return (-1);
13710 }
13711
13712 /**
13713 * OpenCL platforms: detect
13714 */
13715
13716 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13717 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13718
13719 cl_uint platforms_cnt = 0;
13720 cl_uint platform_devices_cnt = 0;
13721
13722 if (keyspace == 0)
13723 {
13724 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13725
13726 if (platforms_cnt == 0)
13727 {
13728 log_info ("");
13729 log_info ("ATTENTION! No OpenCL compatible platform found");
13730 log_info ("");
13731 log_info ("You're probably missing the OpenCL runtime installation");
13732 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13733 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13734 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13735 log_info ("");
13736
13737 return (-1);
13738 }
13739
13740 if (opencl_platforms_filter != (uint) -1)
13741 {
13742 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13743
13744 if (opencl_platforms_filter > platform_cnt_mask)
13745 {
13746 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13747
13748 return (-1);
13749 }
13750 }
13751 }
13752
13753 if (opencl_device_types == NULL)
13754 {
13755 /**
13756 * OpenCL device types:
13757 * 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.
13758 */
13759
13760 cl_device_type device_types_all = 0;
13761
13762 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13763 {
13764 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13765
13766 cl_platform_id platform = platforms[platform_id];
13767
13768 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13769
13770 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13771 {
13772 cl_device_id device = platform_devices[platform_devices_id];
13773
13774 cl_device_type device_type;
13775
13776 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13777
13778 device_types_all |= device_type;
13779 }
13780 }
13781
13782 // In such a case, automatically enable CPU device type support, since it's disabled by default.
13783
13784 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13785 {
13786 device_types_filter |= CL_DEVICE_TYPE_CPU;
13787 }
13788
13789 // In another case, when the user uses --stdout, using CPU devices is much faster to setup
13790 // If we have a CPU device, force it to be used
13791
13792 if (stdout_flag == 1)
13793 {
13794 if (device_types_all & CL_DEVICE_TYPE_CPU)
13795 {
13796 device_types_filter = CL_DEVICE_TYPE_CPU;
13797 }
13798 }
13799 }
13800
13801 /**
13802 * OpenCL devices: simply push all devices from all platforms into the same device array
13803 */
13804
13805 int need_adl = 0;
13806 int need_nvapi = 0;
13807 int need_nvml = 0;
13808 int need_xnvctrl = 0;
13809
13810 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13811
13812 data.devices_param = devices_param;
13813
13814 uint devices_cnt = 0;
13815
13816 uint devices_active = 0;
13817
13818 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13819 {
13820 cl_platform_id platform = platforms[platform_id];
13821
13822 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13823
13824 char platform_vendor[INFOSZ] = { 0 };
13825
13826 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13827
13828 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13829 // this causes trouble with vendor id based macros
13830 // we'll assign generic to those without special optimization available
13831
13832 cl_uint platform_vendor_id = 0;
13833
13834 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13835 {
13836 platform_vendor_id = VENDOR_ID_AMD;
13837 }
13838 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13839 {
13840 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13841 }
13842 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13843 {
13844 platform_vendor_id = VENDOR_ID_APPLE;
13845 }
13846 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13847 {
13848 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13849 }
13850 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13851 {
13852 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13853 }
13854 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13855 {
13856 platform_vendor_id = VENDOR_ID_MESA;
13857 }
13858 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13859 {
13860 platform_vendor_id = VENDOR_ID_NV;
13861 }
13862 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13863 {
13864 platform_vendor_id = VENDOR_ID_POCL;
13865 }
13866 else
13867 {
13868 platform_vendor_id = VENDOR_ID_GENERIC;
13869 }
13870
13871 const uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
13872
13873 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13874 {
13875 if (machine_readable == 0)
13876 {
13877 if (platform_skipped == 0)
13878 {
13879 const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
13880
13881 char line[256] = { 0 };
13882
13883 for (int i = 0; i < len; i++) line[i] = '=';
13884
13885 log_info (line);
13886 }
13887 else
13888 {
13889 log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
13890 log_info ("");
13891 }
13892 }
13893 }
13894
13895 if (platform_skipped == 1) continue;
13896
13897 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13898 {
13899 size_t param_value_size = 0;
13900
13901 const uint device_id = devices_cnt;
13902
13903 hc_device_param_t *device_param = &data.devices_param[device_id];
13904
13905 device_param->platform_vendor_id = platform_vendor_id;
13906
13907 device_param->device = platform_devices[platform_devices_id];
13908
13909 device_param->device_id = device_id;
13910
13911 device_param->platform_devices_id = platform_devices_id;
13912
13913 // device_type
13914
13915 cl_device_type device_type;
13916
13917 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13918
13919 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13920
13921 device_param->device_type = device_type;
13922
13923 // device_name
13924
13925 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13926
13927 char *device_name = (char *) mymalloc (param_value_size);
13928
13929 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13930
13931 device_param->device_name = device_name;
13932
13933 // device_vendor
13934
13935 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13936
13937 char *device_vendor = (char *) mymalloc (param_value_size);
13938
13939 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13940
13941 device_param->device_vendor = device_vendor;
13942
13943 cl_uint device_vendor_id = 0;
13944
13945 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13946 {
13947 device_vendor_id = VENDOR_ID_AMD;
13948 }
13949 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13950 {
13951 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13952 }
13953 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13954 {
13955 device_vendor_id = VENDOR_ID_APPLE;
13956 }
13957 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13958 {
13959 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13960 }
13961 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13962 {
13963 device_vendor_id = VENDOR_ID_INTEL_SDK;
13964 }
13965 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13966 {
13967 device_vendor_id = VENDOR_ID_MESA;
13968 }
13969 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13970 {
13971 device_vendor_id = VENDOR_ID_NV;
13972 }
13973 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13974 {
13975 device_vendor_id = VENDOR_ID_POCL;
13976 }
13977 else
13978 {
13979 device_vendor_id = VENDOR_ID_GENERIC;
13980 }
13981
13982 device_param->device_vendor_id = device_vendor_id;
13983
13984 // tuning db
13985
13986 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13987
13988 // device_version
13989
13990 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13991
13992 char *device_version = (char *) mymalloc (param_value_size);
13993
13994 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13995
13996 device_param->device_version = device_version;
13997
13998 // device_opencl_version
13999
14000 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
14001
14002 char *device_opencl_version = (char *) mymalloc (param_value_size);
14003
14004 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
14005
14006 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
14007
14008 myfree (device_opencl_version);
14009
14010 // vector_width
14011
14012 cl_uint vector_width;
14013
14014 if (opencl_vector_width_chgd == 0)
14015 {
14016 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
14017 {
14018 if (opti_type & OPTI_TYPE_USES_BITS_64)
14019 {
14020 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
14021 }
14022 else
14023 {
14024 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
14025 }
14026 }
14027 else
14028 {
14029 vector_width = (cl_uint) tuningdb_entry->vector_width;
14030 }
14031 }
14032 else
14033 {
14034 vector_width = opencl_vector_width;
14035 }
14036
14037 if (vector_width > 16) vector_width = 16;
14038
14039 device_param->vector_width = vector_width;
14040
14041 // max_compute_units
14042
14043 cl_uint device_processors;
14044
14045 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
14046
14047 device_param->device_processors = device_processors;
14048
14049 // device_maxmem_alloc
14050 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
14051
14052 cl_ulong device_maxmem_alloc;
14053
14054 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
14055
14056 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
14057
14058 // device_global_mem
14059
14060 cl_ulong device_global_mem;
14061
14062 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
14063
14064 device_param->device_global_mem = device_global_mem;
14065
14066 // max_work_group_size
14067
14068 size_t device_maxworkgroup_size;
14069
14070 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
14071
14072 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
14073
14074 // max_clock_frequency
14075
14076 cl_uint device_maxclock_frequency;
14077
14078 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
14079
14080 device_param->device_maxclock_frequency = device_maxclock_frequency;
14081
14082 // device_endian_little
14083
14084 cl_bool device_endian_little;
14085
14086 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
14087
14088 if (device_endian_little == CL_FALSE)
14089 {
14090 log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
14091
14092 device_param->skipped = 1;
14093 }
14094
14095 // device_available
14096
14097 cl_bool device_available;
14098
14099 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
14100
14101 if (device_available == CL_FALSE)
14102 {
14103 log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
14104
14105 device_param->skipped = 1;
14106 }
14107
14108 // device_compiler_available
14109
14110 cl_bool device_compiler_available;
14111
14112 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14113
14114 if (device_compiler_available == CL_FALSE)
14115 {
14116 log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
14117
14118 device_param->skipped = 1;
14119 }
14120
14121 // device_execution_capabilities
14122
14123 cl_device_exec_capabilities device_execution_capabilities;
14124
14125 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14126
14127 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14128 {
14129 log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
14130
14131 device_param->skipped = 1;
14132 }
14133
14134 // device_extensions
14135
14136 size_t device_extensions_size;
14137
14138 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14139
14140 char *device_extensions = mymalloc (device_extensions_size + 1);
14141
14142 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14143
14144 if (strstr (device_extensions, "base_atomics") == 0)
14145 {
14146 log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
14147
14148 device_param->skipped = 1;
14149 }
14150
14151 if (strstr (device_extensions, "byte_addressable_store") == 0)
14152 {
14153 log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
14154
14155 device_param->skipped = 1;
14156 }
14157
14158 myfree (device_extensions);
14159
14160 // device_local_mem_size
14161
14162 cl_ulong device_local_mem_size;
14163
14164 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14165
14166 if (device_local_mem_size < 32768)
14167 {
14168 log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
14169
14170 device_param->skipped = 1;
14171 }
14172
14173 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14174 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14175 // This results in both utilizing it for 50%
14176 // However, Intel has much better SIMD control over their own hardware
14177 // It makes sense to give them full control over their own hardware
14178
14179 if (device_type & CL_DEVICE_TYPE_CPU)
14180 {
14181 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14182 {
14183 if (data.force == 0)
14184 {
14185 if (algorithm_pos == 0)
14186 {
14187 log_info ("- Device #%u: WARNING: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1);
14188 log_info (" You can use --force to override this but do not post error reports if you do so");
14189 }
14190
14191 device_param->skipped = 1;
14192 }
14193 }
14194 }
14195
14196 // skipped
14197
14198 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14199 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14200
14201 // driver_version
14202
14203 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14204
14205 char *driver_version = (char *) mymalloc (param_value_size);
14206
14207 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14208
14209 device_param->driver_version = driver_version;
14210
14211 // device_name_chksum
14212
14213 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14214
14215 #if __x86_64__
14216 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);
14217 #else
14218 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);
14219 #endif
14220
14221 uint device_name_digest[4] = { 0 };
14222
14223 md5_64 ((uint *) device_name_chksum, device_name_digest);
14224
14225 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14226
14227 device_param->device_name_chksum = device_name_chksum;
14228
14229 // vendor specific
14230
14231 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14232 {
14233 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14234 {
14235 need_adl = 1;
14236 }
14237
14238 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14239 {
14240 need_nvml = 1;
14241
14242 #ifdef LINUX
14243 need_xnvctrl = 1;
14244 #endif
14245
14246 #ifdef WIN
14247 need_nvapi = 1;
14248 #endif
14249 }
14250 }
14251
14252 if (device_type & CL_DEVICE_TYPE_GPU)
14253 {
14254 if (device_vendor_id == VENDOR_ID_NV)
14255 {
14256 cl_uint kernel_exec_timeout = 0;
14257
14258 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14259
14260 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14261
14262 device_param->kernel_exec_timeout = kernel_exec_timeout;
14263
14264 cl_uint sm_minor = 0;
14265 cl_uint sm_major = 0;
14266
14267 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14268 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14269
14270 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14271 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14272
14273 device_param->sm_minor = sm_minor;
14274 device_param->sm_major = sm_major;
14275
14276 // CPU burning loop damper
14277 // Value is given as number between 0-100
14278 // By default 100%
14279
14280 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14281
14282 if (nvidia_spin_damp_chgd == 0)
14283 {
14284 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14285 {
14286 /**
14287 * the workaround is not a friend of rule based attacks
14288 * the words from the wordlist combined with fast and slow rules cause
14289 * fluctuations which cause inaccurate wait time estimations
14290 * using a reduced damping percentage almost compensates this
14291 */
14292
14293 device_param->nvidia_spin_damp = 64;
14294 }
14295 }
14296
14297 device_param->nvidia_spin_damp /= 100;
14298 }
14299 }
14300
14301 // display results
14302
14303 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14304 {
14305 if (machine_readable == 0)
14306 {
14307 if (device_param->skipped == 0)
14308 {
14309 log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14310 device_id + 1,
14311 device_name,
14312 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14313 (unsigned int) (device_global_mem / 1024 / 1024),
14314 (unsigned int) device_processors);
14315 }
14316 else
14317 {
14318 log_info ("- Device #%u: %s, skipped",
14319 device_id + 1,
14320 device_name);
14321 }
14322 }
14323 }
14324
14325 // common driver check
14326
14327 if (device_param->skipped == 0)
14328 {
14329 if (device_type & CL_DEVICE_TYPE_GPU)
14330 {
14331 if (platform_vendor_id == VENDOR_ID_AMD)
14332 {
14333 int catalyst_check = (force == 1) ? 0 : 1;
14334
14335 int catalyst_warn = 0;
14336
14337 int catalyst_broken = 0;
14338
14339 if (catalyst_check == 1)
14340 {
14341 catalyst_warn = 1;
14342
14343 // v14.9 and higher
14344 if (atoi (device_param->driver_version) >= 1573)
14345 {
14346 catalyst_warn = 0;
14347 }
14348
14349 catalyst_check = 0;
14350 }
14351
14352 if (catalyst_broken == 1)
14353 {
14354 log_info ("");
14355 log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
14356 log_info ("It passes over cracked hashes and will not report them as cracked");
14357 log_info ("You are STRONGLY encouraged not to use it");
14358 log_info ("You can use --force to override this but do not post error reports if you do so");
14359 log_info ("");
14360
14361 return (-1);
14362 }
14363
14364 if (catalyst_warn == 1)
14365 {
14366 log_info ("");
14367 log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
14368 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
14369 log_info ("See hashcat's homepage for official supported catalyst drivers");
14370 #ifdef _WIN
14371 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14372 #endif
14373 log_info ("You can use --force to override this but do not post error reports if you do so");
14374 log_info ("");
14375
14376 return (-1);
14377 }
14378 }
14379 else if (platform_vendor_id == VENDOR_ID_NV)
14380 {
14381 if (device_param->kernel_exec_timeout != 0)
14382 {
14383 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);
14384 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14385 }
14386 }
14387 }
14388
14389 /* turns out pocl still creates segfaults (because of llvm)
14390 if (device_type & CL_DEVICE_TYPE_CPU)
14391 {
14392 if (platform_vendor_id == VENDOR_ID_AMD)
14393 {
14394 if (force == 0)
14395 {
14396 log_info ("");
14397 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14398 log_info ("You are STRONGLY encouraged not to use it");
14399 log_info ("You can use --force to override this but do not post error reports if you do so");
14400 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14401 log_info ("");
14402
14403 return (-1);
14404 }
14405 }
14406 }
14407 */
14408
14409 /**
14410 * kernel accel and loops tuning db adjustment
14411 */
14412
14413 device_param->kernel_accel_min = 1;
14414 device_param->kernel_accel_max = 1024;
14415
14416 device_param->kernel_loops_min = 1;
14417 device_param->kernel_loops_max = 1024;
14418
14419 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14420
14421 if (tuningdb_entry)
14422 {
14423 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14424 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14425
14426 if (_kernel_accel)
14427 {
14428 device_param->kernel_accel_min = _kernel_accel;
14429 device_param->kernel_accel_max = _kernel_accel;
14430 }
14431
14432 if (_kernel_loops)
14433 {
14434 if (workload_profile == 1)
14435 {
14436 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14437 }
14438 else if (workload_profile == 2)
14439 {
14440 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14441 }
14442
14443 device_param->kernel_loops_min = _kernel_loops;
14444 device_param->kernel_loops_max = _kernel_loops;
14445 }
14446 }
14447
14448 // commandline parameters overwrite tuningdb entries
14449
14450 if (kernel_accel)
14451 {
14452 device_param->kernel_accel_min = kernel_accel;
14453 device_param->kernel_accel_max = kernel_accel;
14454 }
14455
14456 if (kernel_loops)
14457 {
14458 device_param->kernel_loops_min = kernel_loops;
14459 device_param->kernel_loops_max = kernel_loops;
14460 }
14461
14462 /**
14463 * activate device
14464 */
14465
14466 devices_active++;
14467 }
14468
14469 // next please
14470
14471 devices_cnt++;
14472 }
14473
14474 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14475 {
14476 if (machine_readable == 0)
14477 {
14478 log_info ("");
14479 }
14480 }
14481 }
14482
14483 if (keyspace == 0 && devices_active == 0)
14484 {
14485 log_error ("ERROR: No devices found/left");
14486
14487 return (-1);
14488 }
14489
14490 // 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)
14491
14492 if (devices_filter != (uint) -1)
14493 {
14494 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14495
14496 if (devices_filter > devices_cnt_mask)
14497 {
14498 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14499
14500 return (-1);
14501 }
14502 }
14503
14504 data.devices_cnt = devices_cnt;
14505
14506 data.devices_active = devices_active;
14507
14508 /**
14509 * HM devices: init
14510 */
14511
14512 #ifdef HAVE_HWMON
14513 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14514 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14515 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14516 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX] = { { 0 } };
14517
14518 if (gpu_temp_disable == 0)
14519 {
14520 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14521 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14522 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14523 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14524
14525 data.hm_adl = NULL;
14526 data.hm_nvapi = NULL;
14527 data.hm_nvml = NULL;
14528 data.hm_xnvctrl = NULL;
14529
14530 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14531 {
14532 data.hm_nvml = nvml;
14533 }
14534
14535 if (data.hm_nvml)
14536 {
14537 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14538 {
14539 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14540
14541 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14542
14543 int tmp_out = 0;
14544
14545 for (int i = 0; i < tmp_in; i++)
14546 {
14547 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14548 }
14549
14550 for (int i = 0; i < tmp_out; i++)
14551 {
14552 unsigned int speed;
14553
14554 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14555
14556 // doesn't seem to create any advantages
14557 //hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14558 //hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14559 }
14560 }
14561 }
14562
14563 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14564 {
14565 data.hm_nvapi = nvapi;
14566 }
14567
14568 if (data.hm_nvapi)
14569 {
14570 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14571 {
14572 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14573
14574 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14575
14576 int tmp_out = 0;
14577
14578 for (int i = 0; i < tmp_in; i++)
14579 {
14580 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14581 }
14582 }
14583 }
14584
14585 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14586 {
14587 data.hm_xnvctrl = xnvctrl;
14588 }
14589
14590 if (data.hm_xnvctrl)
14591 {
14592 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14593 {
14594 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14595 {
14596 hc_device_param_t *device_param = &data.devices_param[device_id];
14597
14598 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14599
14600 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14601
14602 int speed = 0;
14603
14604 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14605 }
14606 }
14607 }
14608
14609 if ((need_adl == 1) && (adl_init (adl) == 0))
14610 {
14611 data.hm_adl = adl;
14612 }
14613
14614 if (data.hm_adl)
14615 {
14616 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14617 {
14618 // total number of adapters
14619
14620 int hm_adapters_num;
14621
14622 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14623
14624 // adapter info
14625
14626 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14627
14628 if (lpAdapterInfo == NULL) return (-1);
14629
14630 // get a list (of ids of) valid/usable adapters
14631
14632 int num_adl_adapters = 0;
14633
14634 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14635
14636 if (num_adl_adapters > 0)
14637 {
14638 hc_thread_mutex_lock (mux_adl);
14639
14640 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14641
14642 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14643
14644 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14645 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14646
14647 hc_thread_mutex_unlock (mux_adl);
14648 }
14649
14650 myfree (valid_adl_device_list);
14651 myfree (lpAdapterInfo);
14652 }
14653 }
14654
14655 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14656 {
14657 gpu_temp_disable = 1;
14658 }
14659 }
14660
14661 /**
14662 * OpenCL devices: allocate buffer for device specific information
14663 */
14664
14665 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14666
14667 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14668
14669 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14670
14671 /**
14672 * User-defined GPU temp handling
14673 */
14674
14675 if (gpu_temp_disable == 1)
14676 {
14677 gpu_temp_abort = 0;
14678 gpu_temp_retain = 0;
14679 }
14680
14681 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14682 {
14683 if (gpu_temp_abort < gpu_temp_retain)
14684 {
14685 log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14686
14687 return (-1);
14688 }
14689 }
14690
14691 data.gpu_temp_disable = gpu_temp_disable;
14692 data.gpu_temp_abort = gpu_temp_abort;
14693 data.gpu_temp_retain = gpu_temp_retain;
14694 #endif
14695
14696 /**
14697 * enable custom signal handler(s)
14698 */
14699
14700 if (benchmark == 0)
14701 {
14702 hc_signal (sigHandler_default);
14703 }
14704 else
14705 {
14706 hc_signal (sigHandler_benchmark);
14707 }
14708
14709 /**
14710 * inform the user
14711 */
14712
14713 if (data.quiet == 0)
14714 {
14715 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14716
14717 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);
14718
14719 if (attack_mode == ATTACK_MODE_STRAIGHT)
14720 {
14721 log_info ("Rules: %u", kernel_rules_cnt);
14722 }
14723
14724 if (opti_type)
14725 {
14726 log_info ("Applicable Optimizers:");
14727
14728 for (uint i = 0; i < 32; i++)
14729 {
14730 const uint opti_bit = 1u << i;
14731
14732 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14733 }
14734 }
14735
14736 /**
14737 * Watchdog and Temperature balance
14738 */
14739
14740 #ifdef HAVE_HWMON
14741 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14742 {
14743 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14744 }
14745
14746 if (gpu_temp_abort == 0)
14747 {
14748 log_info ("Watchdog: Temperature abort trigger disabled");
14749 }
14750 else
14751 {
14752 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14753 }
14754
14755 if (gpu_temp_retain == 0)
14756 {
14757 log_info ("Watchdog: Temperature retain trigger disabled");
14758 }
14759 else
14760 {
14761 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14762 }
14763
14764 if (data.quiet == 0) log_info ("");
14765 #endif
14766 }
14767
14768 #ifdef HAVE_HWMON
14769
14770 /**
14771 * HM devices: copy
14772 */
14773
14774 if (gpu_temp_disable == 0)
14775 {
14776 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14777 {
14778 hc_device_param_t *device_param = &data.devices_param[device_id];
14779
14780 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14781
14782 if (device_param->skipped) continue;
14783
14784 const uint platform_devices_id = device_param->platform_devices_id;
14785
14786 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14787 {
14788 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14789 data.hm_device[device_id].nvapi = 0;
14790 data.hm_device[device_id].nvml = 0;
14791 data.hm_device[device_id].xnvctrl = 0;
14792 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14793 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14794 data.hm_device[device_id].fan_set_supported = 0;
14795 }
14796
14797 if (device_param->device_vendor_id == VENDOR_ID_NV)
14798 {
14799 data.hm_device[device_id].adl = 0;
14800 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14801 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14802 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14803 data.hm_device[device_id].od_version = 0;
14804 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14805 data.hm_device[device_id].fan_set_supported = 0;
14806 }
14807 }
14808 }
14809
14810 /**
14811 * powertune on user request
14812 */
14813
14814 if (powertune_enable == 1)
14815 {
14816 hc_thread_mutex_lock (mux_adl);
14817
14818 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14819 {
14820 hc_device_param_t *device_param = &data.devices_param[device_id];
14821
14822 if (device_param->skipped) continue;
14823
14824 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14825 {
14826 /**
14827 * Temporary fix:
14828 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14829 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14830 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14831 * Driver / ADL bug?
14832 */
14833
14834 if (data.hm_device[device_id].od_version == 6)
14835 {
14836 int ADL_rc;
14837
14838 // check powertune capabilities first, if not available then skip device
14839
14840 int powertune_supported = 0;
14841
14842 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14843 {
14844 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14845
14846 return (-1);
14847 }
14848
14849 // first backup current value, we will restore it later
14850
14851 if (powertune_supported != 0)
14852 {
14853 // powercontrol settings
14854
14855 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14856
14857 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14858 {
14859 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14860 }
14861
14862 if (ADL_rc != ADL_OK)
14863 {
14864 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14865
14866 return (-1);
14867 }
14868
14869 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14870 {
14871 log_error ("ERROR: Failed to set new ADL PowerControl values");
14872
14873 return (-1);
14874 }
14875
14876 // clocks
14877
14878 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14879
14880 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14881
14882 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)
14883 {
14884 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14885
14886 return (-1);
14887 }
14888
14889 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14890
14891 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14892
14893 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14894 {
14895 log_error ("ERROR: Failed to get ADL device capabilities");
14896
14897 return (-1);
14898 }
14899
14900 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14901 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14902
14903 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14904 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14905
14906 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14907 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14908
14909 // warning if profile has too low max values
14910
14911 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14912 {
14913 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14914 }
14915
14916 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14917 {
14918 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14919 }
14920
14921 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14922
14923 performance_state->iNumberOfPerformanceLevels = 2;
14924
14925 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14926 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14927 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14928 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14929
14930 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)
14931 {
14932 log_info ("ERROR: Failed to set ADL performance state");
14933
14934 return (-1);
14935 }
14936
14937 local_free (performance_state);
14938 }
14939
14940 // set powertune value only
14941
14942 if (powertune_supported != 0)
14943 {
14944 // powertune set
14945 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14946
14947 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14948 {
14949 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14950
14951 return (-1);
14952 }
14953
14954 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14955 {
14956 log_error ("ERROR: Failed to set new ADL PowerControl values");
14957
14958 return (-1);
14959 }
14960 }
14961 }
14962 }
14963
14964 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14965 {
14966 // first backup current value, we will restore it later
14967
14968 unsigned int limit;
14969
14970 int powertune_supported = 0;
14971
14972 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14973 {
14974 powertune_supported = 1;
14975 }
14976
14977 // if backup worked, activate the maximum allowed
14978
14979 if (powertune_supported != 0)
14980 {
14981 unsigned int minLimit;
14982 unsigned int maxLimit;
14983
14984 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14985 {
14986 if (maxLimit > 0)
14987 {
14988 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14989 {
14990 // now we can be sure we need to reset later
14991
14992 nvml_power_limit[device_id] = limit;
14993 }
14994 }
14995 }
14996 }
14997 }
14998 }
14999
15000 hc_thread_mutex_unlock (mux_adl);
15001 }
15002
15003 #endif // HAVE_HWMON
15004
15005 #ifdef DEBUG
15006 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
15007 #endif
15008
15009 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
15010
15011 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15012 {
15013 /**
15014 * host buffer
15015 */
15016
15017 hc_device_param_t *device_param = &data.devices_param[device_id];
15018
15019 if (device_param->skipped) continue;
15020
15021 /**
15022 * device properties
15023 */
15024
15025 const char *device_name_chksum = device_param->device_name_chksum;
15026 const u32 device_processors = device_param->device_processors;
15027
15028 /**
15029 * create context for each device
15030 */
15031
15032 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
15033
15034 /**
15035 * create command-queue
15036 */
15037
15038 // not supported with NV
15039 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
15040
15041 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
15042
15043 /**
15044 * kernel threads: some algorithms need a fixed kernel-threads count
15045 * because of shared memory usage or bitslice
15046 * there needs to be some upper limit, otherwise there's too much overhead
15047 */
15048
15049 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
15050
15051 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
15052 {
15053 kernel_threads = KERNEL_THREADS_MAX_CPU;
15054 }
15055
15056 if (hash_mode == 1500) kernel_threads = 64; // DES
15057 if (hash_mode == 3000) kernel_threads = 64; // DES
15058 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
15059 if (hash_mode == 7500) kernel_threads = 64; // RC4
15060 if (hash_mode == 8900) kernel_threads = 64; // Scrypt
15061 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
15062 if (hash_mode == 9300) kernel_threads = 64; // Scrypt
15063 if (hash_mode == 9700) kernel_threads = 64; // RC4
15064 if (hash_mode == 9710) kernel_threads = 64; // RC4
15065 if (hash_mode == 9800) kernel_threads = 64; // RC4
15066 if (hash_mode == 9810) kernel_threads = 64; // RC4
15067 if (hash_mode == 10400) kernel_threads = 64; // RC4
15068 if (hash_mode == 10410) kernel_threads = 64; // RC4
15069 if (hash_mode == 10500) kernel_threads = 64; // RC4
15070 if (hash_mode == 13100) kernel_threads = 64; // RC4
15071
15072 device_param->kernel_threads = kernel_threads;
15073
15074 device_param->hardware_power = device_processors * kernel_threads;
15075
15076 /**
15077 * create input buffers on device : calculate size of fixed memory buffers
15078 */
15079
15080 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
15081 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15082
15083 device_param->size_root_css = size_root_css;
15084 device_param->size_markov_css = size_markov_css;
15085
15086 size_t size_results = sizeof (uint);
15087
15088 device_param->size_results = size_results;
15089
15090 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
15091 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
15092
15093 size_t size_plains = digests_cnt * sizeof (plain_t);
15094 size_t size_salts = salts_cnt * sizeof (salt_t);
15095 size_t size_esalts = salts_cnt * esalt_size;
15096
15097 device_param->size_plains = size_plains;
15098 device_param->size_digests = size_digests;
15099 device_param->size_shown = size_shown;
15100 device_param->size_salts = size_salts;
15101
15102 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15103 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
15104 size_t size_tm = 32 * sizeof (bs_word_t);
15105
15106 // scryptV stuff
15107
15108 size_t size_scrypt = 4;
15109
15110 if ((hash_mode == 8900) || (hash_mode == 9300))
15111 {
15112 // we need to check that all hashes have the same scrypt settings
15113
15114 const u32 scrypt_N = data.salts_buf[0].scrypt_N;
15115 const u32 scrypt_r = data.salts_buf[0].scrypt_r;
15116 const u32 scrypt_p = data.salts_buf[0].scrypt_p;
15117
15118 for (uint i = 1; i < salts_cnt; i++)
15119 {
15120 if ((data.salts_buf[i].scrypt_N != scrypt_N)
15121 || (data.salts_buf[i].scrypt_r != scrypt_r)
15122 || (data.salts_buf[i].scrypt_p != scrypt_p))
15123 {
15124 log_error ("ERROR: Mixed scrypt settings not supported");
15125
15126 return -1;
15127 }
15128 }
15129
15130 uint tmto_start = 0;
15131 uint tmto_stop = 10;
15132
15133 if (scrypt_tmto)
15134 {
15135 tmto_start = scrypt_tmto;
15136 }
15137 else
15138 {
15139 // in case the user did not specify the tmto manually
15140 // use some values known to run best (tested on 290x for AMD and GTX1080 for NV)
15141
15142 if (hash_mode == 8900)
15143 {
15144 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15145 {
15146 tmto_start = 3;
15147 }
15148 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15149 {
15150 tmto_start = 2;
15151 }
15152 }
15153 else if (hash_mode == 9300)
15154 {
15155 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15156 {
15157 tmto_start = 2;
15158 }
15159 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15160 {
15161 tmto_start = 4;
15162 }
15163 }
15164 }
15165
15166 data.scrypt_tmp_size = (128 * scrypt_r);
15167
15168 device_param->kernel_accel_min = 1;
15169 device_param->kernel_accel_max = 8;
15170
15171 uint tmto;
15172
15173 for (tmto = tmto_start; tmto < tmto_stop; tmto++)
15174 {
15175 size_scrypt = (128 * scrypt_r) * scrypt_N;
15176
15177 size_scrypt /= 1 << tmto;
15178
15179 size_scrypt *= device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel_max;
15180
15181 if ((size_scrypt / 4) > device_param->device_maxmem_alloc)
15182 {
15183 if (quiet == 0) log_info ("WARNING: Not enough single-block device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15184
15185 continue;
15186 }
15187
15188 if (size_scrypt > device_param->device_global_mem)
15189 {
15190 if (quiet == 0) log_info ("WARNING: Not enough total device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15191
15192 continue;
15193 }
15194
15195 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15196 {
15197 data.scrypt_tmto_final = tmto;
15198 }
15199
15200 break;
15201 }
15202
15203 if (tmto == tmto_stop)
15204 {
15205 log_error ("ERROR: Can't allocate enough device memory");
15206
15207 return -1;
15208 }
15209
15210 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.scrypt_tmto_final, size_scrypt);
15211 }
15212
15213 size_t size_scrypt4 = size_scrypt / 4;
15214
15215 /**
15216 * some algorithms need a fixed kernel-loops count
15217 */
15218
15219 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15220 {
15221 const u32 kernel_loops_fixed = 1024;
15222
15223 device_param->kernel_loops_min = kernel_loops_fixed;
15224 device_param->kernel_loops_max = kernel_loops_fixed;
15225 }
15226
15227 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15228 {
15229 const u32 kernel_loops_fixed = 1024;
15230
15231 device_param->kernel_loops_min = kernel_loops_fixed;
15232 device_param->kernel_loops_max = kernel_loops_fixed;
15233 }
15234
15235 if (hash_mode == 8900)
15236 {
15237 const u32 kernel_loops_fixed = 1;
15238
15239 device_param->kernel_loops_min = kernel_loops_fixed;
15240 device_param->kernel_loops_max = kernel_loops_fixed;
15241 }
15242
15243 if (hash_mode == 9300)
15244 {
15245 const u32 kernel_loops_fixed = 1;
15246
15247 device_param->kernel_loops_min = kernel_loops_fixed;
15248 device_param->kernel_loops_max = kernel_loops_fixed;
15249 }
15250
15251 if (hash_mode == 12500)
15252 {
15253 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15254
15255 device_param->kernel_loops_min = kernel_loops_fixed;
15256 device_param->kernel_loops_max = kernel_loops_fixed;
15257 }
15258
15259 /**
15260 * some algorithms have a maximum kernel-loops count
15261 */
15262
15263 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15264 {
15265 u32 innerloop_cnt = 0;
15266
15267 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15268 {
15269 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15270 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15271 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15272 }
15273 else
15274 {
15275 innerloop_cnt = data.salts_buf[0].salt_iter;
15276 }
15277
15278 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15279 (innerloop_cnt <= device_param->kernel_loops_max))
15280 {
15281 device_param->kernel_loops_max = innerloop_cnt;
15282 }
15283 }
15284
15285 u32 kernel_accel_min = device_param->kernel_accel_min;
15286 u32 kernel_accel_max = device_param->kernel_accel_max;
15287
15288 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15289
15290 size_t size_pws = 4;
15291 size_t size_tmps = 4;
15292 size_t size_hooks = 4;
15293
15294 while (kernel_accel_max >= kernel_accel_min)
15295 {
15296 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15297
15298 // size_pws
15299
15300 size_pws = kernel_power_max * sizeof (pw_t);
15301
15302 // size_tmps
15303
15304 switch (hash_mode)
15305 {
15306 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15307 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15308 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15309 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15310 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15311 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15312 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15313 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15314 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15315 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15316 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15317 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15318 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15319 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15320 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15321 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15322 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15323 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15324 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15325 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15326 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15327 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15328 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15329 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15330 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15331 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15332 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15333 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15334 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15335 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15336 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15337 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15338 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15339 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15340 case 8900: size_tmps = kernel_power_max * data.scrypt_tmp_size; break;
15341 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15342 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15343 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15344 case 9300: size_tmps = kernel_power_max * data.scrypt_tmp_size; break;
15345 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15346 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15347 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15348 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15349 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15350 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15351 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15352 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15353 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15354 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15355 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15356 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15357 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15358 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15359 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15360 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15361 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15362 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15363 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15364 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15365 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15366 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15367 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15368 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15369 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15370 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15371 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15372 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15373 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15374 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15375 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15376 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15377 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15378 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15379 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15380 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15381 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15382 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15383 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15384 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15385 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15386 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15387 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15388 };
15389
15390 // size_hooks
15391
15392 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15393 {
15394 switch (hash_mode)
15395 {
15396 }
15397 }
15398
15399 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15400 // if not, decrease amplifier and try again
15401
15402 int memory_limit_hit = 0;
15403
15404 if (size_pws > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15405 if (size_tmps > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15406 if (size_hooks > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15407
15408 const u64 size_total
15409 = bitmap_size
15410 + bitmap_size
15411 + bitmap_size
15412 + bitmap_size
15413 + bitmap_size
15414 + bitmap_size
15415 + bitmap_size
15416 + bitmap_size
15417 + size_bfs
15418 + size_combs
15419 + size_digests
15420 + size_esalts
15421 + size_hooks
15422 + size_markov_css
15423 + size_plains
15424 + size_pws
15425 + size_pws // not a bug
15426 + size_results
15427 + size_root_css
15428 + size_rules
15429 + size_rules_c
15430 + size_salts
15431 + size_scrypt4
15432 + size_scrypt4
15433 + size_scrypt4
15434 + size_scrypt4
15435 + size_shown
15436 + size_tm
15437 + size_tmps;
15438
15439 if (size_total > device_param->device_global_mem) memory_limit_hit = 1;
15440
15441 if (memory_limit_hit == 1)
15442 {
15443 kernel_accel_max--;
15444
15445 continue;
15446 }
15447
15448 break;
15449 }
15450
15451 if (kernel_accel_max < kernel_accel_min)
15452 {
15453 log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle this attack", device_id + 1);
15454
15455 return -1;
15456 }
15457
15458 device_param->kernel_accel_min = kernel_accel_min;
15459 device_param->kernel_accel_max = kernel_accel_max;
15460
15461 /*
15462 if (kernel_accel_max < kernel_accel)
15463 {
15464 if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15465
15466 device_param->kernel_accel = kernel_accel_max;
15467 }
15468 */
15469
15470 device_param->size_bfs = size_bfs;
15471 device_param->size_combs = size_combs;
15472 device_param->size_rules = size_rules;
15473 device_param->size_rules_c = size_rules_c;
15474 device_param->size_pws = size_pws;
15475 device_param->size_tmps = size_tmps;
15476 device_param->size_hooks = size_hooks;
15477
15478 /**
15479 * default building options
15480 */
15481
15482 char cpath[1024] = { 0 };
15483
15484 char build_opts[1024] = { 0 };
15485
15486 #if _WIN
15487
15488 snprintf (cpath, sizeof (cpath) - 1, "%s\\OpenCL\\", shared_dir);
15489
15490 char *cpath_real = mymalloc (MAX_PATH);
15491
15492 if (GetFullPathName (cpath, MAX_PATH, cpath_real, NULL) == 0)
15493 {
15494 log_error ("ERROR: %s: %s", cpath, "GetFullPathName()");
15495
15496 return -1;
15497 }
15498
15499 naive_replace (cpath_real, '\\', '/');
15500
15501 // not escaping here, windows has quotes
15502
15503 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real);
15504
15505 #else
15506
15507 snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir);
15508
15509 char *cpath_real = mymalloc (PATH_MAX);
15510
15511 if (realpath (cpath, cpath_real) == NULL)
15512 {
15513 log_error ("ERROR: %s: %s", cpath, strerror (errno));
15514
15515 return -1;
15516 }
15517
15518 naive_escape (cpath_real, PATH_MAX, ' ', '\\');
15519
15520 snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_real);
15521
15522 #endif
15523
15524 // include check
15525 // this test needs to be done manually because of osx opencl runtime
15526 // if there's a problem with permission, its not reporting back and erroring out silently
15527
15528 #define files_cnt 15
15529
15530 const char *files_names[files_cnt] =
15531 {
15532 "inc_cipher_aes256.cl",
15533 "inc_cipher_serpent256.cl",
15534 "inc_cipher_twofish256.cl",
15535 "inc_common.cl",
15536 "inc_comp_multi_bs.cl",
15537 "inc_comp_multi.cl",
15538 "inc_comp_single_bs.cl",
15539 "inc_comp_single.cl",
15540 "inc_hash_constants.h",
15541 "inc_hash_functions.cl",
15542 "inc_rp.cl",
15543 "inc_rp.h",
15544 "inc_simd.cl",
15545 "inc_types.cl",
15546 "inc_vendor.cl",
15547 };
15548
15549 for (int i = 0; i < files_cnt; i++)
15550 {
15551 char path[1024] = { 0 };
15552
15553 snprintf (path, sizeof (path) - 1, "%s/%s", cpath_real, files_names[i]);
15554
15555 FILE *fd = fopen (path, "r");
15556
15557 if (fd == NULL)
15558 {
15559 log_error ("ERROR: %s: fopen(): %s", path, strerror (errno));
15560
15561 return -1;
15562 }
15563
15564 char buf[1];
15565
15566 size_t n = fread (buf, 1, 1, fd);
15567
15568 if (n != 1)
15569 {
15570 log_error ("ERROR: %s: fread(): %s", path, strerror (errno));
15571
15572 return -1;
15573 }
15574
15575 fclose (fd);
15576 }
15577
15578 myfree (cpath_real);
15579
15580 // we don't have sm_* on vendors not NV but it doesn't matter
15581
15582 char build_opts_new[1024] = { 0 };
15583
15584 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -D VENDOR_ID=%u -D CUDA_ARCH=%d -D VECT_SIZE=%u -D DEVICE_TYPE=%u -D DGST_R0=%u -D DGST_R1=%u -D DGST_R2=%u -D DGST_R3=%u -D DGST_ELEM=%u -D KERN_TYPE=%u -D _unroll -cl-std=CL1.1", build_opts, device_param->device_vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, data.dgst_pos0, data.dgst_pos1, data.dgst_pos2, data.dgst_pos3, data.dgst_size / 4, kern_type);
15585
15586 strncpy (build_opts, build_opts_new, sizeof (build_opts));
15587
15588 #ifdef DEBUG
15589 log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15590 #endif
15591
15592 /**
15593 * main kernel
15594 */
15595
15596 {
15597 /**
15598 * kernel source filename
15599 */
15600
15601 char source_file[256] = { 0 };
15602
15603 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15604
15605 struct stat sst;
15606
15607 if (stat (source_file, &sst) == -1)
15608 {
15609 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15610
15611 return -1;
15612 }
15613
15614 /**
15615 * kernel cached filename
15616 */
15617
15618 char cached_file[256] = { 0 };
15619
15620 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15621
15622 int cached = 1;
15623
15624 struct stat cst;
15625
15626 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15627 {
15628 cached = 0;
15629 }
15630
15631 /**
15632 * kernel compile or load
15633 */
15634
15635 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15636
15637 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15638
15639 if (force_jit_compilation == -1)
15640 {
15641 if (cached == 0)
15642 {
15643 if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
15644
15645 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15646
15647 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15648
15649 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15650
15651 #ifdef DEBUG
15652 size_t build_log_size = 0;
15653
15654 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15655
15656 if (build_log_size > 1)
15657 {
15658 char *build_log = (char *) malloc (build_log_size + 1);
15659
15660 memset (build_log, 0, build_log_size + 1);
15661
15662 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15663
15664 puts (build_log);
15665
15666 free (build_log);
15667 }
15668 #endif
15669
15670 if (rc != 0)
15671 {
15672 device_param->skipped = true;
15673
15674 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15675
15676 continue;
15677 }
15678
15679 size_t binary_size;
15680
15681 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15682
15683 u8 *binary = (u8 *) mymalloc (binary_size);
15684
15685 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15686
15687 writeProgramBin (cached_file, binary, binary_size);
15688
15689 local_free (binary);
15690 }
15691 else
15692 {
15693 #ifdef DEBUG
15694 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15695 #endif
15696
15697 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15698
15699 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15700
15701 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15702 }
15703 }
15704 else
15705 {
15706 #ifdef DEBUG
15707 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15708 #endif
15709
15710 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15711
15712 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15713
15714 char build_opts_update[1024] = { 0 };
15715
15716 if (force_jit_compilation == 1500)
15717 {
15718 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%u", build_opts, data.salts_buf[0].salt_buf[0]);
15719 }
15720 else if (force_jit_compilation == 8900)
15721 {
15722 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DSCRYPT_N=%u -DSCRYPT_R=%u -DSCRYPT_P=%u -DSCRYPT_TMTO=%u -DSCRYPT_TMP_ELEM=%u", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, 1 << data.scrypt_tmto_final, data.scrypt_tmp_size / 16);
15723 }
15724 else
15725 {
15726 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15727 }
15728
15729 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15730
15731 #ifdef DEBUG
15732 size_t build_log_size = 0;
15733
15734 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15735
15736 if (build_log_size > 1)
15737 {
15738 char *build_log = (char *) malloc (build_log_size + 1);
15739
15740 memset (build_log, 0, build_log_size + 1);
15741
15742 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15743
15744 puts (build_log);
15745
15746 free (build_log);
15747 }
15748 #endif
15749
15750 if (rc != 0)
15751 {
15752 device_param->skipped = true;
15753
15754 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15755 }
15756 }
15757
15758 local_free (kernel_lengths);
15759 local_free (kernel_sources[0]);
15760 local_free (kernel_sources);
15761 }
15762
15763 /**
15764 * word generator kernel
15765 */
15766
15767 if (attack_mode != ATTACK_MODE_STRAIGHT)
15768 {
15769 /**
15770 * kernel mp source filename
15771 */
15772
15773 char source_file[256] = { 0 };
15774
15775 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15776
15777 struct stat sst;
15778
15779 if (stat (source_file, &sst) == -1)
15780 {
15781 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15782
15783 return -1;
15784 }
15785
15786 /**
15787 * kernel mp cached filename
15788 */
15789
15790 char cached_file[256] = { 0 };
15791
15792 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15793
15794 int cached = 1;
15795
15796 struct stat cst;
15797
15798 if (stat (cached_file, &cst) == -1)
15799 {
15800 cached = 0;
15801 }
15802
15803 /**
15804 * kernel compile or load
15805 */
15806
15807 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15808
15809 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15810
15811 if (cached == 0)
15812 {
15813 if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
15814 if (quiet == 0) log_info ("");
15815
15816 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15817
15818 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15819
15820 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15821
15822 if (rc != 0)
15823 {
15824 device_param->skipped = true;
15825
15826 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15827
15828 continue;
15829 }
15830
15831 size_t binary_size;
15832
15833 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15834
15835 u8 *binary = (u8 *) mymalloc (binary_size);
15836
15837 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15838
15839 writeProgramBin (cached_file, binary, binary_size);
15840
15841 local_free (binary);
15842 }
15843 else
15844 {
15845 #ifdef DEBUG
15846 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15847 #endif
15848
15849 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15850
15851 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15852
15853 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15854 }
15855
15856 local_free (kernel_lengths);
15857 local_free (kernel_sources[0]);
15858 local_free (kernel_sources);
15859 }
15860
15861 /**
15862 * amplifier kernel
15863 */
15864
15865 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15866 {
15867
15868 }
15869 else
15870 {
15871 /**
15872 * kernel amp source filename
15873 */
15874
15875 char source_file[256] = { 0 };
15876
15877 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15878
15879 struct stat sst;
15880
15881 if (stat (source_file, &sst) == -1)
15882 {
15883 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15884
15885 return -1;
15886 }
15887
15888 /**
15889 * kernel amp cached filename
15890 */
15891
15892 char cached_file[256] = { 0 };
15893
15894 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15895
15896 int cached = 1;
15897
15898 struct stat cst;
15899
15900 if (stat (cached_file, &cst) == -1)
15901 {
15902 cached = 0;
15903 }
15904
15905 /**
15906 * kernel compile or load
15907 */
15908
15909 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15910
15911 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15912
15913 if (cached == 0)
15914 {
15915 if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
15916 if (quiet == 0) log_info ("");
15917
15918 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15919
15920 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15921
15922 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15923
15924 if (rc != 0)
15925 {
15926 device_param->skipped = true;
15927
15928 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15929
15930 continue;
15931 }
15932
15933 size_t binary_size;
15934
15935 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15936
15937 u8 *binary = (u8 *) mymalloc (binary_size);
15938
15939 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15940
15941 writeProgramBin (cached_file, binary, binary_size);
15942
15943 local_free (binary);
15944 }
15945 else
15946 {
15947 #ifdef DEBUG
15948 if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15949 #endif
15950
15951 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15952
15953 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15954
15955 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15956 }
15957
15958 local_free (kernel_lengths);
15959 local_free (kernel_sources[0]);
15960 local_free (kernel_sources);
15961 }
15962
15963 // some algorithm collide too fast, make that impossible
15964
15965 if (benchmark == 1)
15966 {
15967 ((uint *) digests_buf)[0] = -1;
15968 ((uint *) digests_buf)[1] = -1;
15969 ((uint *) digests_buf)[2] = -1;
15970 ((uint *) digests_buf)[3] = -1;
15971 }
15972
15973 /**
15974 * global buffers
15975 */
15976
15977 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15978 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15979 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15980 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15981 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15982 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15983 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15984 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15985 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15986 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15987 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15988 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15989 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15990 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15991 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15992 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15993 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15994 device_param->d_scryptV0_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
15995 device_param->d_scryptV1_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
15996 device_param->d_scryptV2_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
15997 device_param->d_scryptV3_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
15998
15999 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);
16000 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);
16001 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);
16002 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);
16003 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);
16004 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);
16005 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);
16006 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);
16007 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
16008 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
16009 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
16010
16011 /**
16012 * special buffers
16013 */
16014
16015 if (attack_kern == ATTACK_KERN_STRAIGHT)
16016 {
16017 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
16018 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
16019
16020 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
16021 }
16022 else if (attack_kern == ATTACK_KERN_COMBI)
16023 {
16024 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
16025 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
16026 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
16027 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
16028 }
16029 else if (attack_kern == ATTACK_KERN_BF)
16030 {
16031 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
16032 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
16033 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
16034 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
16035 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
16036 }
16037
16038 if (size_esalts)
16039 {
16040 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
16041
16042 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
16043 }
16044
16045 /**
16046 * main host data
16047 */
16048
16049 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
16050
16051 device_param->pws_buf = pws_buf;
16052
16053 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
16054
16055 device_param->combs_buf = combs_buf;
16056
16057 void *hooks_buf = mymalloc (size_hooks);
16058
16059 device_param->hooks_buf = hooks_buf;
16060
16061 /**
16062 * kernel args
16063 */
16064
16065 device_param->kernel_params_buf32[24] = bitmap_mask;
16066 device_param->kernel_params_buf32[25] = bitmap_shift1;
16067 device_param->kernel_params_buf32[26] = bitmap_shift2;
16068 device_param->kernel_params_buf32[27] = 0; // salt_pos
16069 device_param->kernel_params_buf32[28] = 0; // loop_pos
16070 device_param->kernel_params_buf32[29] = 0; // loop_cnt
16071 device_param->kernel_params_buf32[30] = 0; // kernel_rules_cnt
16072 device_param->kernel_params_buf32[31] = 0; // digests_cnt
16073 device_param->kernel_params_buf32[32] = 0; // digests_offset
16074 device_param->kernel_params_buf32[33] = 0; // combs_mode
16075 device_param->kernel_params_buf32[34] = 0; // gid_max
16076
16077 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16078 ? &device_param->d_pws_buf
16079 : &device_param->d_pws_amp_buf;
16080 device_param->kernel_params[ 1] = &device_param->d_rules_c;
16081 device_param->kernel_params[ 2] = &device_param->d_combs_c;
16082 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
16083 device_param->kernel_params[ 4] = &device_param->d_tmps;
16084 device_param->kernel_params[ 5] = &device_param->d_hooks;
16085 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
16086 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
16087 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
16088 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
16089 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
16090 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
16091 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
16092 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
16093 device_param->kernel_params[14] = &device_param->d_plain_bufs;
16094 device_param->kernel_params[15] = &device_param->d_digests_buf;
16095 device_param->kernel_params[16] = &device_param->d_digests_shown;
16096 device_param->kernel_params[17] = &device_param->d_salt_bufs;
16097 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
16098 device_param->kernel_params[19] = &device_param->d_result;
16099 device_param->kernel_params[20] = &device_param->d_scryptV0_buf;
16100 device_param->kernel_params[21] = &device_param->d_scryptV1_buf;
16101 device_param->kernel_params[22] = &device_param->d_scryptV2_buf;
16102 device_param->kernel_params[23] = &device_param->d_scryptV3_buf;
16103 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
16104 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
16105 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
16106 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
16107 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
16108 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
16109 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
16110 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
16111 device_param->kernel_params[32] = &device_param->kernel_params_buf32[32];
16112 device_param->kernel_params[33] = &device_param->kernel_params_buf32[33];
16113 device_param->kernel_params[34] = &device_param->kernel_params_buf32[34];
16114
16115 device_param->kernel_params_mp_buf64[3] = 0;
16116 device_param->kernel_params_mp_buf32[4] = 0;
16117 device_param->kernel_params_mp_buf32[5] = 0;
16118 device_param->kernel_params_mp_buf32[6] = 0;
16119 device_param->kernel_params_mp_buf32[7] = 0;
16120 device_param->kernel_params_mp_buf32[8] = 0;
16121
16122 device_param->kernel_params_mp[0] = NULL;
16123 device_param->kernel_params_mp[1] = NULL;
16124 device_param->kernel_params_mp[2] = NULL;
16125 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
16126 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
16127 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
16128 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
16129 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
16130 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
16131
16132 device_param->kernel_params_mp_l_buf64[3] = 0;
16133 device_param->kernel_params_mp_l_buf32[4] = 0;
16134 device_param->kernel_params_mp_l_buf32[5] = 0;
16135 device_param->kernel_params_mp_l_buf32[6] = 0;
16136 device_param->kernel_params_mp_l_buf32[7] = 0;
16137 device_param->kernel_params_mp_l_buf32[8] = 0;
16138 device_param->kernel_params_mp_l_buf32[9] = 0;
16139
16140 device_param->kernel_params_mp_l[0] = NULL;
16141 device_param->kernel_params_mp_l[1] = NULL;
16142 device_param->kernel_params_mp_l[2] = NULL;
16143 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
16144 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
16145 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
16146 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
16147 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
16148 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
16149 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
16150
16151 device_param->kernel_params_mp_r_buf64[3] = 0;
16152 device_param->kernel_params_mp_r_buf32[4] = 0;
16153 device_param->kernel_params_mp_r_buf32[5] = 0;
16154 device_param->kernel_params_mp_r_buf32[6] = 0;
16155 device_param->kernel_params_mp_r_buf32[7] = 0;
16156 device_param->kernel_params_mp_r_buf32[8] = 0;
16157
16158 device_param->kernel_params_mp_r[0] = NULL;
16159 device_param->kernel_params_mp_r[1] = NULL;
16160 device_param->kernel_params_mp_r[2] = NULL;
16161 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
16162 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
16163 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
16164 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
16165 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
16166 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
16167
16168 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
16169 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
16170
16171 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
16172 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
16173 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
16174 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
16175 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
16176 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
16177 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
16178
16179 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
16180 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
16181
16182 device_param->kernel_params_memset_buf32[1] = 0; // value
16183 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
16184
16185 device_param->kernel_params_memset[0] = NULL;
16186 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
16187 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
16188
16189 /**
16190 * kernel name
16191 */
16192
16193 size_t kernel_wgs_tmp;
16194
16195 char kernel_name[64] = { 0 };
16196
16197 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16198 {
16199 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16200 {
16201 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
16202
16203 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16204
16205 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
16206
16207 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16208
16209 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
16210
16211 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16212 }
16213 else
16214 {
16215 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
16216
16217 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16218
16219 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
16220
16221 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16222
16223 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
16224
16225 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16226 }
16227
16228 if (data.attack_mode == ATTACK_MODE_BF)
16229 {
16230 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16231 {
16232 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
16233
16234 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16235
16236 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);
16237 }
16238 }
16239 }
16240 else
16241 {
16242 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
16243
16244 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16245
16246 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
16247
16248 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16249
16250 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
16251
16252 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16253
16254 if (opts_type & OPTS_TYPE_HOOK12)
16255 {
16256 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16257
16258 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16259
16260 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);
16261 }
16262
16263 if (opts_type & OPTS_TYPE_HOOK23)
16264 {
16265 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16266
16267 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16268
16269 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);
16270 }
16271 }
16272
16273 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);
16274 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);
16275 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);
16276
16277 for (uint i = 0; i <= 23; i++)
16278 {
16279 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16280 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16281 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16282
16283 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16284 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16285 }
16286
16287 for (uint i = 24; i <= 34; i++)
16288 {
16289 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16290 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16291 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16292
16293 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16294 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16295 }
16296
16297 // GPU memset
16298
16299 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16300
16301 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);
16302
16303 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
16304 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16305 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16306
16307 // MP start
16308
16309 if (attack_mode == ATTACK_MODE_BF)
16310 {
16311 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16312 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16313
16314 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);
16315 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);
16316
16317 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16318 {
16319 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16320 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16321 }
16322 }
16323 else if (attack_mode == ATTACK_MODE_HYBRID1)
16324 {
16325 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16326
16327 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);
16328 }
16329 else if (attack_mode == ATTACK_MODE_HYBRID2)
16330 {
16331 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16332
16333 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);
16334 }
16335
16336 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16337 {
16338 // nothing to do
16339 }
16340 else
16341 {
16342 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16343
16344 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);
16345 }
16346
16347 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16348 {
16349 // nothing to do
16350 }
16351 else
16352 {
16353 for (uint i = 0; i < 5; i++)
16354 {
16355 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16356 }
16357
16358 for (uint i = 5; i < 7; i++)
16359 {
16360 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16361 }
16362 }
16363
16364 // maybe this has been updated by clGetKernelWorkGroupInfo()
16365 // value can only be decreased, so we don't need to reallocate buffers
16366
16367 device_param->kernel_threads = kernel_threads;
16368
16369 // zero some data buffers
16370
16371 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16372 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16373 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16374 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16375 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16376 run_kernel_bzero (device_param, device_param->d_result, size_results);
16377
16378 /**
16379 * special buffers
16380 */
16381
16382 if (attack_kern == ATTACK_KERN_STRAIGHT)
16383 {
16384 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16385 }
16386 else if (attack_kern == ATTACK_KERN_COMBI)
16387 {
16388 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16389 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16390 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16391 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16392 }
16393 else if (attack_kern == ATTACK_KERN_BF)
16394 {
16395 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16396 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16397 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16398 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16399 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16400 }
16401
16402 #if defined(HAVE_HWMON)
16403
16404 /**
16405 * Store initial fanspeed if gpu_temp_retain is enabled
16406 */
16407
16408 if (gpu_temp_disable == 0)
16409 {
16410 if (gpu_temp_retain != 0)
16411 {
16412 hc_thread_mutex_lock (mux_adl);
16413
16414 if (data.hm_device[device_id].fan_get_supported == 1)
16415 {
16416 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16417 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16418
16419 // we also set it to tell the OS we take control over the fan and it's automatic controller
16420 // if it was set to automatic. we do not control user-defined fanspeeds.
16421
16422 if (fanpolicy == 1)
16423 {
16424 data.hm_device[device_id].fan_set_supported = 1;
16425
16426 int rc = -1;
16427
16428 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16429 {
16430 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16431 }
16432 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16433 {
16434 #ifdef LINUX
16435 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
16436 #endif
16437
16438 #ifdef WIN
16439 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
16440 #endif
16441 }
16442
16443 if (rc == 0)
16444 {
16445 data.hm_device[device_id].fan_set_supported = 1;
16446 }
16447 else
16448 {
16449 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16450
16451 data.hm_device[device_id].fan_set_supported = 0;
16452 }
16453 }
16454 else
16455 {
16456 data.hm_device[device_id].fan_set_supported = 0;
16457 }
16458 }
16459
16460 hc_thread_mutex_unlock (mux_adl);
16461 }
16462 }
16463
16464 #endif // HAVE_HWMON
16465 }
16466
16467 if (data.quiet == 0) log_info_nn ("");
16468
16469 /**
16470 * In benchmark-mode, inform user which algorithm is checked
16471 */
16472
16473 if (benchmark == 1)
16474 {
16475 if (machine_readable == 0)
16476 {
16477 quiet = 0;
16478
16479 data.quiet = quiet;
16480
16481 char *hash_type = strhashtype (data.hash_mode); // not a bug
16482
16483 log_info ("Hashtype: %s", hash_type);
16484 log_info ("");
16485 }
16486 }
16487
16488 /**
16489 * keep track of the progress
16490 */
16491
16492 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16493 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16494 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16495
16496 /**
16497 * open filehandles
16498 */
16499
16500 #if _WIN
16501 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16502 {
16503 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16504
16505 return (-1);
16506 }
16507
16508 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16509 {
16510 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16511
16512 return (-1);
16513 }
16514
16515 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16516 {
16517 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16518
16519 return (-1);
16520 }
16521 #endif
16522
16523 /**
16524 * dictionary pad
16525 */
16526
16527 segment_size *= (1024 * 1024);
16528
16529 data.segment_size = segment_size;
16530
16531 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16532
16533 wl_data->buf = (char *) mymalloc (segment_size);
16534 wl_data->avail = segment_size;
16535 wl_data->incr = segment_size;
16536 wl_data->cnt = 0;
16537 wl_data->pos = 0;
16538
16539 cs_t *css_buf = NULL;
16540 uint css_cnt = 0;
16541 uint dictcnt = 0;
16542 uint maskcnt = 1;
16543 char **masks = NULL;
16544 char **dictfiles = NULL;
16545
16546 uint mask_from_file = 0;
16547
16548 if (attack_mode == ATTACK_MODE_STRAIGHT)
16549 {
16550 if (wordlist_mode == WL_MODE_FILE)
16551 {
16552 int wls_left = myargc - (optind + 1);
16553
16554 for (int i = 0; i < wls_left; i++)
16555 {
16556 char *l0_filename = myargv[optind + 1 + i];
16557
16558 struct stat l0_stat;
16559
16560 if (stat (l0_filename, &l0_stat) == -1)
16561 {
16562 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16563
16564 return (-1);
16565 }
16566
16567 uint is_dir = S_ISDIR (l0_stat.st_mode);
16568
16569 if (is_dir == 0)
16570 {
16571 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16572
16573 dictcnt++;
16574
16575 dictfiles[dictcnt - 1] = l0_filename;
16576 }
16577 else
16578 {
16579 // do not allow --keyspace w/ a directory
16580
16581 if (keyspace == 1)
16582 {
16583 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16584
16585 return (-1);
16586 }
16587
16588 char **dictionary_files = NULL;
16589
16590 dictionary_files = scan_directory (l0_filename);
16591
16592 if (dictionary_files != NULL)
16593 {
16594 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16595
16596 for (int d = 0; dictionary_files[d] != NULL; d++)
16597 {
16598 char *l1_filename = dictionary_files[d];
16599
16600 struct stat l1_stat;
16601
16602 if (stat (l1_filename, &l1_stat) == -1)
16603 {
16604 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16605
16606 return (-1);
16607 }
16608
16609 if (S_ISREG (l1_stat.st_mode))
16610 {
16611 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16612
16613 dictcnt++;
16614
16615 dictfiles[dictcnt - 1] = strdup (l1_filename);
16616 }
16617 }
16618 }
16619
16620 local_free (dictionary_files);
16621 }
16622 }
16623
16624 if (dictcnt < 1)
16625 {
16626 log_error ("ERROR: No usable dictionary file found.");
16627
16628 return (-1);
16629 }
16630 }
16631 else if (wordlist_mode == WL_MODE_STDIN)
16632 {
16633 dictcnt = 1;
16634 }
16635 }
16636 else if (attack_mode == ATTACK_MODE_COMBI)
16637 {
16638 // display
16639
16640 char *dictfile1 = myargv[optind + 1 + 0];
16641 char *dictfile2 = myargv[optind + 1 + 1];
16642
16643 // find the bigger dictionary and use as base
16644
16645 FILE *fp1 = NULL;
16646 FILE *fp2 = NULL;
16647
16648 struct stat tmp_stat;
16649
16650 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16651 {
16652 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16653
16654 return (-1);
16655 }
16656
16657 if (stat (dictfile1, &tmp_stat) == -1)
16658 {
16659 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16660
16661 fclose (fp1);
16662
16663 return (-1);
16664 }
16665
16666 if (S_ISDIR (tmp_stat.st_mode))
16667 {
16668 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16669
16670 fclose (fp1);
16671
16672 return (-1);
16673 }
16674
16675 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16676 {
16677 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16678
16679 fclose (fp1);
16680
16681 return (-1);
16682 }
16683
16684 if (stat (dictfile2, &tmp_stat) == -1)
16685 {
16686 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16687
16688 fclose (fp1);
16689 fclose (fp2);
16690
16691 return (-1);
16692 }
16693
16694 if (S_ISDIR (tmp_stat.st_mode))
16695 {
16696 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16697
16698 fclose (fp1);
16699 fclose (fp2);
16700
16701 return (-1);
16702 }
16703
16704 data.combs_cnt = 1;
16705
16706 data.quiet = 1;
16707
16708 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16709
16710 data.quiet = quiet;
16711
16712 if (words1_cnt == 0)
16713 {
16714 log_error ("ERROR: %s: empty file", dictfile1);
16715
16716 fclose (fp1);
16717 fclose (fp2);
16718
16719 return (-1);
16720 }
16721
16722 data.combs_cnt = 1;
16723
16724 data.quiet = 1;
16725
16726 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16727
16728 data.quiet = quiet;
16729
16730 if (words2_cnt == 0)
16731 {
16732 log_error ("ERROR: %s: empty file", dictfile2);
16733
16734 fclose (fp1);
16735 fclose (fp2);
16736
16737 return (-1);
16738 }
16739
16740 fclose (fp1);
16741 fclose (fp2);
16742
16743 data.dictfile = dictfile1;
16744 data.dictfile2 = dictfile2;
16745
16746 if (words1_cnt >= words2_cnt)
16747 {
16748 data.combs_cnt = words2_cnt;
16749 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16750
16751 dictfiles = &data.dictfile;
16752
16753 dictcnt = 1;
16754 }
16755 else
16756 {
16757 data.combs_cnt = words1_cnt;
16758 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16759
16760 dictfiles = &data.dictfile2;
16761
16762 dictcnt = 1;
16763
16764 // we also have to switch wordlist related rules!
16765
16766 char *tmpc = data.rule_buf_l;
16767
16768 data.rule_buf_l = data.rule_buf_r;
16769 data.rule_buf_r = tmpc;
16770
16771 int tmpi = data.rule_len_l;
16772
16773 data.rule_len_l = data.rule_len_r;
16774 data.rule_len_r = tmpi;
16775 }
16776 }
16777 else if (attack_mode == ATTACK_MODE_BF)
16778 {
16779 char *mask = NULL;
16780
16781 maskcnt = 0;
16782
16783 if (benchmark == 0)
16784 {
16785 mask = myargv[optind + 1];
16786
16787 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16788
16789 if ((optind + 2) <= myargc)
16790 {
16791 struct stat file_stat;
16792
16793 if (stat (mask, &file_stat) == -1)
16794 {
16795 maskcnt = 1;
16796
16797 masks[maskcnt - 1] = mystrdup (mask);
16798 }
16799 else
16800 {
16801 int wls_left = myargc - (optind + 1);
16802
16803 uint masks_avail = INCR_MASKS;
16804
16805 for (int i = 0; i < wls_left; i++)
16806 {
16807 if (i != 0)
16808 {
16809 mask = myargv[optind + 1 + i];
16810
16811 if (stat (mask, &file_stat) == -1)
16812 {
16813 log_error ("ERROR: %s: %s", mask, strerror (errno));
16814
16815 return (-1);
16816 }
16817 }
16818
16819 uint is_file = S_ISREG (file_stat.st_mode);
16820
16821 if (is_file == 1)
16822 {
16823 FILE *mask_fp;
16824
16825 if ((mask_fp = fopen (mask, "r")) == NULL)
16826 {
16827 log_error ("ERROR: %s: %s", mask, strerror (errno));
16828
16829 return (-1);
16830 }
16831
16832 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16833
16834 while (!feof (mask_fp))
16835 {
16836 memset (line_buf, 0, HCBUFSIZ);
16837
16838 int line_len = fgetl (mask_fp, line_buf);
16839
16840 if (line_len == 0) continue;
16841
16842 if (line_buf[0] == '#') continue;
16843
16844 if (masks_avail == maskcnt)
16845 {
16846 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16847
16848 masks_avail += INCR_MASKS;
16849 }
16850
16851 masks[maskcnt] = mystrdup (line_buf);
16852
16853 maskcnt++;
16854 }
16855
16856 myfree (line_buf);
16857
16858 fclose (mask_fp);
16859 }
16860 else
16861 {
16862 log_error ("ERROR: %s: unsupported file-type", mask);
16863
16864 return (-1);
16865 }
16866 }
16867
16868 mask_from_file = 1;
16869 }
16870 }
16871 else
16872 {
16873 custom_charset_1 = (char *) "?l?d?u";
16874 custom_charset_2 = (char *) "?l?d";
16875 custom_charset_3 = (char *) "?l?d*!$@_";
16876
16877 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16878 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16879 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16880
16881 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16882
16883 wordlist_mode = WL_MODE_MASK;
16884
16885 data.wordlist_mode = wordlist_mode;
16886
16887 increment = 1;
16888
16889 maskcnt = 1;
16890 }
16891 }
16892 else
16893 {
16894 /**
16895 * generate full masks and charsets
16896 */
16897
16898 masks = (char **) mymalloc (sizeof (char *));
16899
16900 switch (hash_mode)
16901 {
16902 case 1731: pw_min = 5;
16903 pw_max = 5;
16904 mask = mystrdup ("?b?b?b?b?b");
16905 break;
16906 case 12500: pw_min = 5;
16907 pw_max = 5;
16908 mask = mystrdup ("?b?b?b?b?b");
16909 break;
16910 default: pw_min = 7;
16911 pw_max = 7;
16912 mask = mystrdup ("?b?b?b?b?b?b?b");
16913 break;
16914 }
16915
16916 maskcnt = 1;
16917
16918 masks[maskcnt - 1] = mystrdup (mask);
16919
16920 wordlist_mode = WL_MODE_MASK;
16921
16922 data.wordlist_mode = wordlist_mode;
16923
16924 increment = 1;
16925 }
16926
16927 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16928
16929 if (increment)
16930 {
16931 if (increment_min > pw_min) pw_min = increment_min;
16932
16933 if (increment_max < pw_max) pw_max = increment_max;
16934 }
16935 }
16936 else if (attack_mode == ATTACK_MODE_HYBRID1)
16937 {
16938 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16939
16940 // display
16941
16942 char *mask = myargv[myargc - 1];
16943
16944 maskcnt = 0;
16945
16946 masks = (char **) mymalloc (1 * sizeof (char *));
16947
16948 // mod
16949
16950 struct stat file_stat;
16951
16952 if (stat (mask, &file_stat) == -1)
16953 {
16954 maskcnt = 1;
16955
16956 masks[maskcnt - 1] = mystrdup (mask);
16957 }
16958 else
16959 {
16960 uint is_file = S_ISREG (file_stat.st_mode);
16961
16962 if (is_file == 1)
16963 {
16964 FILE *mask_fp;
16965
16966 if ((mask_fp = fopen (mask, "r")) == NULL)
16967 {
16968 log_error ("ERROR: %s: %s", mask, strerror (errno));
16969
16970 return (-1);
16971 }
16972
16973 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16974
16975 uint masks_avail = 1;
16976
16977 while (!feof (mask_fp))
16978 {
16979 memset (line_buf, 0, HCBUFSIZ);
16980
16981 int line_len = fgetl (mask_fp, line_buf);
16982
16983 if (line_len == 0) continue;
16984
16985 if (line_buf[0] == '#') continue;
16986
16987 if (masks_avail == maskcnt)
16988 {
16989 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16990
16991 masks_avail += INCR_MASKS;
16992 }
16993
16994 masks[maskcnt] = mystrdup (line_buf);
16995
16996 maskcnt++;
16997 }
16998
16999 myfree (line_buf);
17000
17001 fclose (mask_fp);
17002
17003 mask_from_file = 1;
17004 }
17005 else
17006 {
17007 maskcnt = 1;
17008
17009 masks[maskcnt - 1] = mystrdup (mask);
17010 }
17011 }
17012
17013 // base
17014
17015 int wls_left = myargc - (optind + 2);
17016
17017 for (int i = 0; i < wls_left; i++)
17018 {
17019 char *filename = myargv[optind + 1 + i];
17020
17021 struct stat file_stat;
17022
17023 if (stat (filename, &file_stat) == -1)
17024 {
17025 log_error ("ERROR: %s: %s", filename, strerror (errno));
17026
17027 return (-1);
17028 }
17029
17030 uint is_dir = S_ISDIR (file_stat.st_mode);
17031
17032 if (is_dir == 0)
17033 {
17034 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17035
17036 dictcnt++;
17037
17038 dictfiles[dictcnt - 1] = filename;
17039 }
17040 else
17041 {
17042 // do not allow --keyspace w/ a directory
17043
17044 if (keyspace == 1)
17045 {
17046 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17047
17048 return (-1);
17049 }
17050
17051 char **dictionary_files = NULL;
17052
17053 dictionary_files = scan_directory (filename);
17054
17055 if (dictionary_files != NULL)
17056 {
17057 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17058
17059 for (int d = 0; dictionary_files[d] != NULL; d++)
17060 {
17061 char *l1_filename = dictionary_files[d];
17062
17063 struct stat l1_stat;
17064
17065 if (stat (l1_filename, &l1_stat) == -1)
17066 {
17067 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17068
17069 return (-1);
17070 }
17071
17072 if (S_ISREG (l1_stat.st_mode))
17073 {
17074 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17075
17076 dictcnt++;
17077
17078 dictfiles[dictcnt - 1] = strdup (l1_filename);
17079 }
17080 }
17081 }
17082
17083 local_free (dictionary_files);
17084 }
17085 }
17086
17087 if (dictcnt < 1)
17088 {
17089 log_error ("ERROR: No usable dictionary file found.");
17090
17091 return (-1);
17092 }
17093
17094 if (increment)
17095 {
17096 maskcnt = 0;
17097
17098 uint mask_min = increment_min; // we can't reject smaller masks here
17099 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17100
17101 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17102 {
17103 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17104
17105 if (cur_mask == NULL) break;
17106
17107 masks[maskcnt] = cur_mask;
17108
17109 maskcnt++;
17110
17111 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17112 }
17113 }
17114 }
17115 else if (attack_mode == ATTACK_MODE_HYBRID2)
17116 {
17117 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
17118
17119 // display
17120
17121 char *mask = myargv[optind + 1 + 0];
17122
17123 maskcnt = 0;
17124
17125 masks = (char **) mymalloc (1 * sizeof (char *));
17126
17127 // mod
17128
17129 struct stat file_stat;
17130
17131 if (stat (mask, &file_stat) == -1)
17132 {
17133 maskcnt = 1;
17134
17135 masks[maskcnt - 1] = mystrdup (mask);
17136 }
17137 else
17138 {
17139 uint is_file = S_ISREG (file_stat.st_mode);
17140
17141 if (is_file == 1)
17142 {
17143 FILE *mask_fp;
17144
17145 if ((mask_fp = fopen (mask, "r")) == NULL)
17146 {
17147 log_error ("ERROR: %s: %s", mask, strerror (errno));
17148
17149 return (-1);
17150 }
17151
17152 char *line_buf = (char *) mymalloc (HCBUFSIZ);
17153
17154 uint masks_avail = 1;
17155
17156 while (!feof (mask_fp))
17157 {
17158 memset (line_buf, 0, HCBUFSIZ);
17159
17160 int line_len = fgetl (mask_fp, line_buf);
17161
17162 if (line_len == 0) continue;
17163
17164 if (line_buf[0] == '#') continue;
17165
17166 if (masks_avail == maskcnt)
17167 {
17168 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17169
17170 masks_avail += INCR_MASKS;
17171 }
17172
17173 masks[maskcnt] = mystrdup (line_buf);
17174
17175 maskcnt++;
17176 }
17177
17178 myfree (line_buf);
17179
17180 fclose (mask_fp);
17181
17182 mask_from_file = 1;
17183 }
17184 else
17185 {
17186 maskcnt = 1;
17187
17188 masks[maskcnt - 1] = mystrdup (mask);
17189 }
17190 }
17191
17192 // base
17193
17194 int wls_left = myargc - (optind + 2);
17195
17196 for (int i = 0; i < wls_left; i++)
17197 {
17198 char *filename = myargv[optind + 2 + i];
17199
17200 struct stat file_stat;
17201
17202 if (stat (filename, &file_stat) == -1)
17203 {
17204 log_error ("ERROR: %s: %s", filename, strerror (errno));
17205
17206 return (-1);
17207 }
17208
17209 uint is_dir = S_ISDIR (file_stat.st_mode);
17210
17211 if (is_dir == 0)
17212 {
17213 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17214
17215 dictcnt++;
17216
17217 dictfiles[dictcnt - 1] = filename;
17218 }
17219 else
17220 {
17221 // do not allow --keyspace w/ a directory
17222
17223 if (keyspace == 1)
17224 {
17225 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17226
17227 return (-1);
17228 }
17229
17230 char **dictionary_files = NULL;
17231
17232 dictionary_files = scan_directory (filename);
17233
17234 if (dictionary_files != NULL)
17235 {
17236 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17237
17238 for (int d = 0; dictionary_files[d] != NULL; d++)
17239 {
17240 char *l1_filename = dictionary_files[d];
17241
17242 struct stat l1_stat;
17243
17244 if (stat (l1_filename, &l1_stat) == -1)
17245 {
17246 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17247
17248 return (-1);
17249 }
17250
17251 if (S_ISREG (l1_stat.st_mode))
17252 {
17253 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17254
17255 dictcnt++;
17256
17257 dictfiles[dictcnt - 1] = strdup (l1_filename);
17258 }
17259 }
17260 }
17261
17262 local_free (dictionary_files);
17263 }
17264 }
17265
17266 if (dictcnt < 1)
17267 {
17268 log_error ("ERROR: No usable dictionary file found.");
17269
17270 return (-1);
17271 }
17272
17273 if (increment)
17274 {
17275 maskcnt = 0;
17276
17277 uint mask_min = increment_min; // we can't reject smaller masks here
17278 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17279
17280 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17281 {
17282 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17283
17284 if (cur_mask == NULL) break;
17285
17286 masks[maskcnt] = cur_mask;
17287
17288 maskcnt++;
17289
17290 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17291 }
17292 }
17293 }
17294
17295 data.pw_min = pw_min;
17296 data.pw_max = pw_max;
17297
17298 /**
17299 * weak hash check
17300 */
17301
17302 if (weak_hash_threshold >= salts_cnt)
17303 {
17304 hc_device_param_t *device_param = NULL;
17305
17306 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17307 {
17308 device_param = &data.devices_param[device_id];
17309
17310 if (device_param->skipped) continue;
17311
17312 break;
17313 }
17314
17315 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17316
17317 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17318 {
17319 weak_hash_check (device_param, salt_pos);
17320 }
17321
17322 // Display hack, guarantee that there is at least one \r before real start
17323
17324 //if (data.quiet == 0) log_info ("");
17325 }
17326
17327 /**
17328 * status and monitor threads
17329 */
17330
17331 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17332 {
17333 data.devices_status = STATUS_STARTING;
17334 }
17335
17336 uint inner_threads_cnt = 0;
17337
17338 hc_thread_t *inner_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17339
17340 data.shutdown_inner = 0;
17341
17342 /**
17343 * Outfile remove
17344 */
17345
17346 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
17347 {
17348 hc_thread_create (inner_threads[inner_threads_cnt], thread_monitor, NULL);
17349
17350 inner_threads_cnt++;
17351
17352 if (outfile_check_timer != 0)
17353 {
17354 if (data.outfile_check_directory != NULL)
17355 {
17356 if ((hash_mode != 5200) &&
17357 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17358 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17359 (hash_mode != 9000))
17360 {
17361 hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, NULL);
17362
17363 inner_threads_cnt++;
17364 }
17365 else
17366 {
17367 outfile_check_timer = 0;
17368 }
17369 }
17370 else
17371 {
17372 outfile_check_timer = 0;
17373 }
17374 }
17375 }
17376
17377 /**
17378 * Inform the user if we got some hashes remove because of the pot file remove feature
17379 */
17380
17381 if (data.quiet == 0)
17382 {
17383 if (potfile_remove_cracks > 0)
17384 {
17385 if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
17386 else log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
17387 }
17388 }
17389
17390 data.outfile_check_timer = outfile_check_timer;
17391
17392 /**
17393 * main loop
17394 */
17395
17396 char **induction_dictionaries = NULL;
17397
17398 int induction_dictionaries_cnt = 0;
17399
17400 hcstat_table_t *root_table_buf = NULL;
17401 hcstat_table_t *markov_table_buf = NULL;
17402
17403 uint initial_restore_done = 0;
17404
17405 data.maskcnt = maskcnt;
17406
17407 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17408 {
17409 if (data.devices_status == STATUS_CRACKED) continue;
17410 if (data.devices_status == STATUS_ABORTED) continue;
17411 if (data.devices_status == STATUS_QUIT) continue;
17412
17413 if (maskpos > rd->maskpos)
17414 {
17415 rd->dictpos = 0;
17416 }
17417
17418 rd->maskpos = maskpos;
17419 data.maskpos = maskpos;
17420
17421 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17422 {
17423 char *mask = masks[maskpos];
17424
17425 if (mask_from_file == 1)
17426 {
17427 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17428
17429 char *str_ptr;
17430 uint str_pos;
17431
17432 uint mask_offset = 0;
17433
17434 uint separator_cnt;
17435
17436 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17437 {
17438 str_ptr = strstr (mask + mask_offset, ",");
17439
17440 if (str_ptr == NULL) break;
17441
17442 str_pos = str_ptr - mask;
17443
17444 // escaped separator, i.e. "\,"
17445
17446 if (str_pos > 0)
17447 {
17448 if (mask[str_pos - 1] == '\\')
17449 {
17450 separator_cnt --;
17451
17452 mask_offset = str_pos + 1;
17453
17454 continue;
17455 }
17456 }
17457
17458 // reset the offset
17459
17460 mask_offset = 0;
17461
17462 mask[str_pos] = '\0';
17463
17464 switch (separator_cnt)
17465 {
17466 case 0:
17467 mp_reset_usr (mp_usr, 0);
17468
17469 custom_charset_1 = mask;
17470 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17471 break;
17472
17473 case 1:
17474 mp_reset_usr (mp_usr, 1);
17475
17476 custom_charset_2 = mask;
17477 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17478 break;
17479
17480 case 2:
17481 mp_reset_usr (mp_usr, 2);
17482
17483 custom_charset_3 = mask;
17484 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17485 break;
17486
17487 case 3:
17488 mp_reset_usr (mp_usr, 3);
17489
17490 custom_charset_4 = mask;
17491 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17492 break;
17493 }
17494
17495 mask = mask + str_pos + 1;
17496 }
17497 }
17498
17499 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17500 {
17501 if (maskpos > 0)
17502 {
17503 local_free (css_buf);
17504 local_free (data.root_css_buf);
17505 local_free (data.markov_css_buf);
17506
17507 local_free (masks[maskpos - 1]);
17508 }
17509
17510 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17511
17512 data.mask = mask;
17513 data.css_cnt = css_cnt;
17514 data.css_buf = css_buf;
17515
17516 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17517
17518 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17519
17520 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17521 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17522
17523 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17524
17525 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17526
17527 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17528 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17529
17530 data.root_css_buf = root_css_buf;
17531 data.markov_css_buf = markov_css_buf;
17532
17533 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17534
17535 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17536
17537 local_free (root_table_buf);
17538 local_free (markov_table_buf);
17539
17540 // args
17541
17542 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17543 {
17544 hc_device_param_t *device_param = &data.devices_param[device_id];
17545
17546 if (device_param->skipped) continue;
17547
17548 device_param->kernel_params_mp[0] = &device_param->d_combs;
17549 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17550 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17551
17552 device_param->kernel_params_mp_buf64[3] = 0;
17553 device_param->kernel_params_mp_buf32[4] = css_cnt;
17554 device_param->kernel_params_mp_buf32[5] = 0;
17555 device_param->kernel_params_mp_buf32[6] = 0;
17556 device_param->kernel_params_mp_buf32[7] = 0;
17557
17558 if (attack_mode == ATTACK_MODE_HYBRID1)
17559 {
17560 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17561 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17562 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17563 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17564 }
17565 else if (attack_mode == ATTACK_MODE_HYBRID2)
17566 {
17567 device_param->kernel_params_mp_buf32[5] = 0;
17568 device_param->kernel_params_mp_buf32[6] = 0;
17569 device_param->kernel_params_mp_buf32[7] = 0;
17570 }
17571
17572 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]);
17573 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]);
17574 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]);
17575
17576 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);
17577 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);
17578 }
17579 }
17580 else if (attack_mode == ATTACK_MODE_BF)
17581 {
17582 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17583
17584 if (increment)
17585 {
17586 for (uint i = 0; i < dictcnt; i++)
17587 {
17588 local_free (dictfiles[i]);
17589 }
17590
17591 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17592 {
17593 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17594
17595 if (l1_filename == NULL) break;
17596
17597 dictcnt++;
17598
17599 dictfiles[dictcnt - 1] = l1_filename;
17600 }
17601 }
17602 else
17603 {
17604 dictcnt++;
17605
17606 dictfiles[dictcnt - 1] = mask;
17607 }
17608
17609 if (dictcnt == 0)
17610 {
17611 log_error ("ERROR: Mask is too small");
17612
17613 return (-1);
17614 }
17615 }
17616 }
17617
17618 free (induction_dictionaries);
17619
17620 // induction_dictionaries_cnt = 0; // implied
17621
17622 if (attack_mode != ATTACK_MODE_BF)
17623 {
17624 if (keyspace == 0)
17625 {
17626 induction_dictionaries = scan_directory (induction_directory);
17627
17628 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17629 }
17630 }
17631
17632 if (induction_dictionaries_cnt)
17633 {
17634 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17635 }
17636
17637 /**
17638 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17639 */
17640 if (keyspace == 1)
17641 {
17642 if ((maskcnt > 1) || (dictcnt > 1))
17643 {
17644 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17645
17646 return (-1);
17647 }
17648 }
17649
17650 for (uint dictpos = rd->dictpos; dictpos < dictcnt; dictpos++)
17651 {
17652 if (data.devices_status == STATUS_CRACKED) continue;
17653 if (data.devices_status == STATUS_ABORTED) continue;
17654 if (data.devices_status == STATUS_QUIT) continue;
17655
17656 rd->dictpos = dictpos;
17657
17658 char *subid = logfile_generate_subid ();
17659
17660 data.subid = subid;
17661
17662 logfile_sub_msg ("START");
17663
17664 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17665 {
17666 data.devices_status = STATUS_INIT;
17667 }
17668
17669 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17670 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17671 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17672
17673 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17674
17675 data.cpt_pos = 0;
17676
17677 data.cpt_start = time (NULL);
17678
17679 data.cpt_total = 0;
17680
17681 if (data.restore == 0)
17682 {
17683 rd->words_cur = skip;
17684
17685 skip = 0;
17686
17687 data.skip = 0;
17688 }
17689
17690 data.ms_paused = 0;
17691
17692 data.kernel_power_final = 0;
17693
17694 data.words_cur = rd->words_cur;
17695
17696 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17697 {
17698 hc_device_param_t *device_param = &data.devices_param[device_id];
17699
17700 if (device_param->skipped) continue;
17701
17702 device_param->speed_pos = 0;
17703
17704 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17705 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17706
17707 device_param->exec_pos = 0;
17708
17709 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17710
17711 device_param->outerloop_pos = 0;
17712 device_param->outerloop_left = 0;
17713 device_param->innerloop_pos = 0;
17714 device_param->innerloop_left = 0;
17715
17716 // some more resets:
17717
17718 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17719
17720 device_param->pws_cnt = 0;
17721
17722 device_param->words_off = 0;
17723 device_param->words_done = 0;
17724 }
17725
17726 // figure out some workload
17727
17728 if (attack_mode == ATTACK_MODE_STRAIGHT)
17729 {
17730 if (data.wordlist_mode == WL_MODE_FILE)
17731 {
17732 char *dictfile = NULL;
17733
17734 if (induction_dictionaries_cnt)
17735 {
17736 dictfile = induction_dictionaries[0];
17737 }
17738 else
17739 {
17740 dictfile = dictfiles[dictpos];
17741 }
17742
17743 data.dictfile = dictfile;
17744
17745 logfile_sub_string (dictfile);
17746
17747 for (uint i = 0; i < rp_files_cnt; i++)
17748 {
17749 logfile_sub_var_string ("rulefile", rp_files[i]);
17750 }
17751
17752 FILE *fd2 = fopen (dictfile, "rb");
17753
17754 if (fd2 == NULL)
17755 {
17756 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17757
17758 return (-1);
17759 }
17760
17761 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17762
17763 fclose (fd2);
17764
17765 if (data.words_cnt == 0)
17766 {
17767 logfile_sub_msg ("STOP");
17768
17769 continue;
17770 }
17771 }
17772 }
17773 else if (attack_mode == ATTACK_MODE_COMBI)
17774 {
17775 char *dictfile = data.dictfile;
17776 char *dictfile2 = data.dictfile2;
17777
17778 logfile_sub_string (dictfile);
17779 logfile_sub_string (dictfile2);
17780
17781 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17782 {
17783 FILE *fd2 = fopen (dictfile, "rb");
17784
17785 if (fd2 == NULL)
17786 {
17787 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17788
17789 return (-1);
17790 }
17791
17792 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17793
17794 fclose (fd2);
17795 }
17796 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17797 {
17798 FILE *fd2 = fopen (dictfile2, "rb");
17799
17800 if (fd2 == NULL)
17801 {
17802 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17803
17804 return (-1);
17805 }
17806
17807 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17808
17809 fclose (fd2);
17810 }
17811
17812 if (data.words_cnt == 0)
17813 {
17814 logfile_sub_msg ("STOP");
17815
17816 continue;
17817 }
17818 }
17819 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17820 {
17821 char *dictfile = NULL;
17822
17823 if (induction_dictionaries_cnt)
17824 {
17825 dictfile = induction_dictionaries[0];
17826 }
17827 else
17828 {
17829 dictfile = dictfiles[dictpos];
17830 }
17831
17832 data.dictfile = dictfile;
17833
17834 char *mask = data.mask;
17835
17836 logfile_sub_string (dictfile);
17837 logfile_sub_string (mask);
17838
17839 FILE *fd2 = fopen (dictfile, "rb");
17840
17841 if (fd2 == NULL)
17842 {
17843 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17844
17845 return (-1);
17846 }
17847
17848 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17849
17850 fclose (fd2);
17851
17852 if (data.words_cnt == 0)
17853 {
17854 logfile_sub_msg ("STOP");
17855
17856 continue;
17857 }
17858 }
17859 else if (attack_mode == ATTACK_MODE_BF)
17860 {
17861 local_free (css_buf);
17862 local_free (data.root_css_buf);
17863 local_free (data.markov_css_buf);
17864
17865 char *mask = dictfiles[dictpos];
17866
17867 logfile_sub_string (mask);
17868
17869 // base
17870
17871 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17872
17873 if (opts_type & OPTS_TYPE_PT_UNICODE)
17874 {
17875 uint css_cnt_unicode = css_cnt * 2;
17876
17877 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17878
17879 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17880 {
17881 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17882
17883 css_buf_unicode[j + 1].cs_buf[0] = 0;
17884 css_buf_unicode[j + 1].cs_len = 1;
17885 }
17886
17887 free (css_buf);
17888
17889 css_buf = css_buf_unicode;
17890 css_cnt = css_cnt_unicode;
17891 }
17892
17893 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17894
17895 uint mask_min = pw_min;
17896 uint mask_max = pw_max;
17897
17898 if (opts_type & OPTS_TYPE_PT_UNICODE)
17899 {
17900 mask_min *= 2;
17901 mask_max *= 2;
17902 }
17903
17904 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17905 {
17906 if (css_cnt < mask_min)
17907 {
17908 log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
17909 }
17910
17911 if (css_cnt > mask_max)
17912 {
17913 log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
17914 }
17915
17916 // skip to next mask
17917
17918 logfile_sub_msg ("STOP");
17919
17920 continue;
17921 }
17922
17923 uint save_css_cnt = css_cnt;
17924
17925 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17926 {
17927 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17928 {
17929 uint salt_len = (uint) data.salts_buf[0].salt_len;
17930 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17931
17932 uint css_cnt_salt = css_cnt + salt_len;
17933
17934 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17935
17936 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17937
17938 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17939 {
17940 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17941 css_buf_salt[j].cs_len = 1;
17942 }
17943
17944 free (css_buf);
17945
17946 css_buf = css_buf_salt;
17947 css_cnt = css_cnt_salt;
17948 }
17949 }
17950
17951 data.mask = mask;
17952 data.css_cnt = css_cnt;
17953 data.css_buf = css_buf;
17954
17955 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17956
17957 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17958
17959 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17960
17961 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17962 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17963
17964 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17965
17966 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17967
17968 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17969 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17970
17971 data.root_css_buf = root_css_buf;
17972 data.markov_css_buf = markov_css_buf;
17973
17974 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17975
17976 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17977
17978 local_free (root_table_buf);
17979 local_free (markov_table_buf);
17980
17981 // copy + args
17982
17983 uint css_cnt_l = css_cnt;
17984 uint css_cnt_r;
17985
17986 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17987 {
17988 if (save_css_cnt < 6)
17989 {
17990 css_cnt_r = 1;
17991 }
17992 else if (save_css_cnt == 6)
17993 {
17994 css_cnt_r = 2;
17995 }
17996 else
17997 {
17998 if (opts_type & OPTS_TYPE_PT_UNICODE)
17999 {
18000 if (save_css_cnt == 8 || save_css_cnt == 10)
18001 {
18002 css_cnt_r = 2;
18003 }
18004 else
18005 {
18006 css_cnt_r = 4;
18007 }
18008 }
18009 else
18010 {
18011 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
18012 {
18013 css_cnt_r = 3;
18014 }
18015 else
18016 {
18017 css_cnt_r = 4;
18018 }
18019 }
18020 }
18021 }
18022 else
18023 {
18024 css_cnt_r = 1;
18025
18026 /* unfinished code?
18027 int sum = css_buf[css_cnt_r - 1].cs_len;
18028
18029 for (uint i = 1; i < 4 && i < css_cnt; i++)
18030 {
18031 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
18032
18033 css_cnt_r++;
18034
18035 sum *= css_buf[css_cnt_r - 1].cs_len;
18036 }
18037 */
18038 }
18039
18040 css_cnt_l -= css_cnt_r;
18041
18042 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
18043
18044 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18045 {
18046 hc_device_param_t *device_param = &data.devices_param[device_id];
18047
18048 if (device_param->skipped) continue;
18049
18050 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
18051 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
18052 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
18053
18054 device_param->kernel_params_mp_l_buf64[3] = 0;
18055 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
18056 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
18057 device_param->kernel_params_mp_l_buf32[6] = 0;
18058 device_param->kernel_params_mp_l_buf32[7] = 0;
18059 device_param->kernel_params_mp_l_buf32[8] = 0;
18060
18061 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
18062 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
18063 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
18064 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
18065
18066 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
18067 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
18068 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
18069
18070 device_param->kernel_params_mp_r_buf64[3] = 0;
18071 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
18072 device_param->kernel_params_mp_r_buf32[5] = 0;
18073 device_param->kernel_params_mp_r_buf32[6] = 0;
18074 device_param->kernel_params_mp_r_buf32[7] = 0;
18075
18076 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]);
18077 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]);
18078 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]);
18079
18080 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]);
18081 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]);
18082 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]);
18083
18084 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);
18085 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);
18086 }
18087 }
18088
18089 u64 words_base = data.words_cnt;
18090
18091 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18092 {
18093 if (data.kernel_rules_cnt)
18094 {
18095 words_base /= data.kernel_rules_cnt;
18096 }
18097 }
18098 else if (data.attack_kern == ATTACK_KERN_COMBI)
18099 {
18100 if (data.combs_cnt)
18101 {
18102 words_base /= data.combs_cnt;
18103 }
18104 }
18105 else if (data.attack_kern == ATTACK_KERN_BF)
18106 {
18107 if (data.bfs_cnt)
18108 {
18109 words_base /= data.bfs_cnt;
18110 }
18111 }
18112
18113 data.words_base = words_base;
18114
18115 if (keyspace == 1)
18116 {
18117 log_info ("%llu", (unsigned long long int) words_base);
18118
18119 return (0);
18120 }
18121
18122 if (data.words_cur > data.words_base)
18123 {
18124 log_error ("ERROR: Restore value greater keyspace");
18125
18126 return (-1);
18127 }
18128
18129 if (data.words_cur)
18130 {
18131 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18132 {
18133 for (uint i = 0; i < data.salts_cnt; i++)
18134 {
18135 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
18136 }
18137 }
18138 else if (data.attack_kern == ATTACK_KERN_COMBI)
18139 {
18140 for (uint i = 0; i < data.salts_cnt; i++)
18141 {
18142 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
18143 }
18144 }
18145 else if (data.attack_kern == ATTACK_KERN_BF)
18146 {
18147 for (uint i = 0; i < data.salts_cnt; i++)
18148 {
18149 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
18150 }
18151 }
18152 }
18153
18154 /*
18155 * Update loopback file
18156 */
18157
18158 if (loopback == 1)
18159 {
18160 time_t now;
18161
18162 time (&now);
18163
18164 uint random_num = get_random_num (0, 9999);
18165
18166 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
18167
18168 data.loopback_file = loopback_file;
18169 }
18170
18171 /*
18172 * Update dictionary statistic
18173 */
18174
18175 if (keyspace == 0)
18176 {
18177 dictstat_fp = fopen (dictstat, "wb");
18178
18179 if (dictstat_fp)
18180 {
18181 lock_file (dictstat_fp);
18182
18183 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
18184
18185 fclose (dictstat_fp);
18186 }
18187 }
18188
18189 /**
18190 * create autotune threads
18191 */
18192
18193 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
18194
18195 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18196 {
18197 data.devices_status = STATUS_AUTOTUNE;
18198 }
18199
18200 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18201 {
18202 hc_device_param_t *device_param = &devices_param[device_id];
18203
18204 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
18205 }
18206
18207 hc_thread_wait (data.devices_cnt, c_threads);
18208
18209 /*
18210 * Inform user about possible slow speeds
18211 */
18212
18213 uint hardware_power_all = 0;
18214
18215 uint kernel_power_all = 0;
18216
18217 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18218 {
18219 hc_device_param_t *device_param = &devices_param[device_id];
18220
18221 hardware_power_all += device_param->hardware_power;
18222
18223 kernel_power_all += device_param->kernel_power;
18224 }
18225
18226 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
18227
18228 data.kernel_power_all = kernel_power_all;
18229
18230 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18231 {
18232 if (data.words_base < kernel_power_all)
18233 {
18234 if (quiet == 0)
18235 {
18236 clear_prompt ();
18237
18238 log_info ("ATTENTION!");
18239 log_info (" The wordlist or mask you are using is too small.");
18240 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18241 log_info (" The cracking speed will drop.");
18242 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18243 log_info ("");
18244 }
18245 }
18246 }
18247
18248 /**
18249 * create cracker threads
18250 */
18251
18252 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18253 {
18254 data.devices_status = STATUS_RUNNING;
18255 }
18256
18257 if (initial_restore_done == 0)
18258 {
18259 if (data.restore_disable == 0) cycle_restore ();
18260
18261 initial_restore_done = 1;
18262 }
18263
18264 hc_timer_set (&data.timer_running);
18265
18266 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18267 {
18268 if ((quiet == 0) && (status == 0) && (benchmark == 0))
18269 {
18270 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18271 if (quiet == 0) fflush (stdout);
18272 }
18273 }
18274 else if (wordlist_mode == WL_MODE_STDIN)
18275 {
18276 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18277 if (data.quiet == 0) log_info ("");
18278 }
18279
18280 time_t runtime_start;
18281
18282 time (&runtime_start);
18283
18284 data.runtime_start = runtime_start;
18285
18286 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18287 {
18288 hc_device_param_t *device_param = &devices_param[device_id];
18289
18290 if (wordlist_mode == WL_MODE_STDIN)
18291 {
18292 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18293 }
18294 else
18295 {
18296 hc_thread_create (c_threads[device_id], thread_calc, device_param);
18297 }
18298 }
18299
18300 hc_thread_wait (data.devices_cnt, c_threads);
18301
18302 local_free (c_threads);
18303
18304 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18305 {
18306 data.devices_status = STATUS_EXHAUSTED;
18307 }
18308
18309 logfile_sub_var_uint ("status-after-work", data.devices_status);
18310
18311 data.restore = 0;
18312
18313 if (induction_dictionaries_cnt)
18314 {
18315 unlink (induction_dictionaries[0]);
18316 }
18317
18318 free (induction_dictionaries);
18319
18320 if (attack_mode != ATTACK_MODE_BF)
18321 {
18322 induction_dictionaries = scan_directory (induction_directory);
18323
18324 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18325 }
18326
18327 if (benchmark == 1)
18328 {
18329 status_benchmark ();
18330
18331 if (machine_readable == 0)
18332 {
18333 log_info ("");
18334 }
18335 }
18336 else
18337 {
18338 if (quiet == 0)
18339 {
18340 clear_prompt ();
18341
18342 log_info ("");
18343
18344 status_display ();
18345
18346 log_info ("");
18347 }
18348 else
18349 {
18350 if (status == 1)
18351 {
18352 status_display ();
18353 }
18354 }
18355 }
18356
18357 if (induction_dictionaries_cnt)
18358 {
18359 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18360 }
18361
18362 time_t runtime_stop;
18363
18364 time (&runtime_stop);
18365
18366 data.runtime_stop = runtime_stop;
18367
18368 logfile_sub_uint (runtime_start);
18369 logfile_sub_uint (runtime_stop);
18370
18371 logfile_sub_msg ("STOP");
18372
18373 global_free (subid);
18374
18375 // from this point we handle bypass as running
18376
18377 if (data.devices_status == STATUS_BYPASS)
18378 {
18379 data.devices_status = STATUS_RUNNING;
18380 }
18381
18382 // and overwrite benchmark aborts as well
18383
18384 if (data.benchmark == 1)
18385 {
18386 if (data.devices_status == STATUS_ABORTED)
18387 {
18388 data.devices_status = STATUS_RUNNING;
18389 }
18390 }
18391
18392 // finalize task
18393
18394 if (data.devices_status == STATUS_CRACKED) break;
18395 if (data.devices_status == STATUS_ABORTED) break;
18396 if (data.devices_status == STATUS_QUIT) break;
18397 }
18398
18399 if (data.devices_status == STATUS_CRACKED) break;
18400 if (data.devices_status == STATUS_ABORTED) break;
18401 if (data.devices_status == STATUS_QUIT) break;
18402 }
18403
18404 // 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
18405 if (attack_mode == ATTACK_MODE_STRAIGHT)
18406 {
18407 if (data.wordlist_mode == WL_MODE_FILE)
18408 {
18409 if (data.dictfile == NULL)
18410 {
18411 if (dictfiles != NULL)
18412 {
18413 data.dictfile = dictfiles[0];
18414
18415 hc_timer_set (&data.timer_running);
18416 }
18417 }
18418 }
18419 }
18420 // NOTE: combi is okay because it is already set beforehand
18421 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18422 {
18423 if (data.dictfile == NULL)
18424 {
18425 if (dictfiles != NULL)
18426 {
18427 hc_timer_set (&data.timer_running);
18428
18429 data.dictfile = dictfiles[0];
18430 }
18431 }
18432 }
18433 else if (attack_mode == ATTACK_MODE_BF)
18434 {
18435 if (data.mask == NULL)
18436 {
18437 hc_timer_set (&data.timer_running);
18438
18439 data.mask = masks[0];
18440 }
18441 }
18442
18443 // if cracked / aborted remove last induction dictionary
18444
18445 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18446 {
18447 struct stat induct_stat;
18448
18449 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18450 {
18451 unlink (induction_dictionaries[file_pos]);
18452 }
18453 }
18454
18455 // wait for inner threads
18456
18457 data.shutdown_inner = 1;
18458
18459 for (uint thread_idx = 0; thread_idx < inner_threads_cnt; thread_idx++)
18460 {
18461 hc_thread_wait (1, &inner_threads[thread_idx]);
18462 }
18463
18464 local_free (inner_threads);
18465
18466 // we dont need restore file anymore
18467 if (data.restore_disable == 0)
18468 {
18469 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18470 {
18471 unlink (eff_restore_file);
18472 unlink (new_restore_file);
18473 }
18474 else
18475 {
18476 cycle_restore ();
18477 }
18478 }
18479
18480 // finally save left hashes
18481
18482 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18483 {
18484 save_hash ();
18485 }
18486
18487 /**
18488 * Clean up
18489 */
18490
18491 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18492 {
18493 hc_device_param_t *device_param = &data.devices_param[device_id];
18494
18495 if (device_param->skipped) continue;
18496
18497 local_free (device_param->combs_buf);
18498 local_free (device_param->hooks_buf);
18499 local_free (device_param->device_name);
18500 local_free (device_param->device_name_chksum);
18501 local_free (device_param->device_version);
18502 local_free (device_param->driver_version);
18503
18504 if (device_param->pws_buf) myfree (device_param->pws_buf);
18505 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18506 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18507 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18508 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18509 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18510 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18511 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18512 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18513 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18514 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18515 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18516 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18517 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18518 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18519 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18520 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18521 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18522 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18523 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18524 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18525 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18526 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18527 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18528 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18529 if (device_param->d_scryptV0_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV0_buf);
18530 if (device_param->d_scryptV1_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV1_buf);
18531 if (device_param->d_scryptV2_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV2_buf);
18532 if (device_param->d_scryptV3_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV3_buf);
18533 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18534 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18535 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18536
18537 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18538 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18539 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18540 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18541 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18542 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18543 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18544 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18545 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18546 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18547 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18548
18549 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18550 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18551 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18552
18553 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18554 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18555 }
18556
18557 // reset default fan speed
18558
18559 #ifdef HAVE_HWMON
18560 if (gpu_temp_disable == 0)
18561 {
18562 if (gpu_temp_retain != 0)
18563 {
18564 hc_thread_mutex_lock (mux_adl);
18565
18566 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18567 {
18568 hc_device_param_t *device_param = &data.devices_param[device_id];
18569
18570 if (device_param->skipped) continue;
18571
18572 if (data.hm_device[device_id].fan_set_supported == 1)
18573 {
18574 int rc = -1;
18575
18576 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18577 {
18578 rc = hm_set_fanspeed_with_device_id_adl (device_id, 100, 0);
18579 }
18580 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18581 {
18582 #ifdef LINUX
18583 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
18584 #endif
18585
18586 #ifdef WIN
18587 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, 100, 0);
18588 #endif
18589 }
18590
18591 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18592 }
18593 }
18594
18595 hc_thread_mutex_unlock (mux_adl);
18596 }
18597 }
18598
18599 // reset power tuning
18600
18601 if (powertune_enable == 1)
18602 {
18603 hc_thread_mutex_lock (mux_adl);
18604
18605 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18606 {
18607 hc_device_param_t *device_param = &data.devices_param[device_id];
18608
18609 if (device_param->skipped) continue;
18610
18611 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18612 {
18613 if (data.hm_device[device_id].od_version == 6)
18614 {
18615 // check powertune capabilities first, if not available then skip device
18616
18617 int powertune_supported = 0;
18618
18619 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18620 {
18621 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18622
18623 return (-1);
18624 }
18625
18626 if (powertune_supported != 0)
18627 {
18628 // powercontrol settings
18629
18630 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18631 {
18632 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18633
18634 return (-1);
18635 }
18636
18637 // clocks
18638
18639 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18640
18641 performance_state->iNumberOfPerformanceLevels = 2;
18642
18643 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18644 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18645 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18646 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18647
18648 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18649 {
18650 log_info ("ERROR: Failed to restore ADL performance state");
18651
18652 return (-1);
18653 }
18654
18655 local_free (performance_state);
18656 }
18657 }
18658 }
18659
18660 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18661 {
18662 unsigned int limit = nvml_power_limit[device_id];
18663
18664 if (limit > 0)
18665 {
18666 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18667 }
18668 }
18669 }
18670
18671 hc_thread_mutex_unlock (mux_adl);
18672 }
18673
18674 if (gpu_temp_disable == 0)
18675 {
18676 if (data.hm_nvml)
18677 {
18678 hm_NVML_nvmlShutdown (data.hm_nvml);
18679
18680 nvml_close (data.hm_nvml);
18681
18682 data.hm_nvml = NULL;
18683 }
18684
18685 if (data.hm_nvapi)
18686 {
18687 hm_NvAPI_Unload (data.hm_nvapi);
18688
18689 nvapi_close (data.hm_nvapi);
18690
18691 data.hm_nvapi = NULL;
18692 }
18693
18694 if (data.hm_xnvctrl)
18695 {
18696 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18697
18698 xnvctrl_close (data.hm_xnvctrl);
18699
18700 data.hm_xnvctrl = NULL;
18701 }
18702
18703 if (data.hm_adl)
18704 {
18705 hm_ADL_Main_Control_Destroy (data.hm_adl);
18706
18707 adl_close (data.hm_adl);
18708
18709 data.hm_adl = NULL;
18710 }
18711 }
18712 #endif // HAVE_HWMON
18713
18714 // free memory
18715
18716 local_free (masks);
18717
18718 local_free (dictstat_base);
18719
18720 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18721 {
18722 pot_t *pot_ptr = &pot[pot_pos];
18723
18724 hash_t *hash = &pot_ptr->hash;
18725
18726 local_free (hash->digest);
18727
18728 if (isSalted)
18729 {
18730 local_free (hash->salt);
18731 }
18732 }
18733
18734 local_free (pot);
18735
18736 local_free (all_kernel_rules_cnt);
18737 local_free (all_kernel_rules_buf);
18738
18739 local_free (wl_data->buf);
18740 local_free (wl_data);
18741
18742 local_free (bitmap_s1_a);
18743 local_free (bitmap_s1_b);
18744 local_free (bitmap_s1_c);
18745 local_free (bitmap_s1_d);
18746 local_free (bitmap_s2_a);
18747 local_free (bitmap_s2_b);
18748 local_free (bitmap_s2_c);
18749 local_free (bitmap_s2_d);
18750
18751 #ifdef HAVE_HWMON
18752 local_free (od_clock_mem_status);
18753 local_free (od_power_control_status);
18754 local_free (nvml_power_limit);
18755 #endif
18756
18757 global_free (devices_param);
18758
18759 global_free (kernel_rules_buf);
18760
18761 global_free (root_css_buf);
18762 global_free (markov_css_buf);
18763
18764 global_free (digests_buf);
18765 global_free (digests_shown);
18766 global_free (digests_shown_tmp);
18767
18768 global_free (salts_buf);
18769 global_free (salts_shown);
18770
18771 global_free (esalts_buf);
18772
18773 global_free (words_progress_done);
18774 global_free (words_progress_rejected);
18775 global_free (words_progress_restored);
18776
18777 if (pot_fp) fclose (pot_fp);
18778
18779 if (data.devices_status == STATUS_QUIT) break;
18780 }
18781
18782 // wait for outer threads
18783
18784 data.shutdown_outer = 1;
18785
18786 for (uint thread_idx = 0; thread_idx < outer_threads_cnt; thread_idx++)
18787 {
18788 hc_thread_wait (1, &outer_threads[thread_idx]);
18789 }
18790
18791 local_free (outer_threads);
18792
18793 // destroy others mutex
18794
18795 hc_thread_mutex_delete (mux_dispatcher);
18796 hc_thread_mutex_delete (mux_counter);
18797 hc_thread_mutex_delete (mux_display);
18798 hc_thread_mutex_delete (mux_adl);
18799
18800 // free memory
18801
18802 local_free (eff_restore_file);
18803 local_free (new_restore_file);
18804
18805 local_free (rd);
18806
18807 // tuning db
18808
18809 tuning_db_destroy (tuning_db);
18810
18811 // loopback
18812
18813 local_free (loopback_file);
18814
18815 if (loopback == 1) unlink (loopback_file);
18816
18817 // induction directory
18818
18819 if (induction_dir == NULL)
18820 {
18821 if (attack_mode != ATTACK_MODE_BF)
18822 {
18823 if (rmdir (induction_directory) == -1)
18824 {
18825 if (errno == ENOENT)
18826 {
18827 // good, we can ignore
18828 }
18829 else if (errno == ENOTEMPTY)
18830 {
18831 // good, we can ignore
18832 }
18833 else
18834 {
18835 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18836
18837 return (-1);
18838 }
18839 }
18840
18841 local_free (induction_directory);
18842 }
18843 }
18844
18845 // outfile-check directory
18846
18847 if (outfile_check_dir == NULL)
18848 {
18849 if (rmdir (outfile_check_directory) == -1)
18850 {
18851 if (errno == ENOENT)
18852 {
18853 // good, we can ignore
18854 }
18855 else if (errno == ENOTEMPTY)
18856 {
18857 // good, we can ignore
18858 }
18859 else
18860 {
18861 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18862
18863 return (-1);
18864 }
18865 }
18866
18867 local_free (outfile_check_directory);
18868 }
18869
18870 time_t proc_stop;
18871
18872 time (&proc_stop);
18873
18874 logfile_top_uint (proc_start);
18875 logfile_top_uint (proc_stop);
18876
18877 logfile_top_msg ("STOP");
18878
18879 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18880 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18881
18882 if (data.ocl) ocl_close (data.ocl);
18883
18884 if (data.devices_status == STATUS_ABORTED) return 2;
18885 if (data.devices_status == STATUS_QUIT) return 2;
18886 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18887 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18888 if (data.devices_status == STATUS_CRACKED) return 0;
18889
18890 return -1;
18891 }
Hashcat additions to support pwdhash